md5.c

Linux下的RT系列无线网卡驱动,可以直接在x86平台上编译

/*
 *************************************************************************
 * Ralink Tech Inc.
 * 4F, No. 2 Technology 5th Rd.
 * Science-based Industrial Park
 * Hsin-chu, Taiwan, R.O.C.
 *
 * (c) Copyright 2002-2007, Ralink Technology, Inc.
 *
 * This program is free software; you can redistribute it and/or modify  * 
 * it under the terms of the GNU General Public License as published by  * 
 * the Free Software Foundation; either version 2 of the License, or     * 
 * (at your option) any later version.                                   * 
 *                                                                       * 
 * This program is distributed in the hope that it will be useful,       * 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        * 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         * 
 * GNU General Public License for more details.                          * 
 *                                                                       * 
 * You should have received a copy of the GNU General Public License     * 
 * along with this program; if not, write to the                         * 
 * Free Software Foundation, Inc.,                                       * 
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             * 
 *                                                                       * 
 *************************************************************************
 */ 
/* This	MD5	code is	based on code from Dynamics	-- HUT Mobile IP
 * Copyright (C) 1998-2001,	Dynamics group
 *
 * This	program	is free	software; you can redistribute it and/or modify
 * it under	the	terms of the GNU General Public	License	version	2 as
 * published by	the	Free Software Foundation. See README and COPYING for
 * more	details.

	Module Name:
	md5.c

	Abstract:
		contain	MD5	and	AES	cipher algorithm
		
	Revision History:
	Who			When			What
	--------	----------		----------------------------------------------
	jan		10-28-03		Initial
 */
#include "rt_config.h"


static  VOID    SHAHashBlock(SHA_CTX *ctx);

/**
 * md5_mac:
 * @key: pointer to	the	key	used for MAC generation
 * @key_len: length	of the key in bytes
 * @data: pointer to the data area for which the MAC is	generated
 * @data_len: length of	the	data in	bytes
 * @mac: pointer to	the	buffer holding space for the MAC; the buffer should
 * have	space for 128-bit (16 bytes) MD5 hash value
 *
 * md5_mac() determines	the	message	authentication code	by using secure	hash
 * MD5(key | data |	key).
 */
void md5_mac(u8	*key, size_t key_len, u8 *data,	size_t data_len, u8	*mac)
{
	MD5_CTX	context;

	MD5Init(&context);
	MD5Update(&context,	key, key_len);
	MD5Update(&context,	data, data_len);
	MD5Update(&context,	key, key_len);
	MD5Final(mac, &context);
}

/**
 * hmac_md5:
 * @key: pointer to	the	key	used for MAC generation
 * @key_len: length	of the key in bytes
 * @data: pointer to the data area for which the MAC is	generated
 * @data_len: length of	the	data in	bytes
 * @mac: pointer to	the	buffer holding space for the MAC; the buffer should
 * have	space for 128-bit (16 bytes) MD5 hash value
 *
 * hmac_md5() determines the message authentication	code using HMAC-MD5.
 * This	implementation is based	on the sample code presented in	RFC	2104.
 */
void hmac_md5(u8 *key, size_t key_len, u8 *data, size_t	data_len, u8 *mac)
{
	MD5_CTX	context;
	u8 k_ipad[65]; /* inner	padding	- key XORd with	ipad */
	u8 k_opad[65]; /* outer	padding	- key XORd with	opad */
	u8 tk[16];
	int	i;

	//assert(key != NULL && data != NULL && mac != NULL);

	/* if key is longer	than 64	bytes reset	it to key =	MD5(key) */
	if (key_len	> 64) {
		MD5_CTX	ttcontext;

		MD5Init(&ttcontext);
		MD5Update(&ttcontext, key, key_len);
		MD5Final(tk, &ttcontext);
		//key=(PUCHAR)ttcontext.buf;
		key	= tk;
		key_len	= 16;
	}

	/* the HMAC_MD5	transform looks	like:
	 *
	 * MD5(K XOR opad, MD5(K XOR ipad, text))
	 *
	 * where K is an n byte	key
	 * ipad	is the byte	0x36 repeated 64 times
	 * opad	is the byte	0x5c repeated 64 times
	 * and text	is the data	being protected	*/

	/* start out by	storing	key	in pads	*/
	NdisZeroMemory(k_ipad, sizeof(k_ipad));
	NdisZeroMemory(k_opad,	sizeof(k_opad));
	//assert(key_len < sizeof(k_ipad));
	NdisMoveMemory(k_ipad, key,	key_len);
	NdisMoveMemory(k_opad, key,	key_len);

	/* XOR key with	ipad and opad values */
	for	(i = 0;	i <	64;	i++) {
		k_ipad[i] ^= 0x36;
		k_opad[i] ^= 0x5c;
	}

	/* perform inner MD5 */
	MD5Init(&context);					 /*	init context for 1st pass */
	MD5Update(&context,	k_ipad,	64);	 /*	start with inner pad */
	MD5Update(&context,	data, data_len); /*	then text of datagram */
	MD5Final(mac, &context);			 /*	finish up 1st pass */

	/* perform outer MD5 */
	MD5Init(&context);					 /*	init context for 2nd pass */
	MD5Update(&context,	k_opad,	64);	 /*	start with outer pad */
	MD5Update(&context,	mac, 16);		 /*	then results of	1st	hash */
	MD5Final(mac, &context);			 /*	finish up 2nd pass */
}


