hmac.c

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

/****************************************************************************/
/*                                                                          */
/*                               HMAC routines                              */
/*                                                                          */
/*                           Written by J. Kravitz                          */
/*                                                                          */
/*                     IBM Thomas J. Watson Research Center                 */
/*                                                                          */
/*                               Version 1.3                                */
/*                                                                          */
/*                         Last Revision 23 Feb 2004                        */
/*                                                                          */
/*                           Copyright (C) 2004 IBM                         */
/*                                                                          */
/****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <tpm.h>
#include <tpmutil.h>
#include <hmac.h>

#include <openssl/sha.h>
#include <openssl/hmac.h>

#define TPM_TAG_RSP_COMMAND       0x00C4
#define TPM_TAG_RSP_AUTH1_COMMAND 0x00C5
#define TPM_TAG_RSP_AUTH2_COMMAND 0x00C6

/****************************************************************************/
/*                                                                          */
/* Validate the HMAC in an AUTH1 response                                   */
/*                                                                          */
/* This function validates the Authorization Digest for all AUTH1           */
/* responses.                                                               */
/*                                                                          */
/* The arguments are...                                                     */
/*                                                                          */
/* buffer - a pointer to response buffer                                    */
/* command - the command code from the original request                     */
/* ononce - a pointer to a 20 byte array containing the oddNonce            */
/* key    - a pointer to the key used in the request HMAC                   */
/* keylen - the size of the key                                             */
/* followed by a variable length set of arguments, which must come in       */
/* pairs.                                                                   */
/* The first value in each pair is the length of the data in the second     */
/*   argument of the pair                                                   */
/* The second value in each pair is an offset in the buffer to the data     */
/*   to be included in the hash for the paramdigest                         */
/* There should NOT be pairs for the TPM_RESULT or TPM_COMMAND_CODE         */
/* The last pair must be followed by a pair containing 0,0                  */
/*                                                                          */
/****************************************************************************/
uint32_t TSS_checkhmac1(unsigned char *buffer, uint32_t command,
			unsigned char *ononce, unsigned char *key,
			unsigned int keylen, ...)
{
	uint32_t bufsize;
	uint16_t tag;
	uint32_t ordinal;
	uint32_t result;
	unsigned char *enonce;
	unsigned char *continueflag;
	unsigned char *authdata;
	unsigned char testhmac[20];
	unsigned char paramdigest[20];
	SHA_CTX sha;
	unsigned int dlen;
	unsigned int dpos;
	va_list argp;

	bufsize = LOAD32(buffer, TPM_U16_SIZE);
	tag = LOAD16(buffer, 0);
	ordinal = command;
	result = LOAD32N(buffer, TPM_RETURN_OFFSET);

	if (tag == TPM_TAG_RSP_COMMAND)
		return 0;
	if (tag != TPM_TAG_RSP_AUTH1_COMMAND)
		return ERR_HMAC_FAIL;
	authdata = buffer + bufsize - TPM_HASH_SIZE;
	continueflag = authdata - 1;
	enonce = continueflag - TPM_NONCE_SIZE;
	SHA1_Init(&sha);
	SHA1_Update(&sha, &result, 4);
	SHA1_Update(&sha, &ordinal, 4);
	va_start(argp, keylen);
	for (;;) {
		dlen = (unsigned int) va_arg(argp, unsigned int);
		if (dlen == 0)
			break;
		dpos = (unsigned int) va_arg(argp, unsigned int);
		SHA1_Update(&sha, buffer + dpos, dlen);
	}
	va_end(argp);
	SHA1_Final(paramdigest, &sha);
	TSS_rawhmac(testhmac, key, keylen, TPM_HASH_SIZE, paramdigest,
		    TPM_NONCE_SIZE, enonce,
		    TPM_NONCE_SIZE, ononce, 1, continueflag, 0, 0);
	if (memcmp(testhmac, authdata, TPM_HASH_SIZE) != 0)
		return ERR_HMAC_FAIL;
	return 0;
}

