path: root/src/tpm12/tpm_storage.c

/********************************************************************************/
/*										*/
/*				Storage Functions				*/
/*			     Written by Ken Goldman				*/
/*		       IBM Thomas J. Watson Research Center			*/
/*	      $Id: tpm_storage.c 4442 2011-02-14 20:20:01Z kgoldman $		*/
/*										*/
/* (c) Copyright IBM Corporation 2006, 2010.					*/
/*										*/
/* All rights reserved.								*/
/* 										*/
/* Redistribution and use in source and binary forms, with or without		*/
/* modification, are permitted provided that the following conditions are	*/
/* met:										*/
/* 										*/
/* Redistributions of source code must retain the above copyright notice,	*/
/* this list of conditions and the following disclaimer.			*/
/* 										*/
/* Redistributions in binary form must reproduce the above copyright		*/
/* notice, this list of conditions and the following disclaimer in the		*/
/* documentation and/or other materials provided with the distribution.		*/
/* 										*/
/* Neither the names of the IBM Corporation nor the names of its		*/
/* contributors may be used to endorse or promote products derived from		*/
/* this software without specific prior written permission.			*/
/* 										*/
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS		*/
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT		*/
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR	*/
/* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT		*/
/* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,	*/
/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT		*/
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	*/
/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	*/
/* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		*/
/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	*/
/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		*/
/********************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "tpm_auth.h"
#include "tpm_cryptoh.h"
#include "tpm_crypto.h"
#include "tpm_debug.h"
#include "tpm_digest.h"
#include "tpm_error.h"
#include "tpm_io.h"
#include "tpm_key.h"
#include "tpm_memory.h"
#include "tpm_nonce.h"
#include "tpm_pcr.h"
#include "tpm_process.h"
#include "tpm_secret.h"
#include "tpm_structures.h"
#include "tpm_ver.h"

#include "tpm_storage.h"

/* local function prototypes */

static TPM_RESULT TPM_SealCryptCommon(BYTE **o1,
				      TPM_ADIP_ENC_SCHEME adipEncScheme,
				      TPM_SIZED_BUFFER *inData,
				      TPM_AUTH_SESSION_DATA *auth_session_data,
				      TPM_NONCE nonceOdd);

static TPM_RESULT TPM_LoadKeyCommon(TPM_KEY_HANDLE	*inKeyHandle,
				    TPM_BOOL		*key_added,
				    TPM_SECRET		**hmacKey,
				    TPM_AUTH_SESSION_DATA	**auth_session_data,
				    tpm_state_t		*tpm_state,
				    TPM_TAG		tag,
				    TPM_COMMAND_CODE	ordinal,
				    TPM_KEY_HANDLE	parentHandle,
				    TPM_KEY		*inKey,
				    TPM_DIGEST		inParamDigest,
				    TPM_AUTHHANDLE	authHandle,
				    TPM_NONCE		nonceOdd,
				    TPM_BOOL		continueAuthSession,
				    TPM_AUTHDATA	parentAuth);

/*
  TPM_BOUND_DATA
*/

/* TPM_BoundData_Init()

   sets members to default values
   sets all pointers to NULL and sizes to 0
   always succeeds - no return code
*/

void TPM_BoundData_Init(TPM_BOUND_DATA *tpm_bound_data)
{
    printf(" TPM_BoundData_Init:\n");
    TPM_StructVer_Init(&(tpm_bound_data->ver));
    tpm_bound_data->payload = TPM_PT_BIND;
    tpm_bound_data->payloadDataSize = 0;
    tpm_bound_data->payloadData = NULL;
    return;
}

/* TPM_BoundData_Load()

   deserialize the structure from a 'stream'
   'stream_size' is checked for sufficient data
   returns 0 or error codes
   
   Before use, call TPM_BoundData_Init()
   After use, call TPM_BoundData_Delete() to free memory
*/

TPM_RESULT TPM_BoundData_Load(TPM_BOUND_DATA *tpm_bound_data,
			      unsigned char **stream,
			      uint32_t *stream_size)
{
    TPM_RESULT		rc = 0;

    printf(" TPM_BoundData_Load:\n");
    if (rc == 0) {
	rc = TPM_StructVer_Load(&(tpm_bound_data->ver), stream, stream_size);
    }
    /* check ver immediately to ease debugging */
    if (rc == 0) {
	rc = TPM_StructVer_CheckVer(&(tpm_bound_data->ver));
    }
    if (rc == 0) {
	rc = TPM_Load8(&(tpm_bound_data->payload), stream, stream_size);
    }
    if ((rc == 0) && (*stream_size > 0)){
	/* There is no payloadData size in the serialized data.	 Assume it consumes the rest of the
	   stream */
	tpm_bound_data->payloadDataSize = *stream_size;
	rc = TPM_Malloc(&(tpm_bound_data->payloadData), tpm_bound_data->payloadDataSize);
    }
    if ((rc == 0) && (*stream_size > 0)){
	memcpy(tpm_bound_data->payloadData, *stream, tpm_bound_data->payloadDataSize);
	*stream += tpm_bound_data->payloadDataSize;
	*stream_size -= tpm_bound_data->payloadDataSize;
    }
    return rc;
}

#if 0
/* TPM_BoundData_Store()
   
   serialize the structure to a stream contained in 'sbuffer'
   returns 0 or error codes

   This structure serialization assumes that the payloadDataSize member indicates the size of
   payloadData.
*/

TPM_RESULT TPM_BoundData_Store(TPM_STORE_BUFFER *sbuffer,
			       const TPM_BOUND_DATA *tpm_bound_data)
{
    TPM_RESULT		rc = 0;

    printf(" TPM_BoundData_Store:\n");
    if (rc == 0) {
	rc = TPM_StructVer_Store(sbuffer, &(tpm_bound_data->ver));
    }
    if (rc == 0) {
	rc = TPM_Sbuffer_Append(sbuffer, &(tpm_bound_data->payload), sizeof(TPM_PAYLOAD_TYPE));
    }
    if (rc == 0) {
	rc = TPM_Sbuffer_Append(sbuffer, tpm_bound_data->payloadData,
				tpm_bound_data->payloadDataSize);
    }
    return rc;
}
#endif

/* TPM_BoundData_Delete()

   No-OP if the parameter is NULL, else:
   frees memory allocated for the bound_data
   sets pointers to NULL
   calls TPM_BoundData_Init to set members back to default values
   The bound_data itself is not freed
*/   

void TPM_BoundData_Delete(TPM_BOUND_DATA *tpm_bound_data)
{
    printf(" TPM_BoundData_Delete:\n");
    if (tpm_bound_data != NULL) {
	free(tpm_bound_data->payloadData);
	TPM_BoundData_Init(tpm_bound_data);
    }
    return;
}

/*
  TPM_SEALED_DATA
*/

/* TPM_SealedData_Init()

   sets members to default values
   sets all pointers to NULL and sizes to 0
   always succeeds - no return code
*/

void TPM_SealedData_Init(TPM_SEALED_DATA *tpm_sealed_data)
{
    printf(" TPM_SealedData_Init:\n");
    tpm_sealed_data->payload = TPM_PT_SEAL;
    TPM_Secret_Init(tpm_sealed_data->authData);
    TPM_Secret_Init(tpm_sealed_data->tpmProof);
    TPM_Digest_Init(tpm_sealed_data->storedDigest);
    TPM_SizedBuffer_Init(&(tpm_sealed_data->data));
    return;
}

/* TPM_SealedData_Load()

   deserialize the structure from a 'stream'
   'stream_size' is checked for sufficient data
   returns 0 or error codes
   
   Before use, call TPM_SealedData_Init()
   After use, call TPM_SealedData_Delete() to free memory
*/

TPM_RESULT TPM_SealedData_Load(TPM_SEALED_DATA *tpm_sealed_data,
			       unsigned char **stream,
			       uint32_t *stream_size)
{
    TPM_RESULT		rc = 0;

    printf(" TPM_SealedData_Load:\n");
    /* load payload */
    if (rc == 0) {
	rc = TPM_Load8(&(tpm_sealed_data->payload), stream, stream_size);
    }
    /* load authData */
    if (rc == 0) {
	rc = TPM_Secret_Load(tpm_sealed_data->authData, stream, stream_size);
    }
    /* load tpmProof */
    if (rc == 0) {
	rc = TPM_Secret_Load(tpm_sealed_data->tpmProof, stream, stream_size);
    }
    /* load storedDigest */
    if (rc == 0) {
	rc = TPM_Digest_Load(tpm_sealed_data->storedDigest, stream, stream_size);
    }
    /* load dataSize and data  */
    if (rc == 0) {
	rc = TPM_SizedBuffer_Load(&(tpm_sealed_data->data), stream, stream_size);
    }
    return rc;
}

/* TPM_SealedData_Store()
   
   serialize the structure to a stream contained in 'sbuffer'
   returns 0 or error codes
*/

TPM_RESULT TPM_SealedData_Store(TPM_STORE_BUFFER *sbuffer,
				const TPM_SEALED_DATA *tpm_sealed_data)
{
    TPM_RESULT		rc = 0;
    printf(" TPM_SealedData_Store:\n");
    /* store payload */
    if (rc == 0) {
	rc = TPM_Sbuffer_Append(sbuffer, &(tpm_sealed_data->payload), sizeof(TPM_PAYLOAD_TYPE));
    }
    /* store authData */
    if (rc == 0) {
	rc = TPM_Secret_Store(sbuffer, tpm_sealed_data->authData);
    }
    /* store tpmProof */
    if (rc == 0) {
	rc = TPM_Secret_Store(sbuffer, tpm_sealed_data->tpmProof);
    }
    /* store storedDigest */
    if (rc == 0) {
	rc = TPM_Digest_Store(sbuffer, tpm_sealed_data->storedDigest);
    }
    /* store dataSize and data	*/
    if (rc == 0) {
	rc = TPM_SizedBuffer_Store(sbuffer, &(tpm_sealed_data->data));
    }
    return rc;
}

/* TPM_SealedData_Delete()

   No-OP if the parameter is NULL, else:
   frees memory allocated for the object
   sets pointers to NULL
   calls TPM_SealedData_Init to set members back to default values
   The object itself is not freed
*/   

void TPM_SealedData_Delete(TPM_SEALED_DATA *tpm_sealed_data)
{
    printf(" TPM_SealedData_Delete:\n");
    if (tpm_sealed_data != NULL) {
	TPM_SizedBuffer_Delete(&(tpm_sealed_data->data));
	TPM_SealedData_Init(tpm_sealed_data);
    }
    return;
}

/* TPM_SealedData_GenerateEncData() generates an enc_data structure by serializing the
   TPM_SEALED_DATA structure and encrypting the result using the public key.
*/

TPM_RESULT TPM_SealedData_GenerateEncData(TPM_SIZED_BUFFER *enc_data,
					  const TPM_SEALED_DATA *tpm_sealed_data,
					  TPM_KEY *tpm_key)
{
    TPM_RESULT		rc = 0;
    TPM_STORE_BUFFER	sbuffer;		/* TPM_SEALED_DATA serialization */

    printf(" TPM_SealedData_GenerateEncData\n");
    TPM_Sbuffer_Init(&sbuffer);			/* freed @1 */
    /* serialize the TPM_SEALED_DATA */
    if (rc == 0) {
	rc = TPM_SealedData_Store(&sbuffer, tpm_sealed_data);
    }
    /* encrypt the TPM_SEALED_DATA serialization buffer with the public key, and place
       the result in the encData members */
    if (rc == 0) {
	rc = TPM_RSAPublicEncryptSbuffer_Key(enc_data, &sbuffer, tpm_key);
    }
    TPM_Sbuffer_Delete(&sbuffer);	/* @1 */
    return rc;
}

/* TPM_SealedData_DecryptEncData() decrypts the enc_data using the private key.	 The
   result is deserialized and stored in the TPM_SEALED_DATA structure.

*/

TPM_RESULT TPM_SealedData_DecryptEncData(TPM_SEALED_DATA *tpm_sealed_data,	/* result */
					 TPM_SIZED_BUFFER *enc_data,	/* encrypted input */
					 TPM_KEY *tpm_key)		/* key for decrypting */
{
    TPM_RESULT		rc = 0;
    unsigned char	*decryptData = NULL;	/* freed @1 */
    uint32_t		decryptDataLength = 0;	/* actual valid data */
    unsigned char	*stream;
    uint32_t		stream_size;
    
    printf(" TPM_SealedData_DecryptEncData:\n");
    /* allocate space for the decrypted data */
    if (rc == 0) {
	rc = TPM_RSAPrivateDecryptMalloc(&decryptData,		/* decrypted data */
					 &decryptDataLength,	/* actual size of decrypted data */
					 enc_data->buffer,	/* encrypted data */
					 enc_data->size,	/* encrypted data size */
					 tpm_key);
    }
    /* load the TPM_SEALED_DATA structure from the decrypted data stream */
    if (rc == 0) {
	/* use temporary variables, because TPM_SealedData_Load() moves the stream */
	stream = decryptData;
	stream_size = decryptDataLength;
	rc = TPM_SealedData_Load(tpm_sealed_data, &stream, &stream_size);
    }
    free(decryptData);		/* @1 */
    return rc;
}


/*
  TPM_STORED_DATA
*/

/* TPM_StoredData_Init()

   sets members to default values
   sets all pointers to NULL and sizes to 0
   always succeeds - no return code
*/

void TPM_StoredData_Init(TPM_STORED_DATA *tpm_stored_data,
			 unsigned int version)
{
    printf(" TPM_StoredData_Init: v%u\n", version);
    if (version == 1) {
	TPM_StructVer_Init(&(tpm_stored_data->ver));
    }
    else {
	((TPM_STORED_DATA12 *)tpm_stored_data)->tag = TPM_TAG_STORED_DATA12;
	((TPM_STORED_DATA12 *)tpm_stored_data)->et = 0x0000;
    }
    TPM_SizedBuffer_Init(&(tpm_stored_data->sealInfo));
    TPM_SizedBuffer_Init(&(tpm_stored_data->encData));
    tpm_stored_data->tpm_seal_info = NULL;
    return;
}

/* TPM_StoredData_Load()

   deserialize the structure from a 'stream'
   'stream_size' is checked for sufficient data
   returns 0 or error codes
   
   Before use, call TPM_StoredData_Init()
   After use, call TPM_StoredData_Delete() to free memory

   This function handles both TPM_STORED_DATA and TPM_STORED_DATA12 and returns the 'version'.
*/

