/* transmit the request buffer to the TPM device and read the reply */	ret = TPM_Transmit(tpmdata, "EvictKey");	if (ret != 0)		return ret;	return 0;}/****************************************************************************//*                                                                          *//* Create a buffer from a keydata structure                                 *//*                                                                          *//****************************************************************************/uint32_t TPM_BuildKey(unsigned char *buffer, keydata * k){	unsigned char build_key_fmt[] = "% S L o L S S L L L L @ @ @";	uint32_t ret;	ret = TSS_buildbuff(build_key_fmt, buffer,			    4, k->version,			    k->keyusage,			    k->keyflags,			    k->authdatausage,			    k->pub.algorithm,			    k->pub.encscheme,			    k->pub.sigscheme,			    12,			    k->pub.keybitlen,			    k->pub.numprimes,			    0,			    k->pub.pcrinfolen, k->pub.pcrinfo,			    k->pub.keylength, k->pub.modulus,			    k->privkeylen, k->encprivkey);	return ret;}/****************************************************************************//*                                                                          *//* Walk down a Key blob extracting information                              *//*                                                                          *//****************************************************************************/int TSS_KeyExtract(unsigned char *keybuff, keydata * k){	int offset;	int pubkeylen;	/* fill in  keydata structure */	offset = 0;	memcpy(k->version, keybuff + offset, sizeof(k->version));	offset += 4;	k->keyusage = LOAD16(keybuff, offset);	offset += TPM_U16_SIZE;	k->keyflags = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	k->authdatausage = keybuff[offset];	offset += 1;	pubkeylen = TSS_PubKeyExtract(keybuff + offset, &(k->pub), 1);	offset += pubkeylen;	k->privkeylen = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	if (k->privkeylen > 0 && k->privkeylen <= 1024)		memcpy(k->encprivkey, keybuff + offset, k->privkeylen);	offset += k->privkeylen;	return offset;}/****************************************************************************//*                                                                          *//* Walk down a Public Key blob extracting information                       *//*                                                                          *//****************************************************************************/int TSS_PubKeyExtract(unsigned char *keybuff, pubkeydata * k,		      int pcrpresent){	uint32_t parmsize;	uint32_t pcrisize;	int offset;	offset = 0;	k->algorithm = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	k->encscheme = LOAD16(keybuff, offset);	offset += TPM_U16_SIZE;	k->sigscheme = LOAD16(keybuff, offset);	offset += TPM_U16_SIZE;	parmsize = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	if (k->algorithm == 0x00000001 && parmsize > 0) {	/* RSA */		k->keybitlen = LOAD32(keybuff, offset);		offset += TPM_U32_SIZE;		k->numprimes = LOAD32(keybuff, offset);		offset += TPM_U32_SIZE;		k->expsize = LOAD32(keybuff, offset);		offset += TPM_U32_SIZE;	} else {		offset += parmsize;	}	if (k->expsize == 3) {		k->exponent[0] = *(keybuff + offset + 0);		k->exponent[1] = *(keybuff + offset + 1);		k->exponent[2] = *(keybuff + offset + 2);		offset += k->expsize;	} else if (k->expsize != 0)		offset += k->expsize;	else {		k->exponent[0] = 0x01;		k->exponent[1] = 0x00;		k->exponent[2] = 0x01;		k->expsize = 3;	}	if (pcrpresent) {		pcrisize = LOAD32(keybuff, offset);		offset += TPM_U32_SIZE;		if (pcrisize > 0 && pcrisize <= 256)			memcpy(k->pcrinfo, keybuff + offset, pcrisize);		offset += pcrisize;		k->pcrinfolen = pcrisize;	}	k->keylength = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	if (k->keylength > 0 && k->keylength <= 256)		memcpy(k->modulus, keybuff + offset, k->keylength);	offset += k->keylength;	return offset;}/****************************************************************************//*                                                                          *//* Extract a Pubkey Blob from a Key Blob                                    *//*                                                                          *//****************************************************************************/void TSS_Key2Pub(unsigned char *keybuff, unsigned char *pkey,		 unsigned int *plen){	int srcoff1;	int srcoff2;	int srcoff3;	int dstoff1;	int dstoff2;	int dstoff3;	int len1;	int len2;	int len3;	int pointer;	int parmsize;	int pcrisize;	int pubksize;	srcoff1 = TPM_U32_SIZE + TPM_U16_SIZE + TPM_U32_SIZE + 1;	dstoff1 = 0;	len1 = TPM_U32_SIZE + TPM_U16_SIZE + TPM_U16_SIZE + TPM_U32_SIZE;	memcpy(pkey + dstoff1, keybuff + srcoff1, len1);	dstoff2 = dstoff1 + len1;	srcoff2 = srcoff1 + len1;	pointer = srcoff1 + TPM_U32_SIZE + TPM_U16_SIZE + TPM_U16_SIZE;	parmsize = LOAD32(keybuff, pointer);	len2 = parmsize;	memcpy(pkey + dstoff2, keybuff + srcoff2, len2);	pointer = pointer + TPM_U32_SIZE + parmsize;	pcrisize = LOAD32(keybuff, pointer);	pointer = pointer + TPM_U32_SIZE + pcrisize;	pubksize = LOAD32(keybuff, pointer);	dstoff3 = dstoff2 + len2;	srcoff3 = pointer;	len3 = pubksize + TPM_U32_SIZE;	memcpy(pkey + dstoff3, keybuff + srcoff3, len3);	*plen = len1 + len2 + len3;}/****************************************************************************//*                                                                          *//* Calculate the size of a Key Blob                                         *//*                                                                          *//****************************************************************************/int TSS_KeySize(unsigned char *keybuff){	int offset;	int privkeylen;	offset = 0 + 4 + TPM_U16_SIZE + TPM_U32_SIZE + 1;	offset += TSS_PubKeySize(keybuff + offset, 1);	privkeylen = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE + privkeylen;	return offset;}/****************************************************************************//*                                                                          *//* Calculate the size of a Public Key Blob                                  *//*                                                                          *//****************************************************************************/int TSS_PubKeySize(unsigned char *keybuff, int pcrpresent){	uint32_t parmsize;	uint32_t pcrisize;	uint32_t keylength;	int offset;	offset = 0 + TPM_U32_SIZE + TPM_U16_SIZE + TPM_U16_SIZE;	parmsize = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	offset += parmsize;	if (pcrpresent) {		pcrisize = LOAD32(keybuff, offset);		offset += TPM_U32_SIZE;		offset += pcrisize;	}	keylength = LOAD32(keybuff, offset);	offset += TPM_U32_SIZE;	offset += keylength;	return offset;}/****************************************************************************//*                                                                          *//* Convert a TPM public key to an OpenSSL RSA public key                    *//*                                                                          *//****************************************************************************/RSA *TSS_convpubkey(pubkeydata * k){	RSA *rsa;	BIGNUM *mod;	BIGNUM *exp;	/* create the necessary structures */	rsa = RSA_new();	mod = BN_new();	exp = BN_new();	if (rsa == NULL || mod == NULL || exp == NULL)		return NULL;	/* convert the raw public key values to BIGNUMS */	BN_bin2bn(k->modulus, k->keylength, mod);	BN_bin2bn(k->exponent, k->expsize, exp);	/* set up the RSA public key structure */	rsa->n = mod;	rsa->e = exp;	return rsa;}/****************************************************************************//*                                                                          *//* Get the Fingerprint of a Key given a pubkeydata structure                *//*                                                                          *//****************************************************************************/void TSS_pkeyprint(pubkeydata * key, unsigned char *fprint){	TSS_sha1(key->modulus, key->keylength, fprint);}/****************************************************************************//*                                                                          *//* Get the Fingerprint of a Key given a key blob                            *//*                                                                          *//****************************************************************************/void TSS_keyprint(unsigned char *keybuff, unsigned char *fprint){	keydata k;	TSS_KeyExtract(keybuff, &k);	TSS_pkeyprint(&(k.pub), fprint);}/****************************************************************************//*                                                                          *//* Get the Fingerprint of a Key given a loaded key handle and authdata      *//*                                                                          *//****************************************************************************/uint32_t TSS_lkeyprint(uint32_t keyhandle, unsigned char *keyauth,		       unsigned char *fprint){	uint32_t ret;	unsigned char keyblob[TPM_MAX_BUFF_SIZE];	unsigned int keyblen;	pubkeydata k;	ret = TPM_GetPubKey(keyhandle, keyauth, keyblob, &keyblen);	if (ret != 0)		return ret;	TSS_PubKeyExtract(keyblob, &k, 0);	TSS_pkeyprint(&k, fprint);	return 0;}