sha1.cpp

以前发的那个只实现了SHA-1, 现在补全了, sha-160, sha-224, sha-256, sha-384, sha-512

/*
 *  SHA1.c
 *
 *  Description:
 *      This file implements the Secure Hashing Algorithm 1 as
 *      defined in FIPS PUB 180-1 published April 17, 1995.
 *
 *      The SHA-1, produces a 160-bit message digest for a given
 *      data stream.  It should take about 2**n steps to find a
 *      message with the same digest as a given message and
 *      2**(n/2) to find any two messages with the same digest,
 *      when n is the digest size in bits.  Therefore, this
 *      algorithm can serve as a means of providing a
 *      "fingerprint" for a message.
 *
 *  Portability Issues:
 *      SHA-1 is defined in terms of 32-bit "words".  This code
 *      uses <stdint.h> (included via "sha1.h" to define 32 and 8
 *      bit unsigned integer types.  If your C compiler does not
 *      support 32 bit unsigned integers, this code is not
 *      appropriate.
 *
 *  Caveats:
 *      SHA-1 is designed to work with messages less than 2^64 bits
 *      long.  Although SHA-1 allows a message digest to be generated
 *      for messages of any number of bits less than 2^64, this
 *      implementation only works with messages with a length that is
 *      a multiple of the size of an 8-bit character.
 *
 */

/********************************************************************

Copyright 2006-2008 ZHANG Luduo. All Rights Reserved.

Permission to use, copy, modify, distribute and sell this software
and its documentation for any purpose is hereby granted without fee,
provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear
in supporting documentation.

********************************************************************/

/*

代码说明 : 

	SHA1算法实现, 此份代码参考了RFC3174.txt, 
	对源码略有修改

联系方式:

	作者  - 张鲁夺
	MSN   - [e-mail]
	Email - [e-mail]
	QQ群  - 34064264, 56918155

为所有爱我的人和我爱的人努力!

*/

#include "StdAfx.h"
#include "SHA1.h"

// Define the SHA1 circular left shift macro
#define SHA1CircularShift(bits, word) ((((word) << (bits)) & 0xFFFFFFFF) | ((word) >> (32 - (bits))))

SHA1::SHA1()
{

}

SHA1::~SHA1()
{

}

/** SHA1Reset

	Description:
		This function will initialize the SHA1Context in preparation
		for computing a new SHA1 message digest.

	Parameters:
		context: [in/out]
			The context to reset.
*/
void SHA1::SHA1Reset (SHA1Context* context)
{
    context->Length_Low             = 0;
    context->Length_High            = 0;
    context->Message_Block_Index    = 0;

    context->Message_Digest[0]      = 0x67452301;
    context->Message_Digest[1]      = 0xEFCDAB89;
    context->Message_Digest[2]      = 0x98BADCFE;
    context->Message_Digest[3]      = 0x10325476;
    context->Message_Digest[4]      = 0xC3D2E1F0;

    context->Computed   = 0;
    context->Corrupted  = 0;
}

/** SHA1Input

	Description:
		This function accepts an array of octets as the next portion
		of the message.

	Parameters:
		context: [in/out]
			The SHA context to update
		message_array: [in]
			An array of characters representing the next portion of
			the message.
		length: [in]
			The length of the message in message_array
*/
SHA1::SHA_ERROR SHA1::SHA1Input(SHA1Context* context, const unsigned char* message_array, unsigned length)
{
	if (!length || !context || !message_array)
		return SHA_NULL;

	if (context->Computed)
	{
		context->Corrupted = SHA_STATEERROR;
		return SHA_STATEERROR;
	}

	if (context->Corrupted)
		 return SHA_STATEERROR;

	while(length-- && !context->Corrupted)
	{
		context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);

		context->Length_Low += 8;

		// Force it to 32 bits
		context->Length_Low &= 0xFFFFFFFF;

		if (context->Length_Low == 0)
		{
			context->Length_High++;

			// Force it to 32 bits
			context->Length_High &= 0xFFFFFFFF;

			if (context->Length_High == 0)
			{
				// Message is too long
				context->Corrupted = 1;
			}
		}

		if (context->Message_Block_Index == 64)
		{
			SHA1ProcessMessageBlock(context);
		}

		message_array++;
	}

	return SHA_SUCCESS;
}