/* ===== start - public	domain MD5 implementation =====	*/
/*
 * This	code implements	the	MD5	message-digest algorithm.
 * The algorithm is	due	to Ron Rivest.	This code was
 * written by Colin	Plumb in 1993, no copyright	is claimed.
 * This	code is	in the public domain; do with it what you wish.
 *
 * Equivalent code is available	from RSA Data Security,	Inc.
 * This	code has been tested against that, and is equivalent,
 * except that you don't need to include two pages of legalese
 * with	every copy.
 *
 * To compute the message digest of	a chunk	of bytes, declare an
 * MD5Context structure, pass it to	MD5Init, call MD5Update	as
 * needed on buffers full of bytes,	and	then call MD5Final,	which
 * will	fill a supplied	16-byte	array with the digest.
 */

//#ifndef WORDS_BIGENDIAN
#ifndef BIG_ENDIAN
#define	byteReverse(buf, len)	/* Nothing */
#else
void byteReverse(unsigned char *buf, unsigned longs);

//#ifndef ASM_MD5
#if	1
/*
 * Note: this code is harmless on little-endian	machines.
 */
void byteReverse(unsigned char *buf, unsigned longs)
{
	u32	t;

	do {
		t =	(u32) ((unsigned) buf[3] <<	8 |	buf[2])	<< 16 |	((unsigned)	buf[1] << 8	| buf[0]);
		*(u32 *) buf = t;
		buf	+= 4;
	} while	(--longs);
}
#endif
#endif

/*
 * Start MD5 accumulation.	Set	bit	count to 0 and buffer to mysterious
 * initialization constants.
 */
void MD5Init(struct	MD5Context *ctx)
{
	ctx->buf[0]	= 0x67452301;
	ctx->buf[1]	= 0xefcdab89;
	ctx->buf[2]	= 0x98badcfe;
	ctx->buf[3]	= 0x10325476;

	ctx->bits[0] = 0;
	ctx->bits[1] = 0;
}

/*
 * Update context to reflect the concatenation of another buffer full
 * of bytes.
 */
void MD5Update(struct MD5Context *ctx, unsigned	char *buf, unsigned len)
{
	u32	t;

	/* Update bitcount */

	t =	ctx->bits[0];
	if ((ctx->bits[0] =	t +	((u32) len << 3)) <	t)
		ctx->bits[1]++;		/* Carry from low to high */
	ctx->bits[1] +=	len	>> 29;

	t =	(t >> 3) & 0x3f;	/* Bytes already in	shsInfo->data */

	/* Handle any leading odd-sized	chunks */

	if (t) {
		unsigned char *p = (unsigned char *) ctx->in + t;

		t =	64 - t;
		if (len	< t) {
			NdisMoveMemory(p, buf, len);
			return;
		}
		NdisMoveMemory(p, buf, t);
		byteReverse(ctx->in, 16);
		MD5Transform(ctx->buf, (u32	*) ctx->in);
		buf	+= t;
		len	-= t;
	}
	/* Process data	in 64-byte chunks */

	while (len >= 64) {
		NdisMoveMemory(ctx->in,	buf, 64);
		byteReverse(ctx->in, 16);
		MD5Transform(ctx->buf, (u32	*) ctx->in);
		buf	+= 64;
		len	-= 64;
	}

	/* Handle any remaining	bytes of data. */

	NdisMoveMemory(ctx->in,	buf, len);
}

/*
 * Final wrapup	- pad to 64-byte boundary with the bit pattern
 * 1 0*	(64-bit	count of bits processed, MSB-first)
 */
