rvmd5.c

h.248协议源码

/******************************************************************************
Filename:    rvmd5.c
Description: md5 hashing and authentication algorithms
*******************************************************************************
                Copyright (c) 2000 RADVision Inc.
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever without
written prior approval by RADVision Inc.

RADVision Inc. reserves the right to revise this publication and make changes
without obligation to notify any person of such revisions or changes.
******************************************************************************/

#include <string.h>
#include "rvmem.h"
#include "rvsecutil.h"
#include "rvmd5.h"

static void rvMd5Loop(const char *buf, size_t buflen, char *output)
{
	const size_t numBlocks = buflen / 64;
	RvUint32 a=0x67452301, b=0xefcdab89, c=0x98badcfe, d=0x10325476;
	RvUint32 *writeWord = (RvUint32 *)output;
	size_t i;

	for(i=0; i<numBlocks; ++i)
	{
		static const RvUint32 T[] = {
			0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
			0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
			0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
			0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
			0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
			0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
			0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
			0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
		static const int idx[] =
		{	0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
			1,  6, 11,  0,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12,
			5,  8, 11, 14,  1,  4,  7, 10, 13,  0,  3,  6,  9, 12, 15,  2,
			0,  7, 14,  5, 12,  3, 10,  1,  8, 15,  6, 13,  4, 11,  2,  9 };
		static const unsigned int s[] =
		{   7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
			5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,
			4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,
			6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21 };
		static const RvSecAuxFunc func[] = { rvSecAuxFuncF, rvSecAuxFuncG, rvSecAuxFuncH, rvSecAuxFuncI };
		RvUint32 aa=a, bb=b, cc=c, dd=d;
		const RvUint32 *M = (const RvUint32 *)(buf + i * 64);
		size_t n;
		for(n=0; n<64; ++n)
		{
			RvSecAuxFunc Q = func[n / 16];
			a = b + rvLeftRotate(a + Q(b, c, d) + rvToLittleEndian(M[idx[n]]) + T[n], s[n]);
			++n;
			d = a + rvLeftRotate(d + Q(a, b, c) + rvToLittleEndian(M[idx[n]]) + T[n], s[n]);
			++n;
			c = d + rvLeftRotate(c + Q(d, a, b) + rvToLittleEndian(M[idx[n]]) + T[n], s[n]);
			++n;
			b = c + rvLeftRotate(b + Q(c, d, a) + rvToLittleEndian(M[idx[n]]) + T[n], s[n]);
		}
		a += aa, b += bb, c += cc, d += dd;
	}
	*writeWord++ = rvToLittleEndian(a);
	*writeWord++ = rvToLittleEndian(b);
	*writeWord++ = rvToLittleEndian(c);
	*writeWord++ = rvToLittleEndian(d);
}

static void rvMd5WithBuffer(char *buf, size_t textlen, size_t buflen, char *output)
{
	/* pad with a single 1 bit followed by all 0 bits */
	memset(buf + textlen, 0, buflen - textlen);
	buf[textlen] = (char)0x80;

	/* append length in bits as 64 bit little endian integer */
	*(RvUint32*)(buf + buflen - 8) = rvToLittleEndian(8 * textlen);

	rvMd5Loop(buf, buflen, output);
}

/*$
{function:
	{name: rvMd5 }
	{superpackage: Security}	
	{include: rvmd5.h}
	{description:
		{p: This method performs a Message Digest 5 (MD5) one-way hash on a buffer to 
            produce a 128-bit hash.}
	}
	{proto:void rvMd5(const char* text, size_t textlen, char* output);}
	{params:
		{param: {n: text}    {d:The text buffer to be hashed.}}
		{param: {n: textlen} {d:The length of the text buffer in bytes.}}
		{param: {n: output}  {d:The buffer to be filled in with the results of the hash.
                                This should be at least RV_MD5_HASHLENGTH bytes long (16 bytes).}}
	}
}
$*/
void rvMd5(const char *text, size_t textlen, char *output)
{
	size_t buflen = textlen + rvSecGetPadding(textlen);
	char *buf = (char *)rvMemAlloc(buflen);
	memcpy(buf, text, textlen);
	rvMd5WithBuffer(buf, textlen, buflen, output);
	rvMemFree(buf);
}

/*$
{function:
	{name: rvHmacMd5 }
	{superpackage: Security}	
	{include: rvmd5.h}
	{description:
		{p: This method creates a Hashed Message Authentication Code (HMAC) using the
            MD5 algorithm.}
		{p: See the IETF Informational RFC 2104 "HMAC: Keyed-Hashing for message
            authentication" for information on HMAC.}
	}
	{proto: void rvHmacMd5(const char* text, size_t textlen, const char* key, size_t keylen, char* output);}
	{params:
		{param: {n: text}    {d:The text buffer to be hashed.}}
		{param: {n: textlen} {d:The length of the text buffer in bytes.}}
		{param: {n: key}     {d:The key to use in the hash.}}
		{param: {n: keylen}  {d:The length of the key in bytes.}}
		{param: {n: output}  {d:The buffer to be filled in with the results.
                                This should be at least RV_MD5_HASHLENGTH bytes long (16 bytes).}}
	}
}
$*/
void rvHmacMd5(const char *text, size_t textlen, const char *key, size_t keylen, char *output)
{
	rvHmac(text, textlen, key, keylen, output, rvMd5, rvMd5WithBuffer, RV_MD5_HASHLENGTH);
}