TPM_RESULT TPM_StoredData_Load(TPM_STORED_DATA *tpm_stored_data,
			       unsigned int *version,
			       unsigned char **stream,
			       uint32_t *stream_size)
{
    TPM_RESULT		rc = 0;

    /* Peek at the first byte to guess the version number.  The data is verified later.
       TPM_STORED_DATA is 01,01,00,00 TPM_STORED_DATA12 is 00,16,00,00 */
    if ((rc == 0) && (*stream_size > 0)) {
	if (**stream == 0x01) {
	    *version = 1;
	}
	else {
	    *version = 2;
	}
	printf(" TPM_StoredData_Load: v%u\n", *version);
    }	 
    /* 1.1 load ver */
    if ((rc == 0) && (*version == 1)) {
	rc = TPM_StructVer_Load(&(tpm_stored_data->ver), stream, stream_size);
    }
    /* 1.2 load tag */
    if ((rc == 0) && (*version != 1)) {
	rc = TPM_Load16(&(((TPM_STORED_DATA12 *)tpm_stored_data)->tag), stream, stream_size);
    }
    /* 1.2 load et */
    if ((rc == 0) && (*version != 1)) {
	rc = TPM_Load16(&(((TPM_STORED_DATA12 *)tpm_stored_data)->et), stream, stream_size);
    }
    /* check the TPM_STORED_DATA structure version */
    if ((rc == 0) && (*version == 1)) {
	rc = TPM_StructVer_CheckVer(&(tpm_stored_data->ver));
    }
    /* check the TPM_STORED_DATA12 structure tag */
    if ((rc == 0) && (*version != 1)) {
	rc = TPM_StoredData_CheckTag((TPM_STORED_DATA12 *)tpm_stored_data);
    }
    /* load sealInfoSize and sealInfo */
    if (rc == 0) {
	rc = TPM_SizedBuffer_Load(&(tpm_stored_data->sealInfo), stream, stream_size);
    }
    /* load the TPM_PCR_INFO or TPM_PCR_INFO_LONG cache */
    if (rc == 0) {
	if (*version == 1) {
	    rc = TPM_PCRInfo_CreateFromBuffer(&(tpm_stored_data->tpm_seal_info),
					      &(tpm_stored_data->sealInfo));
	}
	else {
	    rc = TPM_PCRInfoLong_CreateFromBuffer
		 (&(((TPM_STORED_DATA12 *)tpm_stored_data)->tpm_seal_info_long),
		  &(tpm_stored_data->sealInfo));
	}
    }
    /* load encDataSize and encData */
    if (rc == 0) {
	rc = TPM_SizedBuffer_Load(&(tpm_stored_data->encData), stream, stream_size);
    }
    return rc;
}

/* TPM_StoredData_StoreClearData() serializes a TPM_STORED_DATA structure, excluding encData,
   appending results to 'sbuffer'.

   Before serializing, it serializes tpm_seal_info to sealInfoSize and sealInfo.

   This function handles both TPM_STORED_DATA and TPM_STORED_DATA12.
   
   serialize the structure to a stream contained in 'sbuffer'
   returns 0 or error codes
*/

TPM_RESULT TPM_StoredData_StoreClearData(TPM_STORE_BUFFER *sbuffer,
					 TPM_STORED_DATA *tpm_stored_data,
					 unsigned int version)
{
    TPM_RESULT		rc = 0;

    printf(" TPM_StoredData_StoreClearData: v%u\n", version);
    /* 1.1 store ver */
    if ((rc == 0) && (version == 1)) {
	rc = TPM_StructVer_Store(sbuffer, &(tpm_stored_data->ver));
    }
    /* 1.2 store tag */
    if ((rc == 0) && (version != 1)) {
	rc = TPM_Sbuffer_Append16(sbuffer, ((TPM_STORED_DATA12 *)tpm_stored_data)->tag);
    }
    /* 1.2 store et */
    if ((rc == 0) && (version != 1)) {
	rc = TPM_Sbuffer_Append16(sbuffer, ((TPM_STORED_DATA12 *)tpm_stored_data)->et);
    }
    /* store sealInfoSize and sealInfo */
    if (rc == 0) {
	/* copy cache to sealInfoSize and sealInfo */
	if (version == 1) {
	    rc = TPM_SizedBuffer_SetStructure(&(tpm_stored_data->sealInfo),
					      tpm_stored_data->tpm_seal_info,
					      (TPM_STORE_FUNCTION_T)TPM_PCRInfo_Store);
	}
	else {
	    rc = TPM_SizedBuffer_SetStructure(&(tpm_stored_data->sealInfo),
					      tpm_stored_data->tpm_seal_info,
					      (TPM_STORE_FUNCTION_T)TPM_PCRInfoLong_Store);
	}
    }
    /* copy sealInfoSize and sealInfo to sbuffer */
    if (rc == 0) {
	rc = TPM_SizedBuffer_Store(sbuffer, &(tpm_stored_data->sealInfo));
    }
    return rc;
}

/* TPM_StoredData_Store()
   
   Before serializing, it serializes tpm_seal_info to sealInfoSize and sealInfo.

   serialize the structure to a stream contained in 'sbuffer'
   returns 0 or error codes
*/

TPM_RESULT TPM_StoredData_Store(TPM_STORE_BUFFER *sbuffer,
				TPM_STORED_DATA *tpm_stored_data,
				unsigned int version)
{
    TPM_RESULT		rc = 0;

    printf(" TPM_StoredData_Store: v%u\n", version);
    if (rc == 0) {
	rc = TPM_StoredData_StoreClearData(sbuffer, tpm_stored_data, version);
    }
    /* store encDataSize and encData */
    if (rc == 0) {
	rc = TPM_SizedBuffer_Store(sbuffer, &(tpm_stored_data->encData));
    }
    return rc;
}

/* TPM_StoredData_Delete()

   No-OP if the parameter is NULL, else:
   frees memory allocated for the object
   sets pointers to NULL
   calls TPM_StoredData_Init to set members back to default values
   The object itself is not freed
*/   

void TPM_StoredData_Delete(TPM_STORED_DATA *tpm_stored_data,
			   unsigned int version)
{
    printf(" TPM_StoredData_Delete: v%u\n", version);
    if (tpm_stored_data != NULL) {
	TPM_SizedBuffer_Delete(&(tpm_stored_data->sealInfo));
	TPM_SizedBuffer_Delete(&(tpm_stored_data->encData));
	if (version == 1) {
	    TPM_PCRInfo_Delete(tpm_stored_data->tpm_seal_info);
	    free(tpm_stored_data->tpm_seal_info);
	}
	else {
	    TPM_PCRInfoLong_Delete((TPM_PCR_INFO_LONG *)tpm_stored_data->tpm_seal_info);
	    free(tpm_stored_data->tpm_seal_info);
	}
	TPM_StoredData_Init(tpm_stored_data, version);
    }
    return;
}

/* TPM_StoredData_CheckTag() verifies the tag and et members of a TPM_STORED_DATA12 structure

 */

TPM_RESULT TPM_StoredData_CheckTag(TPM_STORED_DATA12 *tpm_stored_data12)
{
    TPM_RESULT	rc = 0;

    printf(" TPM_StoredData_CheckTag:\n");
    if (rc == 0) {
	if (tpm_stored_data12->tag != TPM_TAG_STORED_DATA12) {
	    printf("TPM_StoredData_CheckTag: Error, tag expected %04x found %04hx\n",
		   TPM_TAG_STORED_DATA12, tpm_stored_data12->tag);
	    rc = TPM_BAD_VERSION;
	}
    }
    return rc;
}

/* TPM_StoredData_GenerateDigest() generates a TPM_DIGEST over the TPM_STORED_DATA structure
   excluding the encDataSize and encData members.
*/

TPM_RESULT TPM_StoredData_GenerateDigest(TPM_DIGEST tpm_digest,
					 TPM_STORED_DATA *tpm_stored_data,
					 unsigned int version)
{
    TPM_RESULT		rc = 0;
    TPM_STORE_BUFFER	sbuffer;	/* TPM_STORED_DATA serialization */
    
    printf(" TPM_StoredData_GenerateDigest:\n");
    TPM_Sbuffer_Init(&sbuffer);			/* freed @1 */
    /* serialize the TPM_STORED_DATA excluding the encData fields */
    if (rc == 0) {
	rc = TPM_StoredData_StoreClearData(&sbuffer, tpm_stored_data, version);
    }
    if (rc == 0) {
	rc = TPM_SHA1Sbuffer(tpm_digest, &sbuffer);
    }
    TPM_Sbuffer_Delete(&sbuffer);	/* @1 */
    return rc;
}

/*
  Processing Functions
*/

/* TPM_SealCryptCommon() rev 98

   Handles the encrypt/decrypt actions common to TPM_Sealx and TPM_Unseal

   'encrypt TRUE for encryption, FALSE for decryption

   The output o1 must be freed by the caller.
*/

static TPM_RESULT TPM_SealCryptCommon(BYTE **o1,	/* freed by caller */
				      TPM_ADIP_ENC_SCHEME adipEncScheme,
				      TPM_SIZED_BUFFER *inData,
				      TPM_AUTH_SESSION_DATA *auth_session_data,
				      TPM_NONCE nonceOdd)
{
    TPM_RESULT		rc = 0;
    BYTE		*x1;			/* XOR string, MGF1 output */
    TPM_DIGEST		ctr;			/* symmetric key algorithm CTR */

    printf(" TPM_SealCryptCommon:\n");
    x1 = NULL;					/* freed @1 */

    /* allocate for the output o1 */
    if (rc == TPM_SUCCESS) {
	rc = TPM_Malloc(o1, inData->size);	/* freed by caller */
    }
    if (rc == TPM_SUCCESS) {
	TPM_PrintFourLimit("  TPM_SealCryptCommon: input data", inData->buffer, inData->size);
    }
    switch (adipEncScheme) {
      case TPM_ET_XOR:
	printf("  TPM_SealCryptCommon: TPM_ET_XOR\n");
	if (rc == TPM_SUCCESS) {
	    /* i. Use MGF1 to create string X1 of length sealedDataSize. The inputs to MGF1 are;
	       authLastnonceEven, nonceOdd, "XOR", and authHandle -> sharedSecret. The four
	       concatenated values form the Z value that is the seed for MFG1. */
	    rc = TPM_MGF1_GenerateArray(&x1,		/* MGF1 array */
					inData->size,	/* MGF1 array length */
					
					TPM_NONCE_SIZE +
					TPM_NONCE_SIZE +
					sizeof("XOR") -1 +
					TPM_DIGEST_SIZE, /* seed length */
					
					TPM_NONCE_SIZE, auth_session_data->nonceEven,
					TPM_NONCE_SIZE, nonceOdd,
					sizeof("XOR") -1, "XOR",
					TPM_DIGEST_SIZE, auth_session_data->sharedSecret,
					0, NULL);
	}
	/* ii. Create o1 by XOR of d1 -> data and X1 */
	if (rc == TPM_SUCCESS) {
	    TPM_PrintFour("  TPM_SealCryptCommon: XOR key", x1);
	    TPM_XOR(*o1, inData->buffer, x1, inData->size);
	}
	break;
      case TPM_ET_AES128_CTR:
	printf("  TPM_SealCryptCommon: TPM_ET_AES128_CTR\n");
	/* i. Create o1 by encrypting d1 -> data using the algorithm indicated by inData ->
	   et */
	/* ii. Key is from authHandle -> sharedSecret */
	/* iii. IV is SHA-1 of (authLastNonceEven || nonceOdd) */
	if (rc == TPM_SUCCESS) {
	    rc = TPM_SHA1(ctr,
			  TPM_NONCE_SIZE, auth_session_data->nonceEven,
			  TPM_NONCE_SIZE, nonceOdd,
			  0, NULL);
	}
	if (rc == TPM_SUCCESS) {
	    TPM_PrintFour("  TPM_SealCryptCommon: AES key", auth_session_data->sharedSecret);
	    TPM_PrintFour("  TPM_SealCryptCommon: CTR", ctr);
	    rc = TPM_SymmetricKeyData_CtrCrypt(*o1,				/* output data */
					       inData->buffer,			/* input data */
					       inData->size,			/* data size */
					       auth_session_data->sharedSecret, /* key */
					       TPM_SECRET_SIZE,			/* key size */
					       ctr,				/* CTR */
					       TPM_DIGEST_SIZE);		/* CTR size */
	}
	break;
      default:
	printf("TPM_SealCryptCommon: Error, unsupported adipEncScheme %02x\n", adipEncScheme);
	rc = TPM_INAPPROPRIATE_ENC;
	break;
    }
    if (rc == 0) {
	TPM_PrintFour("  TPM_SealCryptCommon: output data", *o1);
	
    }
    free(x1);				/* @1 */
    return rc;
}

/* 10.1 TPM_Seal rev 110

   The SEAL operation allows software to explicitly state the future "trusted" configuration that
   the platform must be in for the secret to be revealed. The SEAL operation also implicitly
   includes the relevant platform configuration (PCR-values) when the SEAL operation was
   performed. The SEAL operation uses the tpmProof value to BIND the blob to an individual TPM.

   TPM_Seal is used to encrypt private objects that can only be decrypted using TPM_Unseal.
*/

