sha.h

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(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/SHA.H                                     $* 
 *                                                                                             * 
 *                      $Author:: Greg_h                                                      $*
 *                                                                                             * 
 *                     $Modtime:: 7/22/97 11:37a                                              $*
 *                                                                                             * 
 *                    $Revision:: 1                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#ifndef SHA_H
#define SHA_H
 
 
/*
**  The "bool" integral type was defined by the C++ comittee in
**  November of '94. Until the compiler supports this, use the following
**  definition.
*/
#include <new.h>
#include "always.h"
#include    "bool.h"
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
 
 
/*
**  This implements the Secure Hash Algorithm. It is a cryptographically
**  secure hash with no known weaknesses. It generates a 160 bit hash
**  result given an arbitrary length data source.
*/
class SHAEngine
{
    public:
        SHAEngine(void) : IsCached(false), Length(0), PartialCount(0) {
            Acc.Long[0] = (unsigned long)SA;
            Acc.Long[1] = (unsigned long)SB;
            Acc.Long[2] = (unsigned long)SC;
            Acc.Long[3] = (unsigned long)SD;
            Acc.Long[4] = (unsigned long)SE;
        };
 
        void Init(void) {
            new ((void*)this) SHAEngine;
        };
 
        // Fetch result as if source data were to stop now.
        int Result(void * result) const;
 
        void Hash(void const * data, long length);
 
        static int Digest_Size(void) {return(sizeof(SHADigest));}
 
    private:
 
        typedef union {
            unsigned long Long[5];
            unsigned char Char[20];
        } SHADigest;
 
        /*
        **  This holds the calculated final result. It is cached
        **  here to avoid the overhead of recalculating it over
        **  multiple sequential requests.
        */
        bool IsCached;
        SHADigest FinalResult;
 
        enum {
            // These are the initial seeds to the block accumulators.
            SA=0x67452301L,
            SB=0xefcdab89L,
            SC=0x98badcfeL,
            SD=0x10325476L,
            SE=0xc3d2e1f0L,
 
            // These are the constants used in the block transformation.
            K1=0x5a827999L,     // t=0..19      2^(1/2)/4
            K2=0x6ed9eba1L,     // t=20..39     3^(1/2)/4
            K3=0x8f1bbcdcL,     // t=40..59     5^(1/2)/4
            K4=0xca62c1d6L,     // t=60..79     10^(1/2)/4
 
            // Source data is grouped into blocks of this size.
            SRC_BLOCK_SIZE=16*sizeof(long),
 
            // Internal processing data is grouped into blocks this size.
            PROC_BLOCK_SIZE=80*sizeof(long)
        };
 
        long Get_Constant(int index) const {
            if (index < 20) return K1;
            if (index < 40) return K2;
            if (index < 60) return K3;
            return K4;
        };
 
        // Used for 0..19
        long Function1(long X, long Y, long Z) const {
            return(Z ^ ( X & ( Y ^ Z ) ) );
        };
 
        // Used for 20..39
        long Function2(long X, long Y, long Z) const {
            return( X ^ Y ^ Z );
        };
 
        // Used for 40..59
        long Function3(long X, long Y, long Z) const {
            return( (X & Y) | (Z & (X | Y) ) );
        };
 
        // Used for 60..79
        long Function4(long X, long Y, long Z) const {
            return( X ^ Y ^ Z );
        };
 
        long Do_Function(int index, long X, long Y, long Z) const {
            if (index < 20) return Function1(X, Y, Z);
            if (index < 40) return Function2(X, Y, Z);
            if (index < 60) return Function3(X, Y, Z);
            return Function4(X, Y, Z);
        };
 
        // Process a full source data block.
        void Process_Block(void const * source, SHADigest & acc) const;
 
        // Processes a partially filled source accumulator buffer.
        void Process_Partial(void const * & data, long & length);
 
        /*
        **  This is the running accumulator values. These values
        **  are updated by a block processing step that occurs
        **  every 512 bits of source data.
        */
        SHADigest Acc;
 
        /*
        **  This is the running length of the source data
        **  processed so far. This total is used to modify the
        **  resulting hash value as if it were appended to the end
        **  of the source data.
        */
        long Length;
 
        /*
        **  This holds any partial source block. Partial source blocks are
        **  a consequence of submitting less than block sized data chunks
        **  to the SHA Engine.
        */
        int PartialCount;
        char Partial[SRC_BLOCK_SIZE];
};
 
 
#define SHA_SOURCE1     "abc"
#define SHA_DIGEST1a    "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D"
#define SHA_DIGEST1b    "\x01\x64\xB8\xA9\x14\xCD\x2A\x5E\x74\xC4\xF7\xFF\x08\x2C\x4D\x97\xF1\xED\xF8\x80"
 
 
#define SHA_SOURCE2     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
#define SHA_DIGEST2a    "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1"
#define SHA_DIGEST2b    "\xD2\x51\x6E\xE1\xAC\xFA\x5B\xAF\x33\xDF\xC1\xC4\x71\xE4\x38\x44\x9E\xF1\x34\xC8"
 
#define SHA_SOURCE3     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
#define SHA_DIGEST3a    "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F"
#define SHA_DIGEST3b    "\x32\x32\xAF\xFA\x48\x62\x8A\x26\x65\x3B\x5A\xAA\x44\x54\x1F\xD9\x0D\x69\x06\x03"
 
#endif