void MD5Final(unsigned char	digest[16],	struct MD5Context *ctx)
{
	unsigned count;
	unsigned char *p;

	/* Compute number of bytes mod 64 */
	count =	(ctx->bits[0] >> 3)	& 0x3F;

	/* Set the first char of padding to	0x80.  This	is safe	since there	is
	   always at least one byte	free */
	p =	ctx->in	+ count;
	*p++ = 0x80;

	/* Bytes of	padding	needed to make 64 bytes	*/
	count =	64 - 1 - count;

	/* Pad out to 56 mod 64	*/
	if (count <	8) {
		/* Two lots	of padding:	 Pad the first block to	64 bytes */
		NdisZeroMemory(p, count);
		byteReverse(ctx->in, 16);
		MD5Transform(ctx->buf, (u32	*) ctx->in);

		/* Now fill	the	next block with	56 bytes */
		NdisZeroMemory(ctx->in,	56);
	} else {
		/* Pad block to	56 bytes */
		NdisZeroMemory(p,  count - 8);
	}
	byteReverse(ctx->in, 14);

	/* Append length in	bits and transform */
	((u32 *) ctx->in)[14] =	ctx->bits[0];
	((u32 *) ctx->in)[15] =	ctx->bits[1];

	MD5Transform(ctx->buf, (u32	*) ctx->in);
	byteReverse((unsigned char *) ctx->buf,	4);
	NdisMoveMemory(digest, ctx->buf, 16);
	NdisZeroMemory(ctx,	 sizeof(ctx));	/* In case it's	sensitive */
}

//#ifndef ASM_MD5
#if	1

/* The four	core functions - F1	is optimized somewhat */

/* #define F1(x, y,	z) (x &	y |	~x & z)	*/
#define	F1(x, y, z)	(z ^ (x	& (y ^ z)))
#define	F2(x, y, z)	F1(z, x, y)
#define	F3(x, y, z)	(x ^ y ^ z)
#define	F4(x, y, z)	(y ^ (x	| ~z))

/* This	is the central step	in the MD5 algorithm. */
#define	MD5STEP(f, w, x, y,	z, data, s)	\
	( w	+= f(x,	y, z) +	data,  w =(	w<<s | w>>(32-s))&0xffffffff,  w +=	x )

/*
 * The core	of the MD5 algorithm, this alters an existing MD5 hash to
 * reflect the addition	of 16 longwords	of new data.  MD5Update	blocks
 * the data	and	converts bytes into	longwords for this routine.
 */