TPM_RESULT TPM_Process_Seal(tpm_state_t *tpm_state,
			    TPM_STORE_BUFFER *response,
			    TPM_TAG tag,
			    uint32_t paramSize,
			    TPM_COMMAND_CODE ordinal,
			    unsigned char *command,
			    TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	keyHandle;	/* Handle of a loaded key that can perform seal
					   operations. */
    TPM_ENCAUTH		encAuth;	/* The encrypted authorization data for the sealed data. */
    TPM_SIZED_BUFFER	pcrInfo;	/* The PCR selection information. The caller MAY use
					   TPM_PCR_INFO_LONG. */
    TPM_SIZED_BUFFER	inData;		/* The data to be sealed to the platform and any specified
					   PCRs */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for keyHandle
					   authorization. Must be an OS_AP session for this
					   command. */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL		continueAuthSession = TRUE;	/* Ignored */
    TPM_AUTHDATA	pubAuth;	/* The authorization digest for inputs and keyHandle. HMAC
					   key: key.usageAuth. */

    /* processing */
    unsigned char *		inParamStart;		/* starting point of inParam's */
    unsigned char *		inParamEnd;		/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_KEY			*key = NULL;		/* the key specified by keyHandle */
    TPM_SECRET			*keyUsageAuth;
    TPM_BOOL			parentPCRStatus;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    unsigned int		v1PcrVersion = 1;		/* pcrInfo version */
    TPM_STORED_DATA12		*s1_12;
    TPM_PCR_INFO		tpm_pcr_info;		/* deserialized pcrInfo v1 */
    TPM_PCR_INFO_LONG		tpm_pcr_info_long;	/* deserialized pcrInfo v2 */
    unsigned char		*stream;
    uint32_t			stream_size;
    TPM_DIGEST			a1Auth;
    TPM_SEALED_DATA		s2SealedData;
    
    /* output parameters */
    uint32_t		outParamStart;	/* starting point of outParam's */
    uint32_t		outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST		outParamDigest;
    TPM_STORED_DATA	s1StoredData;	/* Encrypted, integrity-protected data object that is the
					   result of the TPM_Seal operation. Returned as
					   SealedData */
    
    printf("TPM_Process_Seal: Ordinal Entry\n");
    TPM_SizedBuffer_Init(&pcrInfo);			/* freed @1 */
    TPM_SizedBuffer_Init(&inData);			/* freed @2 */
    TPM_StoredData_Init(&s1StoredData, v1PcrVersion);	/* freed @3, default is v1 */
    TPM_PCRInfo_Init(&tpm_pcr_info);			/* freed @4 */
    TPM_PCRInfoLong_Init(&tpm_pcr_info_long);		/* freed @5 */
    TPM_SealedData_Init(&s2SealedData);			/* freed @6 */
    s1_12 = (TPM_STORED_DATA12 *)&s1StoredData;		/* to avoid casts */
    /*
      get inputs
    */
    /* get keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&keyHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* get encAuth parameter */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Seal: keyHandle %08x\n", keyHandle);
	returnCode = TPM_Authdata_Load(encAuth, &command, &paramSize);
    }
    /* get pcrInfo parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_SizedBuffer_Load(&pcrInfo, &command, &paramSize);
    }	
    /* get inData parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_SizedBuffer_Load(&inData, &command, &paramSize);
    }	
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Seal: Sealing %u bytes\n", inData.size);
    }	
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag1(tag);
    }
    /* get the 'below the line' authorization parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					pubAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_Seal: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* get the key corresponding to the keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyHandleEntries_GetKey(&key, &parentPCRStatus, tpm_state, keyHandle,
						 FALSE,		/* not r/o, using to encrypt */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    /* get keyHandle -> usageAuth */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_GetUsageAuth(&keyUsageAuth, key);
    }	 
    /* get the session data */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_OSAP,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      key,
					      NULL,			/* OIAP */
					      key->tpm_store_asymkey->pubDataDigest);	/* OSAP */
    }
    /* 1. Validate the authorization to use the key pointed to by keyHandle */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					continueAuthSession,
					pubAuth);		/* Authorization digest for input */
    }
    /* 2. If the inDataSize is 0 the TPM returns TPM_BAD_PARAMETER */
    if (returnCode == TPM_SUCCESS) {
	if (inData.size == 0) {
	    printf("TPM_Process_Seal: Error, inDataSize is 0\n");
	    returnCode = TPM_BAD_PARAMETER;
	}
    }
    /* 3. If the keyUsage field of the key indicated by keyHandle does not have the value
       TPM_KEY_STORAGE, the TPM must return the error code TPM_INVALID_KEYUSAGE. */
    if (returnCode == TPM_SUCCESS) {
	if (key->keyUsage != TPM_KEY_STORAGE) {
	    printf("TPM_Process_Seal: Error, key keyUsage %04hx must be TPM_KEY_STORAGE\n",
		   key->keyUsage);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 4. If the keyHandle points to a migratable key then the TPM MUST return the error code
       TPM_INVALID_KEY_USAGE. */
    if (returnCode == TPM_SUCCESS) {
	if (key->keyFlags & TPM_MIGRATABLE) {
	    printf("TPM_Process_Seal: Error, key keyFlags %08x indicates migratable\n",
		   key->keyFlags);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 5. Determine the version of pcrInfo */
    if (returnCode == TPM_SUCCESS) {
	/* a. If pcrInfoSize is 0 */
	if (pcrInfo.size == 0) {
	    v1PcrVersion = 1;			/* i. set V1 to 1  */
	}
	else {				/* b. Else */
	    /* i. Point X1 as TPM_PCR_INFO_LONG structure to pcrInfo  */
	    /* ii. If X1 -> tag is TPM_TAG_PCR_INFO_LONG  */
	    if (htons(*(uint16_t *)(pcrInfo.buffer)) == TPM_TAG_PCR_INFO_LONG) {
		v1PcrVersion = 2;			/* (1) Set V1 to 2  */
	    }
	    else {			/* iii. Else */
		v1PcrVersion = 1;			/* (1) Set V1 to 1 */
	    }
	}
	/* 6. If V1 is 1 then */
	/* a. Create S1 a TPM_STORED_DATA structure  */
	/* 7. else  */
	/* a. Create S1 a TPM_STORED_DATA12 structure  */
	/* b. Set S1 -> et to 0 */
	/* 8. Set S1 -> encDataSize to 0 */
	/* 9. Set S1 -> encData to all zeros */
	printf("TPM_Process_Seal: V%u\n", v1PcrVersion);
	TPM_StoredData_Init(&s1StoredData, v1PcrVersion);
	/* 10. Set S1 -> sealInfoSize to pcrInfoSize */
	/* NOTE This step is unnecessary.  If pcrInfoSize is 0, sealInfoSize is already initialized
	   to 0.  If pcrInfoSize is non-zero, sealInfoSize is the result of serialization of the
	   tpm_seal_info member, which is either a TPM_PCR_INFO or a TPM_PCR_INFO_LONG */
    }
    /* 11. If pcrInfoSize is not 0 then */
    if ((returnCode == TPM_SUCCESS) && (pcrInfo.size != 0)) {
	printf("TPM_Process_Seal: Creating PCR digest\n");
	/* assign the stream, so pcrInfo is not altered */
	stream = pcrInfo.buffer;
	stream_size = pcrInfo.size;
	/* a. if V1 is 1 then */
	if (v1PcrVersion == 1) {
	    /* i. Validate pcrInfo as a valid TPM_PCR_INFO structure, return TPM_BADINDEX on
	       error */
	    if (returnCode == TPM_SUCCESS) {
		returnCode = TPM_PCRInfo_Load(&tpm_pcr_info, &stream, &stream_size);
		if (returnCode != 0) {
		    returnCode = TPM_BADINDEX;
		}
	    }
	    /* build the TPM_STORED_DATA S1 structure */
	    if (returnCode == TPM_SUCCESS) {
		/* ii. Set S1 -> sealInfo -> pcrSelection to pcrInfo -> pcrSelection */
		returnCode = TPM_PCRInfo_CreateFromBuffer(&(s1StoredData.tpm_seal_info), &pcrInfo);
	    }
	    /* iii. Create h1 the composite hash of the PCR selected by pcrInfo -> pcrSelection */
	    /* iv. Set S1 -> sealInfo -> digestAtCreation to h1 */
	    /* NOTE hash directly to destination.  */
	    if (returnCode == TPM_SUCCESS) {
		returnCode =
		    TPM_PCRSelection_GenerateDigest(s1StoredData.tpm_seal_info->digestAtCreation,
						    &(tpm_pcr_info.pcrSelection),
						    tpm_state->tpm_stclear_data.PCRS);
	    }
	    /* v. Set S1 -> sealInfo -> digestAtRelease to pcrInfo -> digestAtRelease */
	    /* NOTE digestAtRelease copied during TPM_PCRInfo_CreateFromBuffer() */
	}
	/* b. else (v1 is 2) */
	else {
	    /* i. Validate pcrInfo as a valid TPM_PCR_INFO_LONG structure, return TPM_BADINDEX
	       on error */
	    if (returnCode == TPM_SUCCESS) {
		returnCode = TPM_PCRInfoLong_Load(&tpm_pcr_info_long, &stream, &stream_size);
		if (returnCode != 0) {
		    returnCode = TPM_BADINDEX;
		}
	    }
	    /* build the TPM_STORED_DATA S1 structure */
	    if (returnCode == TPM_SUCCESS) {
		/* ii. Set S1 -> sealInfo -> creationPCRSelection to pcrInfo -> creationPCRSelection
		   */
		/* iii. Set S1 -> sealInfo -> releasePCRSelection to pcrInfo -> releasePCRSelection
		   */
		/* iv. Set S1 -> sealInfo -> digestAtRelease to pcrInfo -> digestAtRelease */
		/* v. Set S1 -> sealInfo -> localityAtRelease to pcrInfo -> localityAtRelease */
		/* NOTE copied during TPM_PCRInfoLong_CreateFromBuffer() */
		returnCode = TPM_PCRInfoLong_CreateFromBuffer(&(s1_12->tpm_seal_info_long),
							      &pcrInfo);
	    }
	    if (returnCode == TPM_SUCCESS) {
		/* vi. Create h2 the composite hash of the PCR selected by pcrInfo ->
		   creationPCRSelection */
		/* vii. Set S1 -> sealInfo -> digestAtCreation to h2 */
		/* NOTE hash directly to destination. */
		returnCode =
		    TPM_PCRSelection_GenerateDigest(s1_12->tpm_seal_info_long->digestAtCreation,
						    &(tpm_pcr_info_long.creationPCRSelection),
						    tpm_state->tpm_stclear_data.PCRS);
	    }
	    /* viii. Set S1 -> sealInfo -> localityAtCreation to TPM_STANY_FLAGS ->
	       localityModifier */
	    if (returnCode == TPM_SUCCESS) {
		returnCode = TPM_Locality_Set(&(s1_12->tpm_seal_info_long->localityAtCreation),
					      tpm_state->tpm_stany_flags.localityModifier);
	    }
	}
    }
    /* 12. Create a1 by decrypting encAuth according to the ADIP indicated by authHandle. */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthSessionData_Decrypt(a1Auth,
						 NULL,
						 encAuth,
						 auth_session_data,
						 NULL,
						 NULL,
						 FALSE);	/* even and odd */
    }
    /* 13. The TPM provides NO validation of a1. Well-known values (like all zeros) are valid and
       possible. */
    /* 14. Create S2 a TPM_SEALED_DATA structure */
    if (returnCode == TPM_SUCCESS) {
	/* a. Set S2 -> payload to TPM_PT_SEAL */
	/* NOTE: Done at TPM_SealedData_Init() */
	/* b. Set S2 -> tpmProof to TPM_PERMANENT_DATA -> tpmProof */
	TPM_Secret_Copy(s2SealedData.tpmProof, tpm_state->tpm_permanent_data.tpmProof);
	/* c. Create h3 the SHA-1 of S1 */
	/* d. Set S2 -> storedDigest to h3 */
	returnCode = TPM_StoredData_GenerateDigest(s2SealedData.storedDigest,
						   &s1StoredData, v1PcrVersion);
    }
    if (returnCode == TPM_SUCCESS) {
	/* e. Set S2 -> authData to a1 */
	TPM_Secret_Copy(s2SealedData.authData, a1Auth);
	/* f. Set S2 -> dataSize to inDataSize */
	/* g. Set S2 -> data to inData */
	returnCode = TPM_SizedBuffer_Copy(&(s2SealedData.data), &inData);
    }
    /* 15. Validate that the size of S2 can be encrypted by the key pointed to by keyHandle, return
       TPM_BAD_DATASIZE on error */
    /* 16. Create s3 the encryption of S2 using the key pointed to by keyHandle */
    /* 17. Set continueAuthSession to FALSE */
    if (returnCode == TPM_SUCCESS) {
	continueAuthSession = FALSE;
    }
    /* 18. Set S1 -> encDataSize to the size of s3 */
    /* 19. Set S1 -> encData to s3 */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_SealedData_GenerateEncData(&(s1StoredData.encData), &s2SealedData, key);
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_Seal: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* 20. Return S1 as sealedData */
	    returnCode = TPM_StoredData_Store(response, &s1StoredData, v1PcrVersion);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);		/* length */
	}
	/* calculate and set the below the line parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* owner HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    TPM_SizedBuffer_Delete(&pcrInfo);			/* @1 */
    TPM_SizedBuffer_Delete(&inData);			/* @2 */
    TPM_StoredData_Delete(&s1StoredData, v1PcrVersion);	/* @3 */
    TPM_PCRInfo_Delete(&tpm_pcr_info);			/* @4 */
    TPM_PCRInfoLong_Delete(&tpm_pcr_info_long); 	/* @5 */
    TPM_SealedData_Delete(&s2SealedData);		/* @6 */
    return rcf;
}

/* 10.7 TPM_Sealx rev 110
     
   The TPM_Sealx command works exactly like the TPM_Seal command with the additional requirement of
   encryption for the inData parameter. This command also places in the sealed blob the information
   that the TPM_Unseal also requires encryption.

   TPM_Sealx requires the use of 1.2 data structures. The actions are the same as TPM_Seal without
   the checks for 1.1 data structure usage.
*/

