keys.c

IBM开发的TPM的驱动, 有少量的例子可以供参考

	/* 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;
}