/** SHA1ProcessMessageBlock

	Description:
		This function will process the next 512 bits of the message
		stored in the Message_Block array.

	Parameters:
		None.

	Returns:
		Nothing.

	Comments:
		Many of the variable names in this code, especially the
		single character names, were used because those were the
		names used in the publication.
*/
void SHA1::SHA1ProcessMessageBlock(SHA1Context *context)
{
	// Constants defined in SHA-1
	const unsigned long K[] =    
	{
		0x5A827999,
		0x6ED9EBA1,
		0x8F1BBCDC,
		0xCA62C1D6
	};

	int				t;				// Loop counter
	unsigned long	temp;			// Temporary word value
	unsigned long	W[80];			// Word sequence
	unsigned long	A, B, C, D, E;	// Word buffers

	// Initialize the first 16 words in the array W

	for(t = 0; t < 16; t++)
	{
		W[t] = context->Message_Block[t * 4] << 24;
		W[t] |= context->Message_Block[t * 4 + 1] << 16;
		W[t] |= context->Message_Block[t * 4 + 2] << 8;
		W[t] |= context->Message_Block[t * 4 + 3];
	}

	for(t = 16; t < 80; t++)
	{
	   W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
	}

	A = context->Message_Digest[0];
	B = context->Message_Digest[1];
	C = context->Message_Digest[2];
	D = context->Message_Digest[3];
	E = context->Message_Digest[4];

	for(t = 0; t < 20; t++)
	{
		temp =  SHA1CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
		temp &= 0xFFFFFFFF;
		E = D;
		D = C;
		C = SHA1CircularShift(30, B);
		B = A;
		A = temp;
	}

	for(t = 20; t < 40; t++)
	{
		temp = SHA1CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1];
		temp &= 0xFFFFFFFF;
		E = D;
		D = C;
		C = SHA1CircularShift(30, B);
		B = A;
		A = temp;
	}

	for(t = 40; t < 60; t++)
	{
		temp = SHA1CircularShift(5, A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
		temp &= 0xFFFFFFFF;
		E = D;
		D = C;
		C = SHA1CircularShift(30, B);
		B = A;
		A = temp;
	}

	for(t = 60; t < 80; t++)
	{
		temp = SHA1CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3];
		temp &= 0xFFFFFFFF;
		E = D;
		D = C;
		C = SHA1CircularShift(30, B);
		B = A;
		A = temp;
	}

	context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF;
	context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF;
	context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF;
	context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF;
	context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF;

	context->Message_Block_Index = 0;
}

/** SHA1PadMessage
	Description:
		According to the standard, the message must be padded to an even
		512 bits.  The first padding bit must be a '1'.  The last 64
		bits represent the length of the original message.  All bits in
		between should be 0.  This function will pad the message
		according to those rules by filling the Message_Block array
		accordingly.  It will also call the ProcessMessageBlock function
		provided appropriately.  When it returns, it can be assumed that
		the message digest has been computed.
	Parameters:
		context: [in/out]
		The context to pad
		ProcessMessageBlock: [in]
		The appropriate SHA*ProcessMessageBlock function
	Returns:
		Nothing.
*/
void SHA1::SHA1PadMessage(SHA1Context *context)
{
	/** Check to see if the current message block is too small to hold
		the initial padding bits and length.  If so, we will pad the
		block, process it, and then continue padding into a second
		block.
	*/
	if (context->Message_Block_Index > 55)
	{
		context->Message_Block[context->Message_Block_Index++] = 0x80;
		while(context->Message_Block_Index < 64)
		{
			context->Message_Block[context->Message_Block_Index++] = 0;
		}
		
		SHA1ProcessMessageBlock(context);
		
		while(context->Message_Block_Index < 56)
		{
			context->Message_Block[context->Message_Block_Index++] = 0;
		}
	}
	else
	{
		context->Message_Block[context->Message_Block_Index++] = 0x80;
		while(context->Message_Block_Index < 56)
		{
			context->Message_Block[context->Message_Block_Index++] = 0;
		}
	}

	// Store the message length as the last 8 octets

    context->Message_Block[56] = (unsigned char)(context->Length_High >> 24) & 0xFF;
    context->Message_Block[57] = (unsigned char)(context->Length_High >> 16) & 0xFF;
    context->Message_Block[58] = (unsigned char)(context->Length_High >> 8) & 0xFF;
    context->Message_Block[59] = (unsigned char)(context->Length_High) & 0xFF;
    context->Message_Block[60] = (unsigned char)(context->Length_Low >> 24) & 0xFF;
    context->Message_Block[61] = (unsigned char)(context->Length_Low >> 16) & 0xFF;
    context->Message_Block[62] = (unsigned char)(context->Length_Low >> 8) & 0xFF;
    context->Message_Block[63] = (unsigned char)(context->Length_Low) & 0xFF;

    SHA1ProcessMessageBlock(context);
}

/** SHA1Result

	Description:
		This function will return the 160-bit message digest into the
		Message_Digest array  provided by the caller.
		NOTE: The first octet of hash is stored in the 0th element,
			  the last octet of hash in the 19th element.

	Parameters:
		context: [in/out]
			The context to use to calculate the SHA-1 hash.
		Message_Digest: [out]
			Where the digest is returned.

	Returns:
		sha Error Code.
*/
SHA1::SHA_ERROR SHA1::SHA1Result(SHA1Context* context, unsigned char Message_Digest[20])
{
    if (!context || !Message_Digest)
        return SHA_NULL;

    if (context->Corrupted)
        return SHA_STATEERROR;

    if (!context->Computed)
    {
        SHA1PadMessage(context);
        context->Computed = 1;
    }

    for(int i = 0; i < 20; ++i)
        Message_Digest[i] = (unsigned char)(context->Message_Digest[i >> 2] >> 8 * ( 3 - (i & 0x03)));

	return SHA_SUCCESS;
}