TPM_RESULT TPM_Process_Sealx(tpm_state_t *tpm_state,
			     TPM_STORE_BUFFER *response,
			     TPM_TAG tag,
			     uint32_t paramSize,
			     TPM_COMMAND_CODE ordinal,
			     unsigned char *command,
			     TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	keyHandle;	/* Handle of a loaded key that can perform seal
					   operations. */
    TPM_ENCAUTH		encAuth;	/* The encrypted authorization data for the sealed data */
    TPM_SIZED_BUFFER	pcrInfo;	/* If 0 there are no PCR registers in use.  pcrInfo MUST use
					   TPM_PCR_INFO_LONG */
    TPM_SIZED_BUFFER	inData;		/* The data to be sealed to the platform and any specified
					   PCRs */

    TPM_AUTHHANDLE	authHandle;	/* The authorization session handle used for keyHandle
					   authorization.  Must be an OSAP session for this command.
					   */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL		continueAuthSession = TRUE;	/* Ignored */
    TPM_AUTHDATA	pubAuth;	/* The authorization digest for inputs and keyHandle. HMAC
					   key: key.usageAuth. */

    /* processing */
    unsigned char *		inParamStart;			/* starting point of inParam's */
    unsigned char *		inParamEnd;			/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;			/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_KEY			*key = NULL;			/* the key specified by keyHandle */
    TPM_SECRET			*keyUsageAuth;
    TPM_BOOL			parentPCRStatus;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */

    /* output parameters */
    uint32_t			outParamStart;	/* starting point of outParam's */
    uint32_t			outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST			outParamDigest;
    TPM_STORED_DATA12		s1StoredData;	/* Encrypted, integrity-protected data object that
						   is the result of the TPM_Seal operation. Returned
						   as SealedData */
    TPM_STORED_DATA		*s1_11;		/* 1.1 version to avoid casts */
    TPM_SEALED_DATA		s2SealedData;
    TPM_DIGEST			a1Auth;
    BYTE			*o1DecryptedData;
    
    printf("TPM_Process_Sealx: Ordinal Entry\n");
    s1_11 = (TPM_STORED_DATA *)&s1StoredData;	/* 1.1 version to avoid casts */
    TPM_SizedBuffer_Init(&pcrInfo);		/* freed @1 */
    TPM_SizedBuffer_Init(&inData);		/* freed @2 */
    TPM_StoredData_Init(s1_11, 2);		/* freed @3 */
    TPM_SealedData_Init(&s2SealedData); 	/* freed @4 */
    o1DecryptedData = NULL;			/* freed @5 */
    /*
      get inputs
    */
    /*	get keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&keyHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* get encAuth parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Authdata_Load(encAuth, &command, &paramSize);
    }
    /* get pcrInfo parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_SizedBuffer_Load(&pcrInfo, &command, &paramSize);
    }	
    /* get inData parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_SizedBuffer_Load(&inData, &command, &paramSize);
    }	
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Sealx: Sealing %u bytes\n", inData.size);
	TPM_PrintFourLimit("TPM_Process_Sealx: Sealing data", inData.buffer, inData.size);
    }	
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag1(tag);
    }
    /* get the 'below the line' authorization parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					pubAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_Sealx: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* get the key corresponding to the keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyHandleEntries_GetKey(&key, &parentPCRStatus, tpm_state, keyHandle,
						 FALSE,		/* not r/o, using to encrypt */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    /* get keyHandle -> usageAuth */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_GetUsageAuth(&keyUsageAuth, key);
    }	 
    /* get the session data */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_OSAP,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      key,
					      NULL,			/* OIAP */
					      key->tpm_store_asymkey->pubDataDigest);	/* OSAP */
    }
    /* 1. Validate the authorization to use the key pointed to by keyHandle */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					continueAuthSession,
					pubAuth);		/* Authorization digest for input */
    }
    /* 2. If the inDataSize is 0 the TPM returns TPM_BAD_PARAMETER */
    if (returnCode == TPM_SUCCESS) {
	if (inData.size == 0) {
	    printf("TPM_Process_Sealx: Error, inDataSize is 0\n");
	    returnCode = TPM_BAD_PARAMETER;
	}
    }
    /* 3. If the keyUsage field of the key indicated by keyHandle does not have the value
       TPM_KEY_STORAGE, the TPM must return the error code TPM_INVALID_KEYUSAGE. */
    if (returnCode == TPM_SUCCESS) {
	if (key->keyUsage != TPM_KEY_STORAGE) {
	    printf("TPM_Process_Sealx: Error, key keyUsage %04hx must be TPM_KEY_STORAGE\n",
		   key->keyUsage);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 4. If the keyHandle points to a migratable key then the TPM MUST return the error code
       TPM_INVALID_KEY_USAGE. */
    if (returnCode == TPM_SUCCESS) {
	if (key->keyFlags & TPM_MIGRATABLE) {
	    printf("TPM_Process_Sealx: Error, key keyFlags %08x indicates migratable\n",
		   key->keyFlags);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 5. Create S1 a TPM_STORED_DATA12 structure */
    /* 6. Set S1 -> encDataSize to 0 */
    /* 7. Set S1 -> encData to all zeros */
    /* NOTE: Done by TPM_StoredData_Init() */
    /* 8. Set S1 -> sealInfoSize to pcrInfoSize */
    /* NOTE This step is unnecessary.  If pcrInfoSize is 0, sealInfoSize is already initialized
       to 0.  If pcrInfoSize is non-zero, sealInfoSize is the result of serialization of the
       tpm_seal_info member, which is a TPM_PCR_INFO_LONG */
    /* 9. If pcrInfoSize is not 0 then */
    if ((returnCode == TPM_SUCCESS) && (pcrInfo.size != 0)) {
	printf("TPM_Process_Sealx: Setting sealInfo to pcrInfo\n");
	/* initializing the s -> TPM_PCR_INFO_LONG cache to the contents of pcrInfo */
	/* a. Validate pcrInfo as a valid TPM_PCR_INFO_LONG structure, return TPM_BADINDEX on
	   error */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_PCRInfoLong_CreateFromBuffer(&(s1StoredData.tpm_seal_info_long),
							  &pcrInfo);
	    if (returnCode != TPM_SUCCESS) {
		returnCode = TPM_BADINDEX;
	    }
	}
	/* b. Set S1 -> sealInfo -> creationPCRSelection to pcrInfo -> creationPCRSelection */
	/* c. Set S1 -> sealInfo -> releasePCRSelection to pcrInfo -> releasePCRSelection */
	/* d. Set S1 -> sealInfo -> digestAtRelease to pcrInfo -> digestAtRelease */
	/* e. Set S1 -> sealInfo -> localityAtRelease to pcrInfo -> localityAtRelease  */
	/* NOTE copied during TPM_PCRInfoLong_CreateFromBuffer() */
	/* f. Create h2 the composite hash of the PCR selected by pcrInfo -> creationPCRSelection */
	/* g. Set S1 -> sealInfo -> digestAtCreation to h2 */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_PCRSelection_GenerateDigest
			 (s1StoredData.tpm_seal_info_long->digestAtCreation,
			  &(s1StoredData.tpm_seal_info_long->creationPCRSelection),
			  tpm_state->tpm_stclear_data.PCRS);
	}
	/* h. Set S1 -> sealInfo -> localityAtCreation to TPM_STANY_DATA -> localityModifier */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_Locality_Set(&(s1StoredData.tpm_seal_info_long->localityAtCreation),
					  tpm_state->tpm_stany_flags.localityModifier);
	}
    }
    /* 10. Create S2 a TPM_SEALED_DATA structure */
    /* NOTE: Done at TPM_SealedData_Init() */
    /* 11.Create a1 by decrypting encAuth according to the ADIP indicated by authHandle. */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Sealx: Decrypting encAuth\n");
	returnCode = TPM_AuthSessionData_Decrypt(a1Auth,	/* a1 even */
						 NULL,		/* a1 odd (2nd encAuth) */
						 encAuth,	/* encAuthEven */
						 auth_session_data,
						 NULL,		/* nonceOdd */
						 NULL,		/* encAuthOdd */
						 FALSE);	/* even and odd */
    }
    if (returnCode == TPM_SUCCESS) {
	TPM_PrintFour("TPM_Process_Sealx: Decrypted Auth", a1Auth);
	/* a. If authHandle indicates XOR encryption for the AuthData secrets */
	if (auth_session_data->adipEncScheme == TPM_ET_XOR) {
	    /* i. Set S1 -> et to TPM_ET_XOR || TPM_ET_KEY */
	    /* (1) TPM_ET_KEY is added because TPM_Unseal uses zero as a special value indicating no
	       encryption. */
	    s1StoredData.et = TPM_ET_XOR | TPM_ET_KEY;
	}
	/* b. Else */
	else {
	    /* i. Set S1 -> et to algorithm indicated by authHandle */
	    s1StoredData.et = auth_session_data->adipEncScheme << 8;
	}
    }
    /* 12. The TPM provides NO validation of a1. Well-known values (like all zeros) are valid and
       possible. */
    /* 13. If authHandle indicates XOR encryption */
    /* a. Use MGF1 to create string X2 of length inDataSize. The inputs to MGF1 are;
       authLastNonceEven, nonceOdd, "XOR", and authHandle -> sharedSecret. The four concatenated
       values form the Z value that is the seed for MFG1. */
    /* b. Create o1 by XOR of inData and x2 */
    /* 14. Else */
    /* a. Create o1 by decrypting inData using the algorithm indicated by authHandle */
    /* b. Key is from authHandle -> sharedSecret */
    /* c. CTR is SHA-1 of (authLastNonceEven || nonceOdd) */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Sealx: decrypting inData\n");
	returnCode = TPM_SealCryptCommon(&o1DecryptedData,		/* freed by caller */
					 auth_session_data->adipEncScheme,
					 &inData,
					 auth_session_data,
					 nonceOdd);

   }
    /* 15. Create S2 a TPM_SEALED_DATA structure */
    if (returnCode == TPM_SUCCESS) {
	/* a. Set S2 -> payload to TPM_PT_SEAL */
	/* NOTE: Done at TPM_SealedData_Init() */
	/* b. Set S2 -> tpmProof to TPM_PERMANENT_DATA -> tpmProof */
	TPM_Secret_Copy(s2SealedData.tpmProof, tpm_state->tpm_permanent_data.tpmProof);
	/* c. Create h3 the SHA-1 of S1 */
	/* d. Set S2 -> storedDigest to h3 */
	returnCode = TPM_StoredData_GenerateDigest(s2SealedData.storedDigest, s1_11, 2);
    }
    /* e. Set S2 -> authData to a1 */
    if (returnCode == TPM_SUCCESS) {
	TPM_Secret_Copy(s2SealedData.authData, a1Auth);
	/* f. Set S2 -> dataSize to inDataSize */
	/* g. Set S2 -> data to o1 */
	returnCode = TPM_SizedBuffer_Set(&(s2SealedData.data), inData.size, o1DecryptedData);
    }
    /* 16. Validate that the size of S2 can be encrypted by the key pointed to by keyHandle, return
       */
    /* TPM_BAD_DATASIZE on error */
    /* 17. Create s3 the encryption of S2 using the key pointed to by keyHandle */
    /* 18. Set continueAuthSession to FALSE */
    if (returnCode == TPM_SUCCESS) {
	continueAuthSession = FALSE;
    }
    /* 19. Set S1 -> encDataSize to the size of s3 */
    /* 20. Set S1 -> encData to s3 */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Sealx: Encrypting sealed data\n");
	returnCode = TPM_SealedData_GenerateEncData(&(s1StoredData.encData), &s2SealedData, key);
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_Sealx: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* 21. Return S1 as sealedData */
	    returnCode = TPM_StoredData_Store(response, s1_11, 2);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* owner HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    TPM_SizedBuffer_Delete(&pcrInfo);		/* @1 */
    TPM_SizedBuffer_Delete(&inData);		/* @2 */
    TPM_StoredData_Delete(s1_11, 2);		/* @3 */
    TPM_SealedData_Delete(&s2SealedData);	/* @4 */
    free(o1DecryptedData);			/* @5 */
    return rcf;
}

/* 10.2 TPM_Unseal rev 110

   The TPM_Unseal operation will reveal TPM_Sealed data only if it was encrypted on this platform
   and the current configuration (as defined by the named PCR contents) is the one named as
   qualified to decrypt it.  Internally, TPM_Unseal accepts a data blob generated by a TPM_Seal
   operation. TPM_Unseal decrypts the structure internally, checks the integrity of the resulting
   data, and checks that the PCR named has the value named during TPM_Seal.  Additionally, the
   caller must supply appropriate authorization data for blob and for the key that was used to seal
   that data.
   
   If the integrity, platform configuration and authorization checks succeed, the sealed data is
   returned to the caller; otherwise, an error is generated.
*/