/****************************************************************************/
/*                                                                          */
/* Validate the HMACS in an AUTH2 response                                  */
/*                                                                          */
/* This function validates the Authorization Digests for all AUTH2          */
/* responses.                                                               */
/*                                                                          */
/* The arguments are...                                                     */
/*                                                                          */
/* buffer - a pointer to response buffer                                    */
/* command - the command code from the original request                     */
/* ononce - a pointer to a 20 byte array containing the oddNonce            */
/* key1    - a pointer to the 1st   key used in the request HMAC            */
/* keylen1 - the size of the key                                            */
/* key2    - a pointer to the 2nd   key used in the request HMAC            */
/* keylen2 - the size of the key                                            */
/* followed by a variable length set of arguments, which must come in       */
/* pairs.                                                                   */
/* The first value in each pair is the length of the data in the second     */
/*   argument of the pair                                                   */
/* The second value in each pair is an offset in the buffer to the data     */
/*   to be included in the hash for the paramdigest                         */
/* There should NOT be pairs for the TPM_RESULT or TPM_COMMAND_CODE         */
/* The last pair must be followed by a pair containing 0,0                  */
/*                                                                          */
/****************************************************************************/
uint32_t TSS_checkhmac2(unsigned char *buffer, uint32_t command,
			unsigned char *ononce, unsigned char *key1,
			unsigned int keylen1, unsigned char *key2,
			unsigned int keylen2, ...)
{
	uint32_t bufsize;
	uint16_t tag;
	uint32_t ordinal;
	uint32_t result;
	unsigned char *enonce1;
	unsigned char *continueflag1;
	unsigned char *authdata1;
	unsigned char *enonce2;
	unsigned char *continueflag2;
	unsigned char *authdata2;
	unsigned char testhmac1[20];
	unsigned char paramdigest[20];
	unsigned char testhmac2[20];
	SHA_CTX sha;
	unsigned int dlen;
	unsigned int dpos;
	va_list argp;

	bufsize = LOAD32(buffer, TPM_U16_SIZE);
	tag = LOAD16(buffer, 0);
	ordinal = command;
	result = LOAD32N(buffer, TPM_RETURN_OFFSET);

	if (tag == TPM_TAG_RSP_COMMAND)
		return 0;
	if (tag != TPM_TAG_RSP_AUTH2_COMMAND)
		return ERR_HMAC_FAIL;
	authdata1 =
	    buffer + bufsize - (TPM_HASH_SIZE + 1 + TPM_HASH_SIZE +
				TPM_HASH_SIZE);
	authdata2 = buffer + bufsize - (TPM_HASH_SIZE);
	continueflag1 = authdata1 - 1;
	continueflag2 = authdata2 - 1;
	enonce1 = continueflag1 - TPM_NONCE_SIZE;
	enonce2 = continueflag2 - TPM_NONCE_SIZE;
	SHA1_Init(&sha);
	SHA1_Update(&sha, &result, 4);
	SHA1_Update(&sha, &ordinal, 4);
	va_start(argp, keylen2);
	for (;;) {
		dlen = (unsigned int) va_arg(argp, unsigned int);
		if (dlen == 0)
			break;
		dpos = (unsigned int) va_arg(argp, unsigned int);
		SHA1_Update(&sha, buffer + dpos, dlen);
	}
	SHA1_Final(paramdigest, &sha);
	TSS_rawhmac(testhmac1, key1, keylen1, TPM_HASH_SIZE, paramdigest,
		    TPM_NONCE_SIZE, enonce1,
		    TPM_NONCE_SIZE, ononce, 1, continueflag1, 0, 0);
	TSS_rawhmac(testhmac2, key2, keylen2, TPM_HASH_SIZE, paramdigest,
		    TPM_NONCE_SIZE, enonce2,
		    TPM_NONCE_SIZE, ononce, 1, continueflag2, 0, 0);
	if (memcmp(testhmac1, authdata1, TPM_HASH_SIZE) != 0)
		return ERR_HMAC_FAIL;
	if (memcmp(testhmac2, authdata2, TPM_HASH_SIZE) != 0)
		return ERR_HMAC_FAIL;
	return 0;
}

