sha1.cpp

Go to the documentation of this file.

/*
 * sha1.c
 *
 * Copyright (C) 1998, 2009
 * Paul E. Jones <paulej@packetizer.com>
 * All Rights Reserved
 *
 *****************************************************************************
 * $Id: sha1.c 12 2009-06-22 19:34:25Z paulej $
 *****************************************************************************
 *
 * Description:
 *     This file implements the Secure Hashing Standard as defined
 *     in FIPS PUB 180-1 published April 17, 1995.
 *
 *     The Secure Hashing Standard, which uses the Secure Hashing
 *     Algorithm (SHA), produces a 160-bit message digest for a
 *     given data stream.  In theory, it is highly improbable that
 *     two messages will produce the same message digest.  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 was
 *     written with the expectation that the processor has at least
 *     a 32-bit machine word size.  If the machine word size is larger,
 *     the code should still function properly.  One caveat to that
 *     is that the input functions taking characters and character
 *     arrays assume that only 8 bits of information are stored in each
 *     character.
 *
 * 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.
 *
 */
 
#include "sha1.h"
#include "filesys.h"
#include "../shared/shared.h"
 
/*
 * Define the circular shift macro
 */
#define SHA1CircularShift(bits,word) \
    ((((word) << (bits)) & 0xFFFFFFFF) | \
    ((word) >> (32-(bits))))
 
/* Function prototypes */
static void Com_SHA1ProcessMessageBlock (SHA1Context *);
static void Com_SHA1PadMessage (SHA1Context *);

void Com_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;
}

bool Com_SHA1Result (SHA1Context *context)
{
    if (context->Corrupted) {
        return false;
    }
 
    if (!context->Computed) {
        Com_SHA1PadMessage(context);
        context->Computed = 1;
    }
 
    return true;
}

void Com_SHA1Input (SHA1Context *context, const unsigned char* message_array, unsigned length)
{
    if (!length) {
        return;
    }
 
    if (context->Computed || context->Corrupted) {
        context->Corrupted = 1;
        return;
    }
 
    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) {
            Com_SHA1ProcessMessageBlock(context);
        }
 
        message_array++;
    }
}

static void Com_SHA1ProcessMessageBlock (SHA1Context *context)
{
    const unsigned K[] = /* Constants defined in SHA-1   */
    { 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
    unsigned W[80]; /* Word sequence*/
 
    /*
     * Initialize the first 16 words in the array W
     */
    for (int t = 0; t < 16; t++) {
        W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
        W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
        W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
        W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
    }
 
    for (int t = 16; t < 80; t++) {
        W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
    }
 
    unsigned A = context->Message_Digest[0];
    unsigned B = context->Message_Digest[1];
    unsigned C = context->Message_Digest[2];
    unsigned D = context->Message_Digest[3];
    unsigned E = context->Message_Digest[4];
 
    for (int t = 0; t < 20; t++) {
        unsigned 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 (int t = 20; t < 40; t++) {
        unsigned 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 (int t = 40; t < 60; t++) {
        unsigned 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 (int t = 60; t < 80; t++) {
        unsigned 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;
}

static void Com_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;
        }
 
        Com_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] = (context->Length_High >> 24) & 0xFF;
    context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
    context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
    context->Message_Block[59] = (context->Length_High) & 0xFF;
    context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
    context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
    context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
    context->Message_Block[63] = (context->Length_Low) & 0xFF;
 
    Com_SHA1ProcessMessageBlock(context);
}
 
bool Com_SHA1File (const char* filename, char digest[41])
{
    qFILE f;
    const int filelen = FS_OpenFile(filename, &f, FILE_READ);
    if (filelen < 1)
        return false;
 
    SHA1Context sha;
    Com_SHA1Reset(&sha);
 
    byte buf[1024];
    for (;;) {
        const int n = FS_Read(buf, sizeof(buf), &f);
        if (n < 1)
            break;
        Com_SHA1Input(&sha, buf, n);
    }
 
    if (!Com_SHA1Result(&sha)) {
        return false;
    }
    digest[0] = '\0';
    for (int i = 0; i < 5; i++) {
        Q_strcat(digest, 41, "%02x", sha.Message_Digest[i]);
    }
    return true;
}
 
bool Com_SHA1Buffer (const unsigned char* buf, unsigned int len, char digest[41])
{
    if (len < 1)
        return false;
 
    SHA1Context sha;
    Com_SHA1Reset(&sha);
    Com_SHA1Input(&sha, buf, len);
 
    if (!Com_SHA1Result(&sha)) {
        return false;
    }
    digest[0] = '\0';
    for (int i = 0; i < 5; i++) {
        Q_strcat(digest, 41, "%02x", sha.Message_Digest[i]);
    }
    return true;
}