TPM_RESULT TPM_Process_Unseal(tpm_state_t *tpm_state,
			      TPM_STORE_BUFFER *response,
			      TPM_TAG tag,
			      uint32_t paramSize,
			      TPM_COMMAND_CODE ordinal,
			      unsigned char *command,
			      TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	parentHandle;	/* Handle of a loaded key that can unseal the data. */
    TPM_STORED_DATA	inData;		/* The encrypted data generated by TPM_Seal. */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for parentHandle. */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = TRUE;	/* The continue use flag for the authorization
						   handle */
    TPM_AUTHDATA	parentAuth;	/* The authorization digest for inputs and
					   parentHandle. HMAC key: parentKey.usageAuth. */
    TPM_AUTHHANDLE	dataAuthHandle; /* The authorization handle used to authorize inData. */
    TPM_NONCE		datanonceOdd;	/* Nonce generated by system associated with
					   entityAuthHandle */
    TPM_BOOL	continueDataSession = TRUE;	/* Continue usage flag for dataAuthHandle. */
    TPM_AUTHDATA	dataAuth;	/* The authorization digest for the encrypted entity. HMAC
					   key: entity.usageAuth.  */

    /* processing */
    unsigned char *		inParamStart;		/* starting point of inParam's */
    unsigned char *		inParamEnd;		/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_BOOL			dataAuthHandleValid = FALSE;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    TPM_AUTH_SESSION_DATA	*data_auth_session_data = NULL; /* session data for dataAuthHandle
								   */
    TPM_SECRET			*hmacKey;
    TPM_SECRET			*dataHmacKey;
    unsigned int		v1StoredDataVersion = 1;	/* version of TPM_STORED_DATA
								   inData */
    TPM_KEY			*parentKey;
    TPM_BOOL			parentPCRStatus;
    TPM_SECRET			*parentUsageAuth;
    TPM_SEALED_DATA		d1SealedData;
    TPM_DIGEST			h1StoredDataDigest;
    TPM_STORED_DATA12		*s2StoredData;
    BYTE			*o1Encrypted;			/* For ADIP encryption */
    TPM_ADIP_ENC_SCHEME		adipEncScheme;	 

    /* output parameters */
    uint32_t			outParamStart;	/* starting point of outParam's */
    uint32_t			outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST			outParamDigest;
    uint32_t			secretSize = 0; /* Decrypted data that had been sealed */
    BYTE			*secret = NULL;

    printf("TPM_Process_Unseal: Ordinal Entry\n");
    TPM_StoredData_Init(&inData, v1StoredDataVersion);	/* freed @1, default is v1 */
    TPM_SealedData_Init(&d1SealedData); 		/* freed @2 */
    o1Encrypted = NULL;					/* freed @3 */
    s2StoredData = (TPM_STORED_DATA12 *)&inData;	/* inData when it's a TPM_STORED_DATA12
							   structure */
    /*
      get inputs
    */
    /* get parentHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&parentHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* get inData parameter */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Unseal: parentHandle %08x\n", parentHandle);
	returnCode = TPM_StoredData_Load(&inData, &v1StoredDataVersion, &command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Unseal: inData is v%u\n", v1StoredDataVersion);
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag21(tag);
    }
    /* get the optional 'below the line' authorization parameters */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					parentAuth,
					&command, &paramSize);
    }
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	printf("TPM_Process_Unseal: authHandle %08x\n", authHandle);
    }
    /* get the 'below the line' authorization parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthParams_Get(&dataAuthHandle,
					&dataAuthHandleValid,
					datanonceOdd,
					&continueDataSession,
					dataAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Unseal: dataAuthHandle %08x\n", dataAuthHandle); 
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_Unseal: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
	dataAuthHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* Verify that parentHandle points to a valid key.	Get the TPM_KEY associated with parentHandle
     */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyHandleEntries_GetKey(&parentKey, &parentPCRStatus,
						 tpm_state, parentHandle,
						 FALSE,		/* not r/o, using to decrypt */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    /* get parentHandle -> usageAuth */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	returnCode = TPM_Key_GetUsageAuth(&parentUsageAuth, parentKey);
    }	 
    /* get the first session data */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_NONE,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      parentKey,
					      parentUsageAuth,			/* OIAP */
					      parentKey->tpm_store_asymkey->pubDataDigest); /*OSAP*/
    }
    /* 1. The TPM MUST validate that parentAuth authorizes the use of the key in parentHandle, on
       error return TPM_AUTHFAIL */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					continueAuthSession,
					parentAuth);		/* Authorization digest for input */
    }
    /* if there are no parent auth parameters */
    if ((returnCode == TPM_SUCCESS) && (tag != TPM_TAG_RQU_AUTH2_COMMAND)) {
	if (parentKey->authDataUsage != TPM_AUTH_NEVER) {
	    printf("TPM_Process_Unseal: Error, parent key authorization required\n");
	    returnCode = TPM_AUTHFAIL;
	}
    }
    /* 2. If the keyUsage field of the key indicated by parentHandle does not have the value
       TPM_KEY_STORAGE, the TPM MUST return the error code TPM_INVALID_KEYUSAGE. */
    if (returnCode == TPM_SUCCESS) {
	if (parentKey->keyUsage != TPM_KEY_STORAGE) {
	    printf("TPM_Process_Unseal: Error, key keyUsage %04hx must be TPM_KEY_STORAGE\n",
		   parentKey->keyUsage);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 3. The TPM MUST check that the TPM_KEY_FLAGS -> Migratable flag has the value FALSE in the
       key indicated by parentKeyHandle. If not, the TPM MUST return the error code
       TPM_INVALID_KEYUSAGE */
    if (returnCode == TPM_SUCCESS) {
	if (parentKey->keyFlags & TPM_MIGRATABLE) {
	    printf("TPM_Process_Unseal: Error, key keyFlags %08x indicates migratable\n",
		   parentKey->keyFlags);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 4. Determine the version of inData */
    /* a. If inData -> tag = TPM_TAG_STORED_DATA12 */
    /* i. Set V1 to 2 */
    /* ii. Map S2 a TPM_STORED_DATA12 structure to inData */
    /* b. Else If inData -> ver = 1.1 */
    /* i. Set V1 to 1 */
    /* ii. Map S2 a TPM_STORED_DATA structure to inData */
    /* c. Else */
    /* i. Return TPM_BAD_VERSION */
    /* NOTE: Done during TPM_StoredData_Load() */
    /* The extra indent of error checking is required because the next steps all return
       TPM_NOTSEALED_BLOB on error */
    if (returnCode == TPM_SUCCESS) {
	/* 5. Create d1 by decrypting S2 -> encData using the key pointed to by parentHandle */
	printf("TPM_Process_Unseal: Decrypting encData\n");
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_SealedData_DecryptEncData(&d1SealedData,	/* TPM_SEALED_DATA */
						       &(inData.encData),
						       parentKey);	
	}
	/* 6. Validate d1 */
	/* a. d1 MUST be a TPM_SEALED_DATA structure */
	/* NOTE Done during TPM_SealedData_DecryptEncData() */
	/* b. d1 -> tpmProof MUST match TPM_PERMANENT_DATA -> tpmProof */
	if (returnCode == TPM_SUCCESS) {
	    printf("TPM_Process_Unseal: Sealed data size %u\n", d1SealedData.data.size);
	    TPM_PrintFour("TPM_Process_Unseal: Sealed data", d1SealedData.data.buffer);
	    printf("TPM_Process_Unseal: Checking tpmProof\n");
	    returnCode = TPM_Secret_Compare(d1SealedData.tpmProof,
					    tpm_state->tpm_permanent_data.tpmProof);
	}
	if (returnCode == TPM_SUCCESS) {
	    /* c. Set S2 -> encDataSize to 0 */
	    /* d. Set S2 -> encData to all zeros */
	    /* NOTE: This would be done at cleanup */
	    TPM_SizedBuffer_Delete(&(inData.encData));
	    /* e. Create h1 the SHA-1 of S2 */
	    returnCode = TPM_StoredData_GenerateDigest(h1StoredDataDigest,
						       &inData, v1StoredDataVersion);
	}
	/* f. d1 -> storedDigest MUST match h1 */
	if (returnCode == TPM_SUCCESS) {
	    printf("TPM_Process_Unseal: Checking storedDigest\n");
	    returnCode = TPM_Digest_Compare(d1SealedData.storedDigest, h1StoredDataDigest);
	}
	/* g. d1 -> payload MUST be TPM_PT_SEAL */
	if (returnCode == TPM_SUCCESS) {
	    if (d1SealedData.payload != TPM_PT_SEAL) {
		printf("TPM_Process_Unseal: Error, payload %02x not TPM_PT_SEAL\n",
		       d1SealedData.payload);
		returnCode = TPM_NOTSEALED_BLOB;
	    }
	}
	/* h. Any failure MUST return TPM_NOTSEALED_BLOB */
	if (returnCode != TPM_SUCCESS) {
	    returnCode = TPM_NOTSEALED_BLOB;
	}
    }
    /* 7. If S2 -> sealInfo is not 0 then */
    /* NOTE: Done by _CheckDigest() */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_Unseal: Checking PCR digest\n");
	/* a. If V1 is 1 then */
	if (v1StoredDataVersion == 1) {
	    /* i. Validate that S2 -> pcrInfo is a valid TPM_PCR_INFO structure */
	    /* NOTE: Done during TPM_StoredData_Load() */
	    /* ii. Create h2 the composite hash of the PCR selected by S2 -> pcrInfo -> pcrSelection
	     */
	    /* c. Compare h2 with S2 -> pcrInfo -> digestAtRelease, on mismatch return
	       TPM_WRONGPCRVALUE */
	    returnCode = TPM_PCRInfo_CheckDigest(inData.tpm_seal_info,
						 tpm_state->tpm_stclear_data.PCRS); /* PCR array */
	}
	/* b. If V1 is 2 then */
	else {
	    /* i. Validate that S2 -> pcrInfo is a valid TPM_PCR_INFO_LONG structure */
	    /* NOTE: Done during TPM_StoredData_Load() */
	    /* ii. Create h2 the composite hash of the PCR selected by S2 -> pcrInfo ->
	       releasePCRSelection */
	    /* iii. Check that S2 -> pcrInfo -> localityAtRelease for TPM_STANY_DATA ->
	       localityModifier is TRUE */
	    /* (1) For example if TPM_STANY_DATA -> localityModifier was 2 then S2 -> pcrInfo ->
	       localityAtRelease -> TPM_LOC_TWO would have to be TRUE */
	    /* c. Compare h2 with S2 -> pcrInfo -> digestAtRelease, on mismatch return
	       TPM_WRONGPCRVALUE */
	    returnCode =
		TPM_PCRInfoLong_CheckDigest(s2StoredData->tpm_seal_info_long,
					    tpm_state->tpm_stclear_data.PCRS,	/* PCR array */
					    tpm_state->tpm_stany_flags.localityModifier);
	}
    }
    /* 8. The TPM MUST validate authorization to use d1 by checking that the HMAC calculation
       using d1 -> authData as the shared secret matches the dataAuth. Return TPM_AUTHFAIL on
       mismatch. */
    /* get the second session data */
    /* NOTE: While OSAP isn't specifically excluded, there is currently no way to set up an OSAP
       session using TPM_SEALED_DATA as the entity */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthSessions_GetData(&data_auth_session_data,
					      &dataHmacKey,
					      tpm_state,
					      dataAuthHandle,
					      TPM_PID_OIAP,	/* currently require OIAP */
					      0,		/* OSAP entity type */
					      ordinal,
					      NULL,
					      &(d1SealedData.authData), /* OIAP */
					      NULL);			/* OSAP */
    }
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Auth2data_Check(tpm_state,
					 *dataHmacKey,		/* HMAC key */
					 inParamDigest,
					 data_auth_session_data, /* authorization session */
					 datanonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					 continueDataSession,
					 dataAuth);		/* Authorization digest for input */
    }
    if (returnCode == TPM_SUCCESS) {
	/* 9. If V1 is 2 and S2 -> et specifies encryption (i.e. is not all zeros) then */
	if ((v1StoredDataVersion == 2) && (s2StoredData->et != 0x0000)) {
	    /* a. If tag is not TPM_TAG_RQU_AUTH2_COMMAND, return TPM_AUTHFAIL */
	    if (returnCode == TPM_SUCCESS) {
		if (tag != TPM_TAG_RQU_AUTH2_COMMAND) {
		    printf("TPM_Process_Unseal: Error, sealed with encryption but auth-1\n");
		    returnCode = TPM_AUTHFAIL;
		}
	    }
	    /* b. Verify that the authHandle session type is TPM_PID_OSAP or TPM_PID_DSAP, return
	       TPM_BAD_MODE on error. */
	    if (returnCode == TPM_SUCCESS) {
		if ((auth_session_data->protocolID != TPM_PID_OSAP) &&
		    (auth_session_data->protocolID != TPM_PID_DSAP)) {
		    printf("TPM_Process_Unseal: Error, sealed with encryption but OIAP\n");
		    returnCode = TPM_BAD_MODE;
		}
	    }	    
	    /* c. If MSB of S2 -> et is TPM_ET_XOR */
	    /* i. Use MGF1 to create string X1 of length sealedDataSize. The inputs to MGF1 are;
	       authLastnonceEven, nonceOdd, "XOR", and authHandle -> sharedSecret. The four
	       concatenated values form the Z value that is the seed for MFG1. */
	    /* d. Else */
	    /* i. Create o1 by encrypting d1 -> data using the algorithm indicated by inData ->
	       et */
	    /* ii. Key is from authHandle -> sharedSecret */
	    /* iii. IV is SHA-1 of (authLastNonceEven || nonceOdd) */
	    if (returnCode == TPM_SUCCESS) {
		/* entity type MSB is ADIP encScheme */
		adipEncScheme = (s2StoredData->et >> 8) & 0x00ff;
		printf("TPM_Process_Unseal: Encrypting the output, encScheme %02x\n",
		       adipEncScheme);
		returnCode = TPM_SealCryptCommon(&o1Encrypted,
						 adipEncScheme,
						 &(d1SealedData.data),
						 auth_session_data,
						 nonceOdd);
		secretSize = d1SealedData.data.size;
		secret = o1Encrypted;
	    }
	    /* e. Set continueAuthSession to FALSE */
	    continueAuthSession = FALSE;
	}
	/* 10. else */
	else {
	    printf("TPM_Process_Unseal: No output encryption\n");
	    /* a. Set o1 to d1 -> data */
	    secretSize = d1SealedData.data.size;
	    secret = d1SealedData.data.buffer;
	}
    }
    /* 11. Set the return secret as o1 */
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_Unseal: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* return secretSize */
	    returnCode = TPM_Sbuffer_Append32(response, secretSize);
	}
	if (returnCode == TPM_SUCCESS) {
	    /* return secret */
	    returnCode = TPM_Sbuffer_Append(response, secret, secretSize);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH2_COMMAND)) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* calculate and set the below the line parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_AuthParams_Set(response,
					    *dataHmacKey,	/* HMAC key */
					    data_auth_session_data,
					    outParamDigest,
					    datanonceOdd,
					    continueDataSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueDataSession) &&
	dataAuthHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, dataAuthHandle);
    }
    /*
      cleanup
    */
    TPM_StoredData_Delete(&inData, v1StoredDataVersion);	/* @1 */
    TPM_SealedData_Delete(&d1SealedData);			/* @2 */
    free(o1Encrypted);						/* @3 */
    return rcf;
}
	    
/* 10.3 TPM_UnBind rev 87

   TPM_UnBind takes the data blob that is the result of a Tspi_Data_Bind command and decrypts it
   for export to the User. The caller must authorize the use of the key that will decrypt the
   incoming blob.

   UnBind operates on a block-by-block basis, and has no notion of any relation between one block
   and another.

   UnBind SHALL operate on a single block only. 
*/

TPM_RESULT TPM_Process_UnBind(tpm_state_t *tpm_state,
			      TPM_STORE_BUFFER *response,
			      TPM_TAG tag,
			      uint32_t paramSize,
			      TPM_COMMAND_CODE ordinal,
			      unsigned char *command,
			      TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	keyHandle;	/* The keyHandle identifier of a loaded key that can perform
					   UnBind operations. */
    TPM_SIZED_BUFFER	inData;		/* Encrypted blob to be decrypted */
    TPM_AUTHHANDLE	authHandle;	/* The handle used for keyHandle authorization */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = TRUE;	/* The continue use flag for the authorization
						   handle */
    TPM_AUTHDATA	privAuth;	/* The authorization digest that authorizes the inputs and
					   use of keyHandle. HMAC key: key.usageAuth. */

    /* processing parameters */
    unsigned char *		inParamStart;			/* starting point of inParam's */
    unsigned char *		inParamEnd;			/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_KEY			*key = NULL;			/* the key specified by keyHandle */
    TPM_SECRET			*keyUsageAuth;
    TPM_RSA_KEY_PARMS		*tpm_rsa_key_parms;		/* for key */
    TPM_BOOL			parentPCRStatus;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    uint32_t			decrypt_data_size;		/* resulting decrypted data size */
    BYTE			*decrypt_data = NULL;		/* The resulting decrypted data. */
    unsigned char		*stream;
    uint32_t			stream_size;
    TPM_BOUND_DATA		tpm_bound_data;

    /* output parameters */
    uint32_t		outParamStart;		/* starting point of outParam's */
    uint32_t		outParamEnd;		/* ending point of outParam's */
    TPM_DIGEST		outParamDigest;
    size_t		outDataSize = 0;	/* The length of the returned decrypted data */
    BYTE		*outData = NULL;	/* The resulting decrypted data. */
    
    printf("TPM_Process_UnBind: Ordinal Entry\n");
    TPM_SizedBuffer_Init(&inData);		/* freed @1 */
    TPM_BoundData_Init(&tpm_bound_data);	/* freed @3 */
    /*
      get inputs
    */
    /*	get keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&keyHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* get areaToSignSize and areaToSign parameters */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_UnBind: keyHandle %08x\n", keyHandle);
	returnCode = TPM_SizedBuffer_Load(&inData, &command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_UnBind: UnBinding %u bytes\n", inData.size);
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag10(tag);
    }
    /* get the optional 'below the line' authorization parameters */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					privAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_UnBind: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* 1. If the inDataSize is 0 the TPM returns TPM_BAD_PARAMETER */
    if (returnCode == TPM_SUCCESS) {
	if (inData.size == 0) {
	    printf("TPM_Process_UnBind: Error, inDataSize is 0\n");
	    returnCode = TPM_BAD_PARAMETER;
	}
    }
    /* get the key corresponding to the keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyHandleEntries_GetKey(&key, &parentPCRStatus, tpm_state, keyHandle,
						 FALSE,		/* not read-only */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_COMMAND)){
	if (key->authDataUsage != TPM_AUTH_NEVER) {
	    printf("TPM_Process_UnBind: Error, authorization required\n");
	    returnCode = TPM_AUTHFAIL;
	}
    }
    /* get keyHandle -> usageAuth */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_Key_GetUsageAuth(&keyUsageAuth, key);
    }	 
    /* get the session data */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_NONE,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      key,
					      keyUsageAuth,		/* OIAP */
					      key->tpm_store_asymkey->pubDataDigest); /* OSAP */
    }
    /* 2. Validate the authorization to use the key pointed to by keyHandle */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					continueAuthSession,
					privAuth);		/* Authorization digest for input */
    }
    /* 3. If the keyUsage field of the key referenced by keyHandle does not have the value
       TPM_KEY_BIND or TPM_KEY_LEGACY, the TPM must return the error code TPM_INVALID_KEYUSAGE */
    if (returnCode == TPM_SUCCESS) {
	if ((key->keyUsage != TPM_KEY_BIND) && (key->keyUsage != TPM_KEY_LEGACY)) {
	    printf("TPM_Process_UnBind: Error, invalid keyUsage %04hx\n", (key->keyUsage));
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }
    /* Get the TPM_RSA_KEY_PARMS associated with key */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyParms_GetRSAKeyParms(&tpm_rsa_key_parms, &(key->algorithmParms));
    }	     
    /* 4. Decrypt the inData using the key pointed to by keyHandle */
    if (returnCode == TPM_SUCCESS) {
	returnCode =
	    TPM_RSAPrivateDecryptMalloc(&decrypt_data,		/* decrypted data, freed @2 */
					&decrypt_data_size,	/* actual size of decrypted data
								   data */
					inData.buffer,
					inData.size,
					key);
    }
    if (returnCode == TPM_SUCCESS) {
	/* 5. if (keyHandle -> encScheme does not equal TPM_ES_RSAESOAEP_SHA1_MGF1) and (keyHandle
	   -> keyUsage equals TPM_KEY_LEGACY), */
	if ((key->algorithmParms.encScheme != TPM_ES_RSAESOAEP_SHA1_MGF1) &&
	    (key->keyUsage == TPM_KEY_LEGACY)) {
	    printf("TPM_Process_UnBind: Legacy key\n");
	    /* a. The payload does not have TPM specific markers to validate, so no consistency
	       check can be performed. */
	    /* b. Set the output parameter outData to the value of the decrypted value of
	       inData. (Padding associated with the encryption wrapping of inData SHALL NOT be
	       returned.) */
	    outData = decrypt_data;
	    /* c. Set the output parameter outDataSize to the size of outData, as deduced from the
	       decryption process. */
	    outDataSize = decrypt_data_size;
	}
	/* 6. else */
	else {
	    printf("TPM_Process_UnBind: Payload is TPM_BOUND_DATA structure\n");
	    /* a. Interpret the decrypted data under the assumption that it is a TPM_BOUND_DATA
	       structure, and validate that the payload type is TPM_PT_BIND */
	    if (returnCode == TPM_SUCCESS) {
		stream = decrypt_data;
		stream_size = decrypt_data_size;
		returnCode = TPM_BoundData_Load(&tpm_bound_data,
						&stream,
						&stream_size);
	    }
	    if (returnCode == TPM_SUCCESS) {
		if (tpm_bound_data.payload != TPM_PT_BIND) {
		    printf("TPM_Process_UnBind: Error, "
			   "TPM_BOUND_DATA->payload %02x not TPM_PT_BIND\n",
			   tpm_bound_data.payload);
		    returnCode = TPM_INVALID_STRUCTURE;
		}
	    }
	    /* b. Set the output parameter outData to the value of TPM_BOUND_DATA ->
	       payloadData. (Other parameters of TPM_BOUND_DATA SHALL NOT be returned. Padding
	       associated with the encryption wrapping of inData SHALL NOT be returned.) */
	    if (returnCode == TPM_SUCCESS) {
		outData = tpm_bound_data.payloadData;
		/* c. Set the output parameter outDataSize to the size of outData, as deduced from
		   the decryption process and the interpretation of TPM_BOUND_DATA. */
		outDataSize = tpm_bound_data.payloadDataSize;
	    }
	}
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_UnBind: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* 10. Return the computed outData */
	    /* append outDataSize */
	    returnCode = TPM_Sbuffer_Append32(response, outDataSize);
	}
	if (returnCode == TPM_SUCCESS) {
	    /* append outData */
	    returnCode = TPM_Sbuffer_Append(response, outData, outDataSize);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    TPM_SizedBuffer_Delete(&inData);		/* @1 */
    free(decrypt_data);				/* @2 */
    TPM_BoundData_Delete(&tpm_bound_data);	/* @3 */
    return rcf;
}