void MD5Transform(u32 buf[4], u32 in[16])
{
	register u32 a,	b, c, d;

	a =	buf[0];
	b =	buf[1];
	c =	buf[2];
	d =	buf[3];

	MD5STEP(F1,	a, b, c, d,	in[0] +	0xd76aa478,	7);
	MD5STEP(F1,	d, a, b, c,	in[1] +	0xe8c7b756,	12);
	MD5STEP(F1,	c, d, a, b,	in[2] +	0x242070db,	17);
	MD5STEP(F1,	b, c, d, a,	in[3] +	0xc1bdceee,	22);
	MD5STEP(F1,	a, b, c, d,	in[4] +	0xf57c0faf,	7);
	MD5STEP(F1,	d, a, b, c,	in[5] +	0x4787c62a,	12);
	MD5STEP(F1,	c, d, a, b,	in[6] +	0xa8304613,	17);
	MD5STEP(F1,	b, c, d, a,	in[7] +	0xfd469501,	22);
	MD5STEP(F1,	a, b, c, d,	in[8] +	0x698098d8,	7);
	MD5STEP(F1,	d, a, b, c,	in[9] +	0x8b44f7af,	12);
	MD5STEP(F1,	c, d, a, b,	in[10] + 0xffff5bb1, 17);
	MD5STEP(F1,	b, c, d, a,	in[11] + 0x895cd7be, 22);
	MD5STEP(F1,	a, b, c, d,	in[12] + 0x6b901122, 7);
	MD5STEP(F1,	d, a, b, c,	in[13] + 0xfd987193, 12);
	MD5STEP(F1,	c, d, a, b,	in[14] + 0xa679438e, 17);
	MD5STEP(F1,	b, c, d, a,	in[15] + 0x49b40821, 22);

	MD5STEP(F2,	a, b, c, d,	in[1] +	0xf61e2562,	5);
	MD5STEP(F2,	d, a, b, c,	in[6] +	0xc040b340,	9);
	MD5STEP(F2,	c, d, a, b,	in[11] + 0x265e5a51, 14);
	MD5STEP(F2,	b, c, d, a,	in[0] +	0xe9b6c7aa,	20);
	MD5STEP(F2,	a, b, c, d,	in[5] +	0xd62f105d,	5);
	MD5STEP(F2,	d, a, b, c,	in[10] + 0x02441453, 9);
	MD5STEP(F2,	c, d, a, b,	in[15] + 0xd8a1e681, 14);
	MD5STEP(F2,	b, c, d, a,	in[4] +	0xe7d3fbc8,	20);
	MD5STEP(F2,	a, b, c, d,	in[9] +	0x21e1cde6,	5);
	MD5STEP(F2,	d, a, b, c,	in[14] + 0xc33707d6, 9);
	MD5STEP(F2,	c, d, a, b,	in[3] +	0xf4d50d87,	14);
	MD5STEP(F2,	b, c, d, a,	in[8] +	0x455a14ed,	20);
	MD5STEP(F2,	a, b, c, d,	in[13] + 0xa9e3e905, 5);
	MD5STEP(F2,	d, a, b, c,	in[2] +	0xfcefa3f8,	9);
	MD5STEP(F2,	c, d, a, b,	in[7] +	0x676f02d9,	14);
	MD5STEP(F2,	b, c, d, a,	in[12] + 0x8d2a4c8a, 20);

	MD5STEP(F3,	a, b, c, d,	in[5] +	0xfffa3942,	4);
	MD5STEP(F3,	d, a, b, c,	in[8] +	0x8771f681,	11);
	MD5STEP(F3,	c, d, a, b,	in[11] + 0x6d9d6122, 16);
	MD5STEP(F3,	b, c, d, a,	in[14] + 0xfde5380c, 23);
	MD5STEP(F3,	a, b, c, d,	in[1] +	0xa4beea44,	4);
	MD5STEP(F3,	d, a, b, c,	in[4] +	0x4bdecfa9,	11);
	MD5STEP(F3,	c, d, a, b,	in[7] +	0xf6bb4b60,	16);
	MD5STEP(F3,	b, c, d, a,	in[10] + 0xbebfbc70, 23);
	MD5STEP(F3,	a, b, c, d,	in[13] + 0x289b7ec6, 4);
	MD5STEP(F3,	d, a, b, c,	in[0] +	0xeaa127fa,	11);
	MD5STEP(F3,	c, d, a, b,	in[3] +	0xd4ef3085,	16);
	MD5STEP(F3,	b, c, d, a,	in[6] +	0x04881d05,	23);
	MD5STEP(F3,	a, b, c, d,	in[9] +	0xd9d4d039,	4);
	MD5STEP(F3,	d, a, b, c,	in[12] + 0xe6db99e5, 11);
	MD5STEP(F3,	c, d, a, b,	in[15] + 0x1fa27cf8, 16);
	MD5STEP(F3,	b, c, d, a,	in[2] +	0xc4ac5665,	23);

	MD5STEP(F4,	a, b, c, d,	in[0] +	0xf4292244,	6);
	MD5STEP(F4,	d, a, b, c,	in[7] +	0x432aff97,	10);
	MD5STEP(F4,	c, d, a, b,	in[14] + 0xab9423a7, 15);
	MD5STEP(F4,	b, c, d, a,	in[5] +	0xfc93a039,	21);
	MD5STEP(F4,	a, b, c, d,	in[12] + 0x655b59c3, 6);
	MD5STEP(F4,	d, a, b, c,	in[3] +	0x8f0ccc92,	10);
	MD5STEP(F4,	c, d, a, b,	in[10] + 0xffeff47d, 15);
	MD5STEP(F4,	b, c, d, a,	in[1] +	0x85845dd1,	21);
	MD5STEP(F4,	a, b, c, d,	in[8] +	0x6fa87e4f,	6);
	MD5STEP(F4,	d, a, b, c,	in[15] + 0xfe2ce6e0, 10);
	MD5STEP(F4,	c, d, a, b,	in[6] +	0xa3014314,	15);
	MD5STEP(F4,	b, c, d, a,	in[13] + 0x4e0811a1, 21);
	MD5STEP(F4,	a, b, c, d,	in[4] +	0xf7537e82,	6);
	MD5STEP(F4,	d, a, b, c,	in[11] + 0xbd3af235, 10);
	MD5STEP(F4,	c, d, a, b,	in[2] +	0x2ad7d2bb,	15);
	MD5STEP(F4,	b, c, d, a,	in[9] +	0xeb86d391,	21);

	buf[0] += a;
	buf[1] += b;
	buf[2] += c;
	buf[3] += d;
}
#endif

void SHAInit(SHA_CTX *ctx) {
	int	i;
 
	ctx->lenW =	0;
	ctx->sizeHi	= ctx->sizeLo =	0;
 
	/* Initialize H	with the magic constants (see FIPS180 for constants)
	 */
	ctx->H[0] =	0x67452301L;
	ctx->H[1] =	0xefcdab89L;
	ctx->H[2] =	0x98badcfeL;
	ctx->H[3] =	0x10325476L;