CnC_Remastered_Collection

SHA.CPP (16166B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code 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 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/SHA.CPP 1     3/03/97 10:25a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : SHA.CPP                                                      *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : 07/03/96                                                     *
  *                                                                                             *
  *                  Last Update : July 3, 1996 [JLB]                                           *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  *   SHAEngine::Result -- Fetch the current digest.                                            *
  *   SHAEngine::Hash -- Process an arbitrarily long data block.                                *
  *   SHAEngine::Process_Partial -- Helper routine to process any partially accumulated data blo*
  *   SHAEngine::Process_Block -- Process a full data block into the hash accumulator.          *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	<stdlib.h>
 //#include	<iostream.h>
 #include	"sha.h"
 
 
 
 #if !defined(__BORLANDC__) && !defined(min)
 #define	min(a, b)		((a)<(b))?(a):(b)
 #endif
 
 
 /***********************************************************************************************
  * SHAEngine::Process_Partial -- Helper routine to process any partially accumulated data bloc *
  *                                                                                             *
  *    This routine will see if there is a partial block already accumulated in the holding     *
  *    buffer. If so, then the data is fetched from the source such that a full buffer is       *
  *    accumulated and then processed. If there is insufficient data to fill the buffer, then   *
  *    it accumulates what data it can and then returns so that this routine can be called      *
  *    again later.                                                                             *
  *                                                                                             *
  * INPUT:   data  -- Reference to a pointer to the data. This pointer will be modified if      *
  *                   this routine consumes any of the data in the buffer.                      *
  *                                                                                             *
  *          length-- Reference to the length of the data available. If this routine consumes   *
  *                   any of the data, then this length value will be modified.                 *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 void SHAEngine::Process_Partial(void const * & data, long & length)
 {
 	if (length == 0 || data == NULL) return;
 
 	/*
 	**	If there is no partial buffer and the source is greater than
 	**	a source block size, then partial processing is unnecessary.
 	**	Bail out in this case.
 	*/
 	if (PartialCount == 0 && length >= SRC_BLOCK_SIZE) return;
 
 	/*
 	**	Attach as many bytes as possible from the source data into
 	**	the staging buffer.
 	*/
 	int add_count = min((int)length, SRC_BLOCK_SIZE - PartialCount);
 	memcpy(&Partial[PartialCount], data, add_count);
 	data = ((char const *&)data) + add_count;
 	PartialCount += add_count;
 	length -= add_count;
 
 	/*
 	**	If a full staging buffer has been accumulated, then process
 	**	the staging buffer and then bail.
 	*/
 	if (PartialCount == SRC_BLOCK_SIZE) {
 		Process_Block(&Partial[0], Acc);
 		Length += (long)SRC_BLOCK_SIZE;
 		PartialCount = 0;
 	}
 }
 
 
 /***********************************************************************************************
  * SHAEngine::Hash -- Process an arbitrarily long data block.                                  *
  *                                                                                             *
  *    This is the main access routine to the SHA engine. It will take the arbitrarily long     *
  *    data block and process it. The hash value is accumulated with any previous calls to      *
  *    this routine.                                                                            *
  *                                                                                             *
  * INPUT:   data     -- Pointer to the data block to process.                                  *
  *                                                                                             *
  *          length   -- The number of bytes to process.                                        *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 void SHAEngine::Hash(void const * data, long length)
 {
 	IsCached = false;
 
 	/*
 	**	Check for and handle any smaller-than-512bit blocks. This can
 	**	result in all of the source data submitted to this routine to be
 	**	consumed at this point.
 	*/
 	Process_Partial(data, length);
 
 	/*
 	**	If there is no more source data to process, then bail. Speed reasons.
 	*/
 	if (length == 0) return;
 
 	/*
 	**	First process all the whole blocks available in the source data.
 	*/
 	long blocks = (length / SRC_BLOCK_SIZE);
 	long const * source = (long const *)data;
 	for (int bcount = 0; bcount < blocks; bcount++) {
 		Process_Block(source, Acc);
 		Length += (long)SRC_BLOCK_SIZE;
 		source += SRC_BLOCK_SIZE/sizeof(long);
 		length -= (long)SRC_BLOCK_SIZE;
 	}
 
 	/*
 	**	Process any remainder bytes. This data is stored in the source
 	**	accumulator buffer for future processing.
 	*/
 	data = source;
 	Process_Partial(data, length);
 }
 
 
 #define	Reverse_LONG(a)	((a>>24)&0x000000FFL) | ((a>>8)&0x0000FF00L) | ((a<<8)&0x00FF0000L) | ((a<<24)&0xFF000000L)
 
 
 /***********************************************************************************************
  * SHAEngine::Result -- Fetch the current digest.                                              *
  *                                                                                             *
  *    This routine will return the digest as it currently stands.                              *
  *                                                                                             *
  * INPUT:   pointer  -- Pointer to the buffer that will hold the digest -- 20 bytes.           *
  *                                                                                             *
  * OUTPUT:  Returns with the number of bytes copied into the buffer. This will always be       *
  *          20.                                                                                *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 int SHAEngine::Result(void * result) const
 {
 	/*
 	**	If the final hash result has already been calculated for the
 	**	current data state, then immediately return with the precalculated
 	**	value.
 	*/
 	if (IsCached) {
 		memcpy(result, &FinalResult, sizeof(FinalResult));
 	}
 
 	long length = Length + PartialCount;
 	int partialcount = PartialCount;
 	char partial[SRC_BLOCK_SIZE];
 	memcpy(partial, Partial, sizeof(Partial));
 
 	/*
 	**	Cap the end of the source data stream with a 1 bit.
 	*/
 	partial[partialcount] = (char)0x80;
 
 	/*
 	**	Determine if there is insufficient room to append the
 	**	data length number to the hash source. If not, then
 	**	fill out the rest of the accumulator and flush it to
 	**	the hash so that there will be room for the final
 	**	count value.
 	*/
 	SHADigest acc = Acc;
 	if ((SRC_BLOCK_SIZE - partialcount) < 9) {
 		if (partialcount+1 < SRC_BLOCK_SIZE) {
 			memset(&partial[partialcount+1], '\0', SRC_BLOCK_SIZE - (partialcount+1));
 		}
 		Process_Block(&partial[0], acc);
 		partialcount = 0;
 	} else {
 		partialcount++;
 	}
 
 	/*
 	**	Put the length of the source data as a 64 bit integer in the
 	**	last 8 bytes of the pseudo-source data.
 	*/
 	memset(&partial[partialcount], '\0', SRC_BLOCK_SIZE - partialcount);
 	*(long *)(&partial[SRC_BLOCK_SIZE-4]) = Reverse_LONG((length*8));
 	Process_Block(&partial[0], acc);
 
 	memcpy((char *)&FinalResult, &acc, sizeof(acc));
 	for (int index = 0; index < sizeof(FinalResult)/sizeof(long); index++) {
 //	for (int index = 0; index < SRC_BLOCK_SIZE/sizeof(long); index++) {
 		(long &)FinalResult.Long[index] = Reverse_LONG(FinalResult.Long[index]);
 	}
 	(bool&)IsCached = true;
 	memcpy(result, &FinalResult, sizeof(FinalResult));
 	return(sizeof(FinalResult));
 }
 
 /*
 **	This pragma to turn off the warning "Conversion may lose significant digits" is to
 **	work around a bug within the Borland compiler. It will give this warning when the
 **	_rotl() function is called but will NOT give the warning when the _lrotl() function
 **	is called even though they both have the same parameters and declaration attributes.
 */
 //#pragma warn -sig
 template<class T>
 T _rotl(T X, int n)
 {
 	return(T)( ( X << n ) | ( (unsigned)X >> ((sizeof(T)*8) - n) ) );
 }
 //unsigned long _RTLENTRY _rotl(unsigned long X, int n)
 //{
 //	return(unsigned long)( (unsigned long)( (unsigned long)( (unsigned long)X ) << (int)n ) | (unsigned long)( ((unsigned long) X ) >> ( (int)((int)(sizeof(long)*(long)8) - (long)n) ) ) );
 //}
 void memrev(char * buffer, size_t length);
 
 
 /***********************************************************************************************
  * SHAEngine::Process_Block -- Process a full data block into the hash accumulator.            *
  *                                                                                             *
  *    This helper routine is called when a full block of data is available for processing      *
  *    into the hash.                                                                           *
  *                                                                                             *
  * INPUT:   source   -- Pointer to the block of data to process.                               *
  *                                                                                             *
  *          acc      -- Reference to the hash accumulator that this hash step will be          *
  *                      accumulated into.                                                      *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   07/03/1996 JLB : Created.                                                                 *
  *=============================================================================================*/
 void SHAEngine::Process_Block(void const * source, SHADigest & acc) const
 {
 	/*
 	**	The hash is generated by performing operations on a
 	**	block of generated/seeded data.
 	*/
 	long block[PROC_BLOCK_SIZE/sizeof(long)];
 
 	/*
 	**	Expand the source data into a large 80 * 32bit buffer. This is the working
 	**	data that will be transformed by the secure hash algorithm.
 	*/
 	long const * data = (long const *)source;
 	int index;
 	for (index = 0; index < SRC_BLOCK_SIZE/sizeof(long); index++) {
 		block[index] = Reverse_LONG(data[index]);
 	}
 
 	for (index = SRC_BLOCK_SIZE/sizeof(long); index < PROC_BLOCK_SIZE/sizeof(long); index++) {
 //		block[index] = _rotl(block[(index-3)&15] ^ block[(index-8)&15] ^ block[(index-14)&15] ^ block[(index-16)&15], 1);
 		block[index] = _rotl(block[index-3] ^ block[index-8] ^ block[index-14] ^ block[index-16], 1);
 	}
 
 	/*
 	**	This is the core algorithm of the Secure Hash Algorithm. It is a block
 	**	transformation of 512 bit source data with a 2560 bit intermediate buffer.
 	*/
 	SHADigest alt = acc;
 	for (index = 0; index < PROC_BLOCK_SIZE/sizeof(long); index++) {
 		long temp = _rotl(alt.Long[0], 5) + Do_Function(index, alt.Long[1], alt.Long[2], alt.Long[3]) + alt.Long[4] + block[index] + Get_Constant(index);
 		alt.Long[4] = alt.Long[3];
 		alt.Long[3] = alt.Long[2];
 		alt.Long[2] = _rotl(alt.Long[1], 30);
 		alt.Long[1] = alt.Long[0];
 		alt.Long[0] = temp;
 	}
 	acc.Long[0] += alt.Long[0];
 	acc.Long[1] += alt.Long[1];
 	acc.Long[2] += alt.Long[2];
 	acc.Long[3] += alt.Long[3];
 	acc.Long[4] += alt.Long[4];
 }