/* 10.4 TPM_CreateWrapKey rev 114

   The TPM_CreateWrapKey command both generates and creates a secure storage bundle for asymmetric
   keys.

   The newly created key can be locked to a specific PCR value by specifying a set of PCR registers.
*/

TPM_RESULT TPM_Process_CreateWrapKey(tpm_state_t *tpm_state,
				     TPM_STORE_BUFFER *response,
				     TPM_TAG tag,
				     uint32_t paramSize,
				     TPM_COMMAND_CODE ordinal,
				     unsigned char *command,
				     TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	parentHandle;	/* Handle of a loaded key that can perform key wrapping. */
    TPM_ENCAUTH		dataUsageAuth;	/* Encrypted usage authorization data for the key. */
    TPM_ENCAUTH		dataMigrationAuth;	/* Encrypted migration authorization data for the
						   key.*/
    TPM_KEY		keyInfo;	/* Information about key to be created, pubkey.keyLength and
					   keyInfo.encData elements are 0. MAY be TPM_KEY12 */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for parent key
					   authorization. Must be an OSAP session.  */
    TPM_NONCE	nonceOdd;		/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = TRUE;	/* Ignored */
    TPM_AUTHDATA pubAuth;		/* The authorization digest that authorizes the use of the
					   public key in parentHandle. HMAC key:
					   parentKey.usageAuth. */

    /* processing parameters */
    unsigned char *		inParamStart;			/* starting point of inParam's */
    unsigned char *		inParamEnd;			/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    TPM_SECRET			*hmacKey;
    TPM_KEY			*parentKey = NULL;	/* the key specified by parentHandle */
    TPM_BOOL			parentPCRStatus;
    TPM_RSA_KEY_PARMS		*keyInfoRSAParms = NULL;	/* substructure of keyInfo */
    TPM_SECRET			du1UsageAuth;
    TPM_SECRET			dm1MigrationAuth;
    TPM_STORE_ASYMKEY		*wrappedStoreAsymkey;		/* substructure of wrappedKey */
    TPM_PCR_INFO		wrappedPCRInfo;
    int				ver;				/* TPM_KEY or TPM_KEY12 */

    /* output parameters */
    TPM_KEY		wrappedKey;	/* The TPM_KEY structure which includes the public and
					   encrypted private key. MAY be TPM_KEY12 */
    uint32_t		outParamStart;	/* starting point of outParam's */
    uint32_t		outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST		outParamDigest;
    
    printf("TPM_Process_CreateWrapKey: Ordinal Entry\n");
    TPM_Key_Init(&keyInfo);
    TPM_Key_Init(&wrappedKey);
    TPM_PCRInfo_Init(&wrappedPCRInfo);
    /*
      get inputs
    */
    /* get parentHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&parentHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* get dataUsageAuth parameter */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_CreateWrapKey: parentHandle %08x\n", parentHandle);
	returnCode = TPM_Authdata_Load(dataUsageAuth, &command, &paramSize);
    }
    /* get dataMigrationAuth parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Authdata_Load(dataMigrationAuth, &command, &paramSize);
    }
    /* get keyInfo parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_Load(&keyInfo, &command, &paramSize);	/* freed @1 */
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag1(tag);
    }
    /* get the 'below the line' authorization parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					pubAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_CreateWrapKey: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* get the key corresponding to the parentHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_KeyHandleEntries_GetKey(&parentKey, &parentPCRStatus, tpm_state,
						 parentHandle,
						 FALSE, /* not r/o, using to encrypt w/public key */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    /* get the session data */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_OSAP,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      parentKey,
					      NULL,			/* OIAP */
					      parentKey->tpm_store_asymkey->pubDataDigest); /*OSAP*/
    }
    /* 1. Validate the authorization to use the key pointed to by parentHandle. Return TPM_AUTHFAIL
       on any error. */
    /* 2. Validate the session type for parentHandle is OSAP. */
    if (returnCode == TPM_SUCCESS) {
	TPM_PrintFour("TPM_Process_CreateWrapKey: sharedSecret", auth_session_data->sharedSecret);
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle
								*/
					continueAuthSession,
					pubAuth);	/* Authorization digest for input */
    }
    /* 3. If the TPM is not designed to create a key of the type requested in keyInfo, return the
       error code TPM_BAD_KEY_PROPERTY */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_CreateWrapKey: Checking key properties\n");
	returnCode = TPM_Key_CheckProperties(&ver, &keyInfo, 0,
					     tpm_state->tpm_permanent_flags.FIPS);
    }	     
    /* Get the TPM_RSA_KEY_PARMS associated with keyInfo */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_CreateWrapKey: key parameters v = %d\n", ver);
	returnCode = TPM_KeyParms_GetRSAKeyParms(&keyInfoRSAParms, &(keyInfo.algorithmParms));
    }	     
    /* 4. Verify that parentHandle->keyUsage equals TPM_KEY_STORAGE */
    if (returnCode == TPM_SUCCESS) {
	if (parentKey->keyUsage != TPM_KEY_STORAGE) {
	    printf("TPM_Process_CreateWrapKey: Error, parent keyUsage not TPM_KEY_STORAGE\n");
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }	 
    /* 5. If parentHandle -> keyFlags -> migratable is TRUE and keyInfo -> keyFlags -> migratable is
       FALSE then return TPM_INVALID_KEYUSAGE */
    if (returnCode == TPM_SUCCESS) {
	if ((parentKey->keyFlags & TPM_MIGRATABLE) && !(keyInfo.keyFlags & TPM_MIGRATABLE)) {
	    printf("TPM_Process_CreateWrapKey: Error, parent not migratable\n");
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }	 
    /* 6. Validate key parameters */
    /* a. keyInfo -> keyUsage MUST NOT be TPM_KEY_IDENTITY or TPM_KEY_AUTHCHANGE. If it is, return
       TPM_INVALID_KEYUSAGE */
    if (returnCode == TPM_SUCCESS) {
	if ((keyInfo.keyUsage == TPM_KEY_IDENTITY) ||
	    (keyInfo.keyUsage == TPM_KEY_AUTHCHANGE)) {
	    printf("TPM_Process_CreateWrapKey: Error, Invalid key usage %04x\n",
		   keyInfo.keyUsage);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }	 
    /* b. If keyInfo -> keyFlags -> migrateAuthority is TRUE then return TPM_INVALID_KEYUSAGE */
    if (returnCode == TPM_SUCCESS) {
	if (keyInfo.keyFlags & TPM_MIGRATEAUTHORITY) {
	    printf("TPM_Process_CreateWrapKey: Error, Invalid key flags %08x\n",
		   keyInfo.keyFlags);
	    returnCode = TPM_INVALID_KEYUSAGE;
	}
    }	 
    /* 7.  If TPM_PERMANENT_FLAGS -> FIPS is TRUE then
       a.  If keyInfo -> keySize is less than 1024 return TPM_NOTFIPS
       b.  If keyInfo -> authDataUsage specifies TPM_AUTH_NEVER return TPM_NOTFIPS
       c.  If keyInfo -> keyUsage specifies TPM_KEY_LEGACY return TPM_NOTFIPS
       NOTE Done in step 3 TPM_Key_CheckProperties()
    */
    /* 8. If keyInfo -> keyUsage equals TPM_KEY_STORAGE	 or TPM_KEY_MIGRATE
       i. algorithmID MUST be TPM_ALG_RSA
       ii. encScheme MUST be TPM_ES_RSAESOAEP_SHA1_MGF1
       iii. sigScheme MUST be TPM_SS_NONE
       iv. key size MUST be 2048
       v. exponentSize MUST be 0
       NOTE Done in step 3 TPM_Key_CheckProperties()
    */
    /* 9. Determine the version of key
       a.If keyInfo -> ver is 1.1
       i. Set V1 to 1
       ii. Map wrappedKey to a TPM_KEY structure
       iii. Validate all remaining TPM_KEY structures
       b. Else if keyInfo -> tag is TPM_TAG_KEY12
       i. Set V1 to 2
       ii. Map wrappedKey to a TPM_KEY12 structure
       iii. Validate all remaining TPM_KEY12 structures
       NOTE Check done by TPM_Key_CheckProperties()
       NOTE Map done by TPM_Key_GenerateRSA()
    */
    /* 10..Create DU1 by decrypting dataUsageAuth according to the ADIP indicated by authHandle */
    /* 11. Create DM1 by decrypting dataMigrationAuth according to the ADIP indicated by
	   authHandle */
    if (returnCode == TPM_SUCCESS) {
	TPM_AuthSessionData_Decrypt(du1UsageAuth, 
				    dm1MigrationAuth,
				    dataUsageAuth,	/* even encAuth */
				    auth_session_data,
				    nonceOdd,
				    dataMigrationAuth,	/* odd encAuth */
				    TRUE);
    }
    /* 12. Set continueAuthSession to FALSE */
    if (returnCode == TPM_SUCCESS) {
	continueAuthSession = FALSE;
    }
    /* 13. Generate asymmetric key according to algorithm information in keyInfo */
    /* 14. Fill in the wrappedKey structure with information from the newly generated key. */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_CreateWrapKey: Generating key\n");
	returnCode = TPM_Key_GenerateRSA(&wrappedKey,
					 tpm_state,
					 parentKey,
					 tpm_state->tpm_stclear_data.PCRS,	/* PCR array */
					 ver,
					 keyInfo.keyUsage,
					 keyInfo.keyFlags,
					 keyInfo.authDataUsage,		/* TPM_AUTH_DATA_USAGE */
					 &(keyInfo.algorithmParms),	/* TPM_KEY_PARMS */
					 keyInfo.tpm_pcr_info,		/* TPM_PCR_INFO */
					 keyInfo.tpm_pcr_info_long);	/* TPM_PCR_INFO_LONG */
    }	 
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_GetStoreAsymkey(&wrappedStoreAsymkey,
					     &wrappedKey);
    }	 
    if (returnCode == TPM_SUCCESS) {
	/* a. Set wrappedKey -> encData -> usageAuth to DU1 */
	TPM_Secret_Copy(wrappedStoreAsymkey->usageAuth, du1UsageAuth);
	/* b. If the KeyFlags -> migratable bit is set to 1, the wrappedKey -> encData ->
	   migrationAuth SHALL contain the decrypted value from dataMigrationAuth. */
	if (wrappedKey.keyFlags & TPM_MIGRATABLE) {
	    TPM_Secret_Copy(wrappedStoreAsymkey->migrationAuth, dm1MigrationAuth);
	}
	/* c. If the KeyFlags -> migratable bit is set to 0, the wrappedKey -> encData ->
	   migrationAuth SHALL be set to the value tpmProof */
	else {
	    TPM_Secret_Copy(wrappedStoreAsymkey->migrationAuth,
			    tpm_state->tpm_permanent_data.tpmProof);
	}
	printf("TPM_Process_CreateWrapKey: wrappedKey.PCRInfoSize %d\n", wrappedKey.pcrInfo.size);
    }	 
    /* 15. If keyInfo->PCRInfoSize is non-zero. */
    /* a. If V1 is 1 */
    /* i. Set wrappedKey -> pcrInfo to a TPM_PCR_INFO structure using the pcrSelection to
       indicate the PCR's in use */
    /* b. Else */
    /* i. Set wrappedKey -> pcrInfo to a TPM_PCR_INFO_LONG structure */
    /* c. Set wrappedKey -> pcrInfo to keyInfo -> pcrInfo */
    /* d. Set wrappedKey -> digestAtCreation to the TPM_COMPOSITE_HASH indicated by
       creationPCRSelection */
    /* e. If V1 is 2 set wrappedKey -> localityAtCreation to TPM_STANY_DATA -> locality */
    /* NOTE Done by TPM_Key_GenerateRSA() */
    /* 16. Encrypt the private portions of the wrappedKey structure using the key in parentHandle */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_GenerateEncData(&wrappedKey, parentKey);
    }	 
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_CreateWrapKey: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* 17. Return the newly generated key in the wrappedKey parameter */
	    returnCode = TPM_Key_Store(response, &wrappedKey);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /* cleanup */
    TPM_Key_Delete(&keyInfo);			/* @1 */
    TPM_Key_Delete(&wrappedKey);		/* @2 */
    TPM_PCRInfo_Delete(&wrappedPCRInfo);	/* @3 */
    return rcf;
}

/* 27.8 TPM_LoadKey rev 114

   Version 1.2 deprecates LoadKey due to the HMAC of the new keyhandle on return. The wrapping makes
   use of the handle difficult in an environment where the TSS, or other management entity, is
   changing the TPM handle to a virtual handle.
   
   Software using loadKey on a 1.2 TPM can have a collision with the returned handle as the 1.2 TPM
   uses random values in the lower three bytes of the handle. All new software must use LoadKey2 to
   allow management software the ability to manage the key handle.
   
   Before the TPM can use a key to either wrap, unwrap, bind, unbind, seal, unseal, sign or perform
   any other action, it needs to be present in the TPM.	 The TPM_LoadKey function loads the key into
   the TPM for further use.
*/

