Renegade/Code/wwlib/rndstraw.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts 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 3 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, see <http://www.gnu.org/licenses/>.
*/

/*********************************************************************************************** 
 ***              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                                            * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Library/RNDSTRAW.CPP                              $* 
 *                                                                                             * 
 *                      $Author:: Greg_h                                                      $*
 *                                                                                             * 
 *                     $Modtime:: 7/22/97 11:37a                                              $*
 *                                                                                             * 
 *                    $Revision:: 1                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 *   RandomStraw::Get -- Fetch random data.                                                    *
 *   RandomStraw::RandomStraw -- Constructor for the random straw class.                       *
 *   RandomStraw::Reset -- Reset the data to known initial state.                              *
 *   RandomStraw::Scramble_Seed -- Masks any coorelation between the seed bits.                *
 *   RandomStraw::Seed_Bit -- Add a random bit to the accumulated seed value.                  *
 *   RandomStraw::Seed_Bits_Needed -- Fetches the number of seed bits needed.                  *
 *   RandomStraw::Seed_Byte -- Submit 8 bits to the random number seed.                        *
 *   RandomStraw::Seed_Long -- Submit 32 bits to the random number seed.                       *
 *   RandomStraw::Seed_Short -- Submit 16 bits to the random number seed.                      *
 *   RandomStraw::~RandomStraw -- Destructor for random straw class.                           *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include	"always.h"
#include	"rndstraw.h"
#include	"sha.h"
#include	<limits.h>
#include	<string.h>


/***********************************************************************************************
 * RandomStraw::RandomStraw -- Constructor for the random straw class.                         *
 *                                                                                             *
 *    This will initialize the random straw into a known state. The initial state is useless   *
 *    for cryptographic purposes. It must be seeded before it should be used.                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
RandomStraw::RandomStraw(void) :
	SeedBits(0),
	Current(0)
{
	Reset();
}


/***********************************************************************************************
 * RandomStraw::~RandomStraw -- Destructor for random straw class.                             *
 *                                                                                             *
 *    This destructor will clear out the seed data so that there won't be any sensitive        *
 *    information left over in the memory this object occupied.                                *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
RandomStraw::~RandomStraw(void)
{
	Reset();
}


/***********************************************************************************************
 * RandomStraw::Reset -- Reset the data to known initial state.                                *
 *                                                                                             *
 *    This routine is functionally equivalent to performing an placement new on the object. It *
 *    clears out all the seed data.                                                            *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   You must reseed it before fetching random numbers.                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Reset(void)
{
	SeedBits = 0;
	Current = 0;
	memset(Random, '\0', sizeof(Random));
}


/***********************************************************************************************
 * RandomStraw::Seed_Bits_Needed -- Fetches the number of seed bits needed.                    *
 *                                                                                             *
 *    This routine is used when seeding the random straw. Keep feeding random bits to this     *
 *    class until the Seed_Bits_Needed value returns zero. Random bits should be gathered from *
 *    sources external to the immediate program. Examples would be the system clock (good for  *
 *    a few bits), the delay between player keystrokes (good for a few bits per keystroke),    *
 *    etc. When gathering random bits from integers, use the low order bits (since they        *
 *    characteristically are less predictable and more 'random' than the others).              *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the number of bits required in order to fully seed this random        *
 *          number generator.                                                                  *
 *                                                                                             *
 * WARNINGS:   Even if this routine returns zero, you are still allowed and encouraged to feed *
 *             more random bits when the opportunity arrises.                                  *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
int RandomStraw::Seed_Bits_Needed(void) const
{
	const int total = sizeof(Random) * CHAR_BIT;
	if (SeedBits < total) {
		return(total - SeedBits);
	}
	return(0);
}


/***********************************************************************************************
 * RandomStraw::Seed_Bit -- Add a random bit to the accumulated seed value.                    *
 *                                                                                             *
 *    This routine should be called to feed a single random bit to the random straw object.    *
 *    You must feed as many bits as requested by the Seed_Bits_Needed() function. Submitting   *
 *    additional bits is not only allowed, but encouraged.                                     *
 *                                                                                             *
 * INPUT:   seed  -- The bit (lowest order bit) to feed to the random number seed.             *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Seed_Bit(int seed)
{
	char * ptr = ((char *)&Random[0]) + ((SeedBits / CHAR_BIT) % sizeof(Random));
	char frac = (char)(1 << (SeedBits & (CHAR_BIT-1)));

	if (seed & 0x01) {
		*ptr ^= frac;
	}
	SeedBits++;

	if (SeedBits == (sizeof(Random) * CHAR_BIT)) {
		Scramble_Seed();
	}
}


/***********************************************************************************************
 * RandomStraw::Seed_Byte -- Submit 8 bits to the random number seed.                          *
 *                                                                                             *
 *    This will submit 8 bits (as specified) to the random number seed.                        *
 *                                                                                             *
 * INPUT:   seed  -- The seed bits to submit.                                                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Seed_Byte(char seed)
{
	for (int index = 0; index < CHAR_BIT; index++) {
		Seed_Bit(seed);
		seed >>= 1;
	}
}


/***********************************************************************************************
 * RandomStraw::Seed_Short -- Submit 16 bits to the random number seed.                        *
 *                                                                                             *
 *    This will submit 16 bits to the accumulated seed.                                        *
 *                                                                                             *
 * INPUT:   seed  -- The 16 bits to submit to the seed.                                        *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Seed_Short(short seed)
{
	for (int index = 0; index < (sizeof(seed)*CHAR_BIT); index++) {
		Seed_Bit(seed);
		seed >>= 1;
	}
}


/***********************************************************************************************
 * RandomStraw::Seed_Long -- Submit 32 bits to the random number seed.                         *
 *                                                                                             *
 *    This will submit a full 32 bits to the accumulated seed value.                           *
 *                                                                                             *
 * INPUT:   seed  -- The 32 bits to submit.                                                    *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Seed_Long(long seed)
{
	for (int index = 0; index < (sizeof(seed)*CHAR_BIT); index++) {
		Seed_Bit(seed);
		seed >>= 1;
	}
}


/***********************************************************************************************
 * RandomStraw::Scramble_Seed -- Masks any coorelation between the seed bits.                  *
 *                                                                                             *
 *    This routine is called when a full set of seed bits has been accumulated. It will take   *
 *    the existing seed and scramble the bits. An effective way of doing this is to use the    *
 *    Secure Hash Algorithm. It is necessary to have this routine because there might be       *
 *    some coorelation in the seed bits. Even more important is that this routine will result  *
 *    in every bit of the seed having a scrambling effect on every other bit.                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/10/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void RandomStraw::Scramble_Seed(void)
{
	SHAEngine sha;

	for (int index = 0; index < sizeof(Random); index++) {
		char digest[20];

		sha.Hash(&Random[0], sizeof(Random));
		sha.Result(digest);

		int tocopy = sizeof(digest) < (sizeof(Random)-index) ? sizeof(digest) : (sizeof(Random)-index);
		memmove(((char *)&Random[0]) + index, digest, tocopy);
	}
}


/***********************************************************************************************
 * RandomStraw::Get -- Fetch random data.                                                      *
 *                                                                                             *
 *    This routine will fetch random data and store it into the buffer specified.              *
 *                                                                                             *
 * INPUT:   source   -- Pointer to the buffer to fill with random data.                        *
 *                                                                                             *
 *          length   -- The number of bytes to store into the buffer.                          *
 *                                                                                             *
 * OUTPUT:  Returns with the actual number of bytes stored into the buffer. This will always   *
 *          be the number of bytes requested since random numbers are unexhaustible.           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/04/1996 JLB : Created.                                                                 *
 *   07/10/1996 JLB : Revamped to make cryptographically secure.                               *
 *=============================================================================================*/
int RandomStraw::Get(void * source, int slen)
{
	if (source == NULL || slen < 1) {
		return(Straw::Get(source, slen));
	}

	int total = 0;
	while (slen > 0) {
		*(char *)source = (char)(Random[Current++]());
		Current = Current % (sizeof(Random) / sizeof(Random[0]));
		source = (char*)source + sizeof(char);
		slen--;
		total++;
	}
	return(total);
}