/****************************************************************************/
/*                                                                          */
/* Calculate HMAC value for an AUTH1 command                                */
/*                                                                          */
/* This function calculates the Authorization Digest for all OIAP           */
/* commands.                                                                */
/*                                                                          */
/* The arguments are...                                                     */
/*                                                                          */
/* digest - a pointer to a 20 byte array that will receive the result       */
/* key    - a pointer to the key to be used in the HMAC calculation         */
/* keylen - the size of the key in bytes                                    */
/* h1     - a pointer to a 20 byte array containing the evenNonce           */
/* h2     - a pointer to a 20 byte array containing the oddNonce            */
/* h3     - an unsigned character containing the continueAuthSession value  */
/* followed by a variable length set of arguments, which must come in       */
/* pairs.                                                                   */
/* The first value in each pair is the length of the data in the second     */
/*   argument of the pair                                                   */
/* The second value in each pair is a pointer to the data to be hashed      */
/*   into the paramdigest.                                                  */
/* The last pair must be followed by a pair containing 0,0                  */
/*                                                                          */
/****************************************************************************/
uint32_t TSS_authhmac(unsigned char *digest, unsigned char *key,
		      unsigned int keylen, unsigned char *h1,
		      unsigned char *h2, unsigned char h3, ...)
{
	unsigned char paramdigest[TPM_HASH_SIZE];
	SHA_CTX sha;
	unsigned int dlen;
	unsigned char *data;
	unsigned char c;

	va_list argp;

	SHA1_Init(&sha);
	if (h1 == NULL || h2 == NULL)
		return ERR_NULL_ARG;
	c = h3;
	va_start(argp, h3);
	for (;;) {
		dlen = (unsigned int) va_arg(argp, unsigned int);
		if (dlen == 0)
			break;
		data = (unsigned char *) va_arg(argp, int);
		if (data == NULL)
			return ERR_NULL_ARG;
		SHA1_Update(&sha, data, dlen);
	}
	va_end(argp);
	SHA1_Final(paramdigest, &sha);
	TSS_rawhmac(digest, key, keylen, TPM_HASH_SIZE, paramdigest,
		    TPM_NONCE_SIZE, h1, TPM_NONCE_SIZE, h2, 1, &c, 0, 0);
	return 0;
}

/****************************************************************************/
/*                                                                          */
/* Calculate Raw HMAC value                                                 */
/*                                                                          */
/* This function calculates an HMAC digest                                  */
/*                                                                          */
/* The arguments are...                                                     */
/*                                                                          */
/* digest - a pointer to a 20 byte array that will receive the result       */
/* key    - a pointer to the key to be used in the HMAC calculation         */
/* keylen - the size of the key in bytes                                    */
/* followed by a variable length set of arguments, which must come in       */
/* pairs.                                                                   */
/* The first value in each pair is the length of the data in the second     */
/*   argument of the pair                                                   */
/* The second value in each pair is a pointer to the data to be hashed      */
/*   into the paramdigest.                                                  */
/* The last pair must be followed by a pair containing 0,0                  */
/*                                                                          */
/****************************************************************************/
uint32_t TSS_rawhmac(unsigned char *digest, unsigned char *key,
		     unsigned int keylen, ...)
{
	HMAC_CTX hmac;
	unsigned int dlen;
	unsigned char *data;
	va_list argp;

#ifdef HAVE_HMAC_CTX_CLEANUP
	HMAC_CTX_init(&hmac);
#endif
	HMAC_Init(&hmac, key, keylen, EVP_sha1());
	va_start(argp, keylen);
	for (;;) {
		dlen = (unsigned int) va_arg(argp, unsigned int);
		if (dlen == 0)
			break;
		data = (unsigned char *) va_arg(argp, int);
		if (data == NULL)
			return ERR_NULL_ARG;
		HMAC_Update(&hmac, data, dlen);
	}
	HMAC_Final(&hmac, digest, &dlen);
#ifdef HAVE_HMAC_CTX_CLEANUP
	HMAC_CTX_cleanup(&hmac);
#else
	HMAC_cleanup(&hmac);
#endif
	va_end(argp);
	return 0;
}