TPM_RESULT TPM_Process_LoadKey(tpm_state_t *tpm_state,
			       TPM_STORE_BUFFER *response,
			       TPM_TAG tag,
			       uint32_t paramSize,
			       TPM_COMMAND_CODE ordinal,
			       unsigned char *command,
			       TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	parentHandle;	/* TPM handle of parent key. */
    TPM_KEY		*inKey;		/* Incoming key structure, both encrypted private and clear
					   public portions.  MAY be TPM_KEY12 */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for parentHandle
					   authorization. */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = FALSE;	/* The continue use flag for the authorization
						   handle */
    TPM_AUTHDATA	parentAuth;	/* The authorization digest for inputs and
					   parentHandle. HMAC key: parentKey.usageAuth. */
    /* processing parameters */
    unsigned char *		inParamStart;			/* starting point of inParam's */
    unsigned char *		inParamEnd;			/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_BOOL			key_added = FALSE;	/* key has been added to handle list */
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    
    /* output parameters */
    uint32_t		outParamStart;	/* starting point of outParam's */
    uint32_t		outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST		outParamDigest;
    TPM_KEY_HANDLE	inKeyHandle;	/* Internal TPM handle where decrypted key was loaded. */

    printf("TPM_Process_LoadKey: Ordinal Entry\n");
    inKey = NULL;			/* freed @1 */
    /*
      get inputs
    */
    /*	get parentHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&parentHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* Allocate space for inKey.  The key cannot be a local variable, since it persists in key
       storage after the command completes. */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_LoadKey: parentHandle %08x\n", parentHandle);
	returnCode = TPM_Malloc((unsigned char **)&inKey, sizeof(TPM_KEY));	/* freed @1 */
    }
    /* get inKey parameter */
    if (returnCode == TPM_SUCCESS) {
	TPM_Key_Init(inKey);					/* freed @2 */
	returnCode = TPM_Key_Load(inKey, &command, &paramSize); /* freed @2 */
    }
    if (returnCode == TPM_SUCCESS) {
	TPM_PrintFour("TPM_Process_LoadKey: inKey n", inKey->pubKey.buffer);
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag10(tag);
    }
    /* get the optional 'below the line' authorization parameters */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					parentAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_LoadKey: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_LoadKeyCommon(&inKeyHandle,	/* output */
				       &key_added,	/* output */
				       &hmacKey,	/* output */
				       &auth_session_data, /* output */
				       tpm_state,
				       tag,
				       ordinal,
				       parentHandle,
				       inKey,
				       inParamDigest,
				       authHandle,	/*uninitialized*/
				       nonceOdd,
				       continueAuthSession,
				       parentAuth);
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_LoadKey: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* return the key handle */
	    returnCode = TPM_Sbuffer_Append32(response, inKeyHandle);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    /* if there was a failure, delete inKey */
    if ((rcf != 0) || (returnCode != TPM_SUCCESS)) {
	TPM_Key_Delete(inKey);	/* @2 */
	free(inKey);		/* @1 */
	if (key_added) {
	    /* if there was a failure and inKey was stored in the handle list, free the handle.
	       Ignore errors, since only one error code can be returned. */
	    TPM_KeyHandleEntries_DeleteHandle(tpm_state->tpm_key_handle_entries, inKeyHandle);
	}	
    }
    return rcf;
}
	    
/* 10.5 TPM_LoadKey2 rev 107

   Before the TPM can use a key to either wrap, unwrap, unbind, seal, unseal, sign or perform any
   other action, it needs to be present in the TPM.  The TPM_LoadKey2 function loads the key into
   the TPM for further use.

   The TPM assigns the key handle. The TPM always locates a loaded key by use of the handle. The
   assumption is that the handle may change due to key management operations. It is the
   responsibility of upper level software to maintain the mapping between handle and any label used
   by external software.

   This command has the responsibility of enforcing restrictions on the use of keys. For example,
   when attempting to load a STORAGE key it will be checked for the restrictions on a storage key
   (2048 size etc.).

   The load command must maintain a record of whether any previous key in the key hierarchy was
   bound to a PCR using parentPCRStatus.
   
   The flag parentPCRStatus enables the possibility of checking that a platform passed through some
   particular state or states before finishing in the current state. A grandparent key could be
   linked to state-1, a parent key could linked to state-2, and a child key could be linked to
   state-3, for example. The use of the child key then indicates that the platform passed through
   states 1 and 2 and is currently in state 3, in this example.	 TPM_Startup with stType ==
   TPM_ST_CLEAR indicates that the platform has been reset, so the platform has not passed through
   the previous states. Hence keys with parentPCRStatus==TRUE must be unloaded if TPM_Startup is
   issued with stType == TPM_ST_CLEAR.
   
   If a TPM_KEY structure has been decrypted AND the integrity test using "pubDataDigest" has passed
   AND the key is non-migratory, the key must have been created by the TPM. So there is every reason
   to believe that the key poses no security threat to the TPM. While there is no known attack from
   a rogue migratory key, there is a desire to verify that a loaded migratory key is a real key,
   arising from a general sense of unease about execution of arbitrary data as a key. Ideally a
   consistency check would consist of an encrypt/decrypt cycle, but this may be expensive. For RSA
   keys, it is therefore suggested that the consistency test consists of dividing the supposed RSA
   product by the supposed RSA prime, and checking that there is no remainder.
*/

TPM_RESULT TPM_Process_LoadKey2(tpm_state_t *tpm_state,
				TPM_STORE_BUFFER *response,
				TPM_TAG tag,
				uint32_t paramSize,
				TPM_COMMAND_CODE ordinal,
				unsigned char *command,
				TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	parentHandle;	/* TPM handle of parent key. */
    TPM_KEY		*inKey;		/* Incoming key structure, both encrypted private and clear
					   public portions.  MAY be TPM_KEY12 */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for parentHandle
					   authorization. */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = FALSE;	/* The continue use flag for the authorization
						   handle */
    TPM_AUTHDATA	parentAuth;	/* The authorization digest for inputs and
					   parentHandle. HMAC key: parentKey.usageAuth. */
    /* processing parameters */
    unsigned char *		inParamStart;			/* starting point of inParam's */
    unsigned char *		inParamEnd;			/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_BOOL			key_added = FALSE;	/* key has been added to handle list */
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    
    /* output parameters */
    uint32_t		outParamStart;	/* starting point of outParam's */
    uint32_t		outParamEnd;	/* ending point of outParam's */
    TPM_DIGEST		outParamDigest;
    TPM_KEY_HANDLE	inKeyHandle;	/* Internal TPM handle where decrypted key was loaded. */

    printf("TPM_Process_LoadKey2: Ordinal Entry\n");
    inKey = NULL;			/* freed @1 */
    /*
      get inputs
    */
    /*	get parentHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&parentHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    /* Allocate space for inKey.  The key cannot be a local variable, since it persists in key
       storage after the command completes. */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_LoadKey2: parentHandle %08x\n", parentHandle);
	returnCode = TPM_Malloc((unsigned char **)&inKey, sizeof(TPM_KEY));	/* freed @1 */
    }
    /* get inKey parameter */
    if (returnCode == TPM_SUCCESS) {
	TPM_Key_Init(inKey);					/* freed @2 */
	returnCode = TPM_Key_Load(inKey, &command, &paramSize); /* freed @2 */
    }
    if (returnCode == TPM_SUCCESS) {
	TPM_PrintFour("TPM_Process_LoadKey2: inKey n", inKey->pubKey.buffer);
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag10(tag);
    }
    /* get the optional 'below the line' authorization parameters */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					parentAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_LoadKey2: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_LoadKeyCommon(&inKeyHandle,		/* output */
				       &key_added,		/* output */
				       &hmacKey,		/* output */
				       &auth_session_data,	/* output */
				       tpm_state,
				       tag,
				       ordinal,
				       parentHandle,
				       inKey,
				       inParamDigest,
				       authHandle,		/* uninitialized */
				       nonceOdd,
				       continueAuthSession,
				       parentAuth);
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_LoadKey2: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	    /* In TPM_LoadKey2, the inKeyHandle is not part of the output HMAC */
	    /* return the key handle */
	    returnCode = TPM_Sbuffer_Append32(response, inKeyHandle);
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    /* if there was a failure, delete inKey */
    if ((rcf != 0) || (returnCode != TPM_SUCCESS)) {
	TPM_Key_Delete(inKey);	/* @2 */
	free(inKey);		/* @1 */
	if (key_added) {
	    /* if there was a failure and inKey was stored in the handle list, free the handle.
	       Ignore errors, since only one error code can be returned. */
	    TPM_KeyHandleEntries_DeleteHandle(tpm_state->tpm_key_handle_entries, inKeyHandle);
	}	
    }
    return rcf;
}

/* TPM_LoadKeyCommon rev 114

   Code common to TPM_LoadKey and TPM_LoadKey2.	 They differ only in whether the key handle is
   included in the response HMAC calculation.
*/

static TPM_RESULT TPM_LoadKeyCommon(TPM_KEY_HANDLE	*inKeyHandle,	/* output */
				    TPM_BOOL		*key_added,	/* output */
				    TPM_SECRET		**hmacKey,	/* output */
				    TPM_AUTH_SESSION_DATA	**auth_session_data, /* output */
				    tpm_state_t		*tpm_state,
				    TPM_TAG		tag,
				    TPM_COMMAND_CODE	ordinal,
				    TPM_KEY_HANDLE	parentHandle,
				    TPM_KEY		*inKey,
				    TPM_DIGEST		inParamDigest,
				    TPM_AUTHHANDLE	authHandle,
				    TPM_NONCE		nonceOdd,
				    TPM_BOOL		continueAuthSession,
				    TPM_AUTHDATA	parentAuth)
{
    TPM_RESULT			rc = 0;
    TPM_KEY			*parentKey;		/* the key specified by parentHandle */
    TPM_SECRET			*parentUsageAuth;
    TPM_BOOL			parentPCRStatus;
    TPM_BOOL			parentPCRUsage;
    int				ver;

    printf("TPM_LoadKeyCommon:\n");
    *key_added = FALSE; /* key has been added to handle list */
    /* Verify that parentHandle points to a valid key.	Get the TPM_KEY associated with parentHandle
     */
    if (rc == TPM_SUCCESS) {
	rc = TPM_KeyHandleEntries_GetKey(&parentKey, &parentPCRStatus,
					 tpm_state, parentHandle,
					 FALSE,		/* not r/o, using to decrypt */
					 FALSE,		/* do not ignore PCRs */
					 FALSE);	/* cannot use EK */
    }
    /* check TPM_AUTH_DATA_USAGE authDataUsage */
    if ((rc == TPM_SUCCESS) && (tag == TPM_TAG_RQU_COMMAND)) {
	if (parentKey->authDataUsage != TPM_AUTH_NEVER) {
	    printf("TPM_LoadKeyCommon: Error, authorization required\n");
	    rc = TPM_AUTHFAIL;
	}
    }
    /* get parentHandle -> usageAuth */
    if ((rc == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	rc = TPM_Key_GetUsageAuth(&parentUsageAuth, parentKey);
    }	 
    /* get the session data */
    if ((rc == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	rc = TPM_AuthSessions_GetData(auth_session_data,
				      hmacKey,
				      tpm_state,
				      authHandle,
				      TPM_PID_NONE,
				      TPM_ET_KEYHANDLE,
				      ordinal,
				      parentKey,
				      parentUsageAuth,			/* OIAP */
				      parentKey->tpm_store_asymkey->pubDataDigest);	/* OSAP */
    }
    /* 1. Validate the command and the parameters using parentAuth and parentHandle -> usageAuth */
    if ((rc == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	rc = TPM_Authdata_Check(tpm_state,
				**hmacKey,		/* HMAC key */
				inParamDigest,
				*auth_session_data,	/* authorization session */
				nonceOdd,		/* Nonce generated by system
							   associated with authHandle */
				continueAuthSession,
				parentAuth);		/* Authorization digest for input */
    }
    /* 2. If parentHandle -> keyUsage is NOT TPM_KEY_STORAGE return TPM_INVALID_KEYUSAGE */
    if (rc == TPM_SUCCESS) {
	if (parentKey->keyUsage != TPM_KEY_STORAGE) {
	    printf("TPM_LoadKeyCommon: Error, "
		   "parentHandle -> keyUsage should be TPM_KEY_STORAGE, is %04x\n",
		   parentKey->keyUsage);
	    rc = TPM_INVALID_KEYUSAGE;
	}
    }
    /* 3. If the TPM is not designed to operate on a key of the type specified by inKey, return the
       error code TPM_BAD_KEY_PROPERTY.	 */
    if (rc == TPM_SUCCESS) {
	rc = TPM_Key_CheckProperties(&ver, inKey, 0, tpm_state->tpm_permanent_flags.FIPS);
	printf("TPM_LoadKeyCommon: key parameters v = %d\n", ver);
    }
    /* 4. The TPM MUST handle both TPM_KEY and TPM_KEY12 structures.
       This step is done at TPM_Key_Load()
    */
    /* 5. Decrypt the inKey -> privkey to obtain TPM_STORE_ASYMKEY structure using the key in
       parentHandle.
    */
    if (rc == TPM_SUCCESS) {
	rc = TPM_Key_DecryptEncData(inKey, parentKey);
    }
    /* 6. Validate the integrity of inKey and decrypted TPM_STORE_ASYMKEY
       a. Reproduce inKey -> TPM_STORE_ASYMKEY -> pubDataDigest using the fields of inKey, and check
       that the reproduced value is the same as pubDataDigest
    */
    if (rc == TPM_SUCCESS) {
	rc = TPM_Key_CheckPubDataDigest(inKey);
    }
    /* 7. Validate the consistency of the key and it's key usage. */
    /* a. If inKey -> keyFlags -> migratable is TRUE, the TPM SHALL verify consistency of the public
       and private components of the asymmetric key pair. If inKey -> keyFlags -> migratable is
       FALSE, the TPM MAY verify consistency of the public and private components of the asymmetric
       key pair. The consistency of an RSA key pair MAY be verified by dividing the supposed (P*Q)
       product by a supposed prime and checking that there is no remainder.

       This step is done at TPM_Key_Load()
    */
    /* b.  If inKey -> keyUsage is TPM_KEY_IDENTITY, verify that inKey->keyFlags->migratable is
       FALSE. If it is not, return TPM_INVALID_KEYUSAGE
    */
    if (rc == TPM_SUCCESS) {
	if ((inKey->keyUsage == TPM_KEY_IDENTITY) &&
	    (inKey->keyFlags & TPM_MIGRATABLE)) {
	    printf("TPM_LoadKeyCommon: Error, identity key is migratable\n");
	    rc = TPM_INVALID_KEYUSAGE;
	}
    }
    /* c.  If inKey -> keyUsage is TPM_KEY_AUTHCHANGE, return TPM_INVALID_KEYUSAGE */
    if (rc == TPM_SUCCESS) {
	if (inKey->keyUsage == TPM_KEY_AUTHCHANGE) {
	    printf("TPM_LoadKeyCommon: Error, keyUsage is TPM_KEY_AUTHCHANGE\n");
	    rc = TPM_INVALID_KEYUSAGE;
	}
    }
    /* d.  If inKey -> keyFlags -> migratable equals 0 then verify that TPM_STORE_ASYMKEY ->
       migrationAuth equals TPM_PERMANENT_DATA -> tpmProof */
    if (rc == TPM_SUCCESS) {
	if (!(inKey->keyFlags & TPM_MIGRATABLE)) {
	    rc = TPM_Secret_Compare(tpm_state->tpm_permanent_data.tpmProof,
				   inKey->tpm_store_asymkey->migrationAuth);
	    if (rc != 0) {
		printf("TPM_LoadKeyCommon: Error, tpmProof mismatch\n");
		rc = TPM_INVALID_KEYUSAGE;
	    }
	}
    }
    /*	 e.   Validate the mix of encryption and signature schemes
	 f.   If TPM_PERMANENT_FLAGS -> FIPS is TRUE then
	 i.   If keyInfo -> keySize is less than 1024 return TPM_NOTFIPS
	 ii.  If keyInfo -> authDataUsage specifies TPM_AUTH_NEVER return
	 TPM_NOTFIPS
	 iii.  If  keyInfo  ->	keyUsage specifies TPM_KEY_LEGACY  return
	 TPM_NOTFIPS
	 g.   If inKey -> keyUsage is TPM_KEY_STORAGE or TPM_KEY_MIGRATE
	 i.   algorithmID MUST be TPM_ALG_RSA
	 ii.  Key size MUST be 2048
	 iii. exponentSize MUST be 0
	 iv. sigScheme MUST be TPM_SS_NONE
	 h.   If inKey -> keyUsage is TPM_KEY_IDENTITY
	 i.   algorithmID MUST be TPM_ALG_RSA
	 ii.  Key size MUST be 2048
	 iv. exponentSize MUST be 0
	 iii. encScheme MUST be TPM_ES_NONE
	 NOTE Done in step 3.  
    */
    if (rc == TPM_SUCCESS) {
	/* i. If the decrypted inKey -> pcrInfo is NULL, */
	/* i. The TPM MUST set the internal indicator to indicate that the key is not using any PCR
	   registers. */
	/* j.  Else */
	/* i. The TPM MUST store pcrInfo in a manner that allows the TPM to calculate a composite
	   hash whenever the key will be in use */
	/* ii. The TPM MUST handle both version 1.1 TPM_PCR_INFO and 1.2 TPM_PCR_INFO_LONG
	   structures according to the type of TPM_KEY structure */
	/* (1) The TPM MUST validate the TPM_PCR_INFO or TPM_PCR_INFO_LONG structures for legal
	       values.	However, the digestAtRelease and localityAtRelease are not validated for
	       authorization until use time.*/
	/* NOTE TPM_Key_Load() loads the TPM_PCR_INFO or TPM_PCR_INFO_LONG cache */
    }
    /* 8.  Perform any processing necessary to make TPM_STORE_ASYMKEY key available for
       operations. */
    /* NOTE Done at TPM_Key_Load() */
    /* 9. Load key and key information into internal memory of the TPM. If insufficient memory
       exists return error TPM_NOSPACE. */
    /* 10. Assign inKeyHandle according to internal TPM rules. */
    /* 11. Set InKeyHandle -> parentPCRStatus to parentHandle -> parentPCRStatus. */
    if (rc == TPM_SUCCESS) {
	*inKeyHandle = 0;	/* no preferred value */
	rc = TPM_KeyHandleEntries_AddKeyEntry(inKeyHandle,			/* output */
					      tpm_state->tpm_key_handle_entries, /* input */
					      inKey,				/* input */
					      parentPCRStatus,
					      0);			/* keyControl */
    }
    if (rc == TPM_SUCCESS) {
	printf(" TPM_LoadKeyCommon: Loaded key handle %08x\n", *inKeyHandle);
	/* remember that the handle has been added to handle list, so it can be deleted on error */
	*key_added = TRUE;
	
    }
    /* 12. If parentHandle indicates it is using PCR registers then set inKeyHandle ->
       parentPCRStatus to TRUE. */
    if (rc == TPM_SUCCESS) {
	rc = TPM_Key_GetPCRUsage(&parentPCRUsage, parentKey, 0);
    }
    if (rc == TPM_SUCCESS) {
	if (parentPCRUsage) {
	    rc = TPM_KeyHandleEntries_SetParentPCRStatus(tpm_state->tpm_key_handle_entries,
							 *inKeyHandle, TRUE);
	}
    }	
    return rc;
}

/* 10.6 TPM_GetPubKey rev 102

   The owner of a key may wish to obtain the public key value from a loaded key. This information
   may have privacy concerns so the command must have authorization from the key owner.
*/

TPM_RESULT TPM_Process_GetPubKey(tpm_state_t *tpm_state,
				 TPM_STORE_BUFFER *response,
				 TPM_TAG tag,
				 uint32_t paramSize,
				 TPM_COMMAND_CODE ordinal,
				 unsigned char *command,
				 TPM_TRANSPORT_INTERNAL *transportInternal)
{
    TPM_RESULT	rcf = 0;			/* fatal error precluding response */
    TPM_RESULT	returnCode = TPM_SUCCESS;	/* command return code */

    /* input parameters */
    TPM_KEY_HANDLE	keyHandle;	/* TPM handle of key. */
    TPM_AUTHHANDLE	authHandle;	/* The authorization handle used for keyHandle
					   authorization. */
    TPM_NONCE		nonceOdd;	/* Nonce generated by system associated with authHandle */
    TPM_BOOL	continueAuthSession = TRUE;	/*The continue use flag for the authorization
						  handle */
    TPM_AUTHDATA	keyAuth;	/* Authorization HMAC key: key.usageAuth. */
    
    /* processing parameters */
    unsigned char *		inParamStart;		/* starting point of inParam's */
    unsigned char *		inParamEnd;		/* ending point of inParam's */
    TPM_DIGEST			inParamDigest;
    TPM_BOOL			auditStatus;		/* audit the ordinal */
    TPM_BOOL			transportEncrypt;	/* wrapped in encrypted transport session */
    TPM_BOOL			authHandleValid = FALSE;
    TPM_SECRET			*hmacKey;
    TPM_KEY			*key = NULL;		/* the key specified by keyHandle */
    TPM_BOOL			parentPCRStatus;
    TPM_AUTH_SESSION_DATA	*auth_session_data = NULL;	/* session data for authHandle */
    TPM_SECRET			*keyUsageAuth;
    TPM_STORE_BUFFER		pubkeyStream;

    /* output parameters */
    uint32_t			outParamStart;		/* starting point of outParam's */
    uint32_t			outParamEnd;		/* ending point of outParam's */
    TPM_DIGEST			outParamDigest;
    const unsigned char		*pubkeyStreamBuffer;	/* output */
    uint32_t			pubkeyStreamLength;

    printf("TPM_Process_GetPubKey: Ordinal Entry\n");
    TPM_Sbuffer_Init(&pubkeyStream);		/* freed @1 */
    /*
      get inputs
    */
    /* get keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Load32(&keyHandle, &command, &paramSize);
    }
    /* save the starting point of inParam's for authorization and auditing */
    inParamStart = command;
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_GetPubKey: keyHandle %08x\n", keyHandle);
    }
    /* save the ending point of inParam's for authorization and auditing */
    inParamEnd = command;
    /* digest the input parameters */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_GetInParamDigest(inParamDigest,	/* output */
					  &auditStatus,		/* output */
					  &transportEncrypt,	/* output */
					  tpm_state,
					  tag,
					  ordinal,
					  inParamStart,
					  inParamEnd,
					  transportInternal);
    }
    /* check state */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckState(tpm_state, tag, TPM_CHECK_ALL);
    }
    /* check tag */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_CheckRequestTag10(tag);
    }
    /* get the optional 'below the line' authorization parameters */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthParams_Get(&authHandle,
					&authHandleValid,
					nonceOdd,
					&continueAuthSession,
					keyAuth,
					&command, &paramSize);
    }
    if (returnCode == TPM_SUCCESS) {
	if (paramSize != 0) {
	    printf("TPM_Process_GetPubKey: Error, command has %u extra bytes\n",
		   paramSize);
	    returnCode = TPM_BAD_PARAM_SIZE;
	}
    }
    /* do not terminate sessions if the command did not parse correctly */
    if (returnCode != TPM_SUCCESS) {
	authHandleValid = FALSE;
    }
    /*
      Processing
    */
    /* get the key corresponding to the keyHandle parameter */
    if (returnCode == TPM_SUCCESS) {
	printf("TPM_Process_GetPubKey: Key handle %08x\n", keyHandle);
	returnCode = TPM_KeyHandleEntries_GetKey(&key, &parentPCRStatus, tpm_state, keyHandle,
						 TRUE,		/* read-only */
						 FALSE,		/* do not ignore PCRs */
						 FALSE);	/* cannot use EK */
    }
    /* 1. If tag = TPM_TAG_RQU_AUTH1_COMMAND then */
    /* get keyHandle -> usageAuth */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_Key_GetUsageAuth(&keyUsageAuth, key);
    }	 
    /* get the session data */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_AuthSessions_GetData(&auth_session_data,
					      &hmacKey,
					      tpm_state,
					      authHandle,
					      TPM_PID_NONE,
					      TPM_ET_KEYHANDLE,
					      ordinal,
					      key,
					      keyUsageAuth,		/* OIAP */
					      key->tpm_store_asymkey->pubDataDigest);	/* OSAP */
    }


    /* a. Validate the command parameters using keyHandle -> usageAuth, on error return
       TPM_AUTHFAIL */
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	returnCode = TPM_Authdata_Check(tpm_state,
					*hmacKey,		/* HMAC key */
					inParamDigest,
					auth_session_data,	/* authorization session */
					nonceOdd,		/* Nonce generated by system
								   associated with authHandle */
					continueAuthSession,
					keyAuth);		/* Authorization digest for input */
    }
    /* 2. Else	*/
    if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_COMMAND)){
	/* a. Verify that keyHandle -> authDataUsage is TPM_NO_READ_PUBKEY_AUTH or TPM_AUTH_NEVER,
	   on error return TPM_AUTHFAIL */
#ifdef TPM_V12
	if ((key->authDataUsage != TPM_NO_READ_PUBKEY_AUTH) &&
	    (key->authDataUsage != TPM_AUTH_NEVER)) {
	    printf("TPM_Process_GetPubKey: Error, authorization required\n");
	    returnCode = TPM_AUTHFAIL;
	}
#else	/* TPM 1.1 does not have TPM_NO_READ_PUBKEY_AUTH */
	if (key->authDataUsage != TPM_AUTH_NEVER) {
	    printf("TPM_Process_GetPubKey: Error, authorization required\n");
	    returnCode = TPM_AUTHFAIL;
	}
#endif
    }
#ifdef TPM_V12	/* TPM 1.1 does not have readSRKPub  */
    if (returnCode == TPM_SUCCESS) {
	/* 3. If keyHandle == TPM_KH_SRK then  */
	if ((keyHandle == TPM_KH_SRK) &&
	    /* a. If TPM_PERMANENT_FLAGS -> readSRKPub is FALSE then return TPM_INVALID_KEYHANDLE */
	    !tpm_state->tpm_permanent_flags.readSRKPub) {
	    printf("TPM_Process_GetPubKey: "
		   "Error, keyHandle is TPM_KH_SRK and readSRKPub is FALSE\n");
	    returnCode = TPM_INVALID_KEYHANDLE;
	}
    }
#endif
    /* 4. If keyHandle -> pcrInfoSize is not 0 */
    /* a. If keyHandle -> keyFlags has pcrIgnoredOnRead set to FALSE */
    /* i. Create a digestAtRelease according to the specified PCR registers and compare
       to keyHandle -> digestAtRelease and if a mismatch return TPM_WRONGPCRVAL */
    /* ii. If specified validate any locality requests */
    /* NOTE: Done at TPM_KeyHandleEntries_GetKey() */
    /* 5. Create a TPM_PUBKEY structure and return */
    if (returnCode == TPM_SUCCESS) {
	returnCode = TPM_Key_StorePubkey(&pubkeyStream,		/* output */
					 &pubkeyStreamBuffer,	/* output */
					 &pubkeyStreamLength,	/* output */
					 key);			/* input */
    }
    /*
      response
    */
    /* standard response: tag, (dummy) paramSize, returnCode.  Failure is fatal. */
    if (rcf == 0) {
	printf("TPM_Process_GetPubKey: Ordinal returnCode %08x %u\n",
	       returnCode, returnCode);
	rcf = TPM_Sbuffer_StoreInitialResponse(response, tag, returnCode);
    }
    /* success response, append the rest of the parameters.  */
    if (rcf == 0) {
	if (returnCode == TPM_SUCCESS) {
	    /* checkpoint the beginning of the outParam's */
	    outParamStart = response->buffer_current - response->buffer;
	    /* TPM_PUBKEY structure  */
	    returnCode = TPM_Sbuffer_Append(response, pubkeyStreamBuffer, pubkeyStreamLength);
	    /* checkpoint the end of the outParam's */
	    outParamEnd = response->buffer_current - response->buffer;
	}
	/* digest the above the line output parameters */
	if (returnCode == TPM_SUCCESS) {
	    returnCode = TPM_GetOutParamDigest(outParamDigest,	/* output */
					       auditStatus,	/* input audit status */
					       transportEncrypt,
					       tag,			
					       returnCode,
					       ordinal,		/* command ordinal */
					       response->buffer + outParamStart,	/* start */
					       outParamEnd - outParamStart);	/* length */
	}
	/* calculate and set the below the line parameters */
	if ((returnCode == TPM_SUCCESS) && (tag == TPM_TAG_RQU_AUTH1_COMMAND)) {
	    returnCode = TPM_AuthParams_Set(response,
					    *hmacKey,		/* owner HMAC key */
					    auth_session_data,
					    outParamDigest,
					    nonceOdd,
					    continueAuthSession);
	}
	/* audit if required */
	if ((returnCode == TPM_SUCCESS) && auditStatus) {
	    returnCode = TPM_ProcessAudit(tpm_state,
					  transportEncrypt,
					  inParamDigest,
					  outParamDigest,
					  ordinal);
	}
	/* adjust the initial response */
	rcf = TPM_Sbuffer_StoreFinalResponse(response, returnCode, tpm_state);
    }
    /* if there was an error, or continueAuthSession is FALSE, terminate the session */
    if (((rcf != 0) ||
	 ((returnCode != TPM_SUCCESS) && (returnCode != TPM_DEFEND_LOCK_RUNNING)) ||
	 !continueAuthSession) &&
	authHandleValid) {
	TPM_AuthSessions_TerminateHandle(tpm_state->tpm_stclear_data.authSessions, authHandle);
    }
    /*
      cleanup
    */
    TPM_Sbuffer_Delete(&pubkeyStream);		/* @1 */
    return rcf;
}