sha1.c File Reference

#include <string.h>
#include "crypto.h"

Go to the source code of this file.

Defines
#define	SHA1CircularShift(bits, word)   (((word) << (bits)) | ((word) >> (32-(bits))))
	SHA1 implementation - as defined in FIPS PUB 180-1 published April 17, 1995.
Functions
static void	SHA1PadMessage (SHA1_CTX *ctx)
static void	SHA1ProcessMessageBlock (SHA1_CTX *ctx)
	Process the next 512 bits of the message stored in the array.
void	SHA1Init (SHA1_CTX *ctx)
	Initialize the SHA1 context.
void	SHA1Update (SHA1_CTX *ctx, const uint8_t *msg, int len)
	Accepts an array of octets as the next portion of the message.
void	SHA1Final (SHA1_CTX *ctx, uint8_t *digest)
	Return the 160-bit message digest into the user's array.

---

Define Documentation

#define SHA1CircularShift	(	bits,
		word		)	(((word) << (bits)) | ((word) >> (32-(bits))))

SHA1 implementation - as defined in FIPS PUB 180-1 published April 17, 1995.

This code was originally taken from RFC3174

Definition at line 30 of file sha1.c.

Referenced by SHA1ProcessMessageBlock().

---

Function Documentation

static void SHA1PadMessage

(

SHA1_CTX *

ctx

)

[static]

Definition at line 195 of file sha1.c.

References SHA1_CTX::Length_High, SHA1_CTX::Length_Low, SHA1_CTX::Message_Block, SHA1_CTX::Message_Block_Index, and SHA1ProcessMessageBlock().

Referenced by SHA1Final().

{
    /*
     *  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 (ctx->Message_Block_Index > 55)
    {
        ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
        while(ctx->Message_Block_Index < 64)
        {
            ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        }

        SHA1ProcessMessageBlock(ctx);

        while (ctx->Message_Block_Index < 56)
        {
            ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        }
    }
    else
    {
        ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
        while(ctx->Message_Block_Index < 56)
        {

            ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        }
    }

    /*
     *  Store the message length as the last 8 octets
     */
    ctx->Message_Block[56] = ctx->Length_High >> 24;
    ctx->Message_Block[57] = ctx->Length_High >> 16;
    ctx->Message_Block[58] = ctx->Length_High >> 8;
    ctx->Message_Block[59] = ctx->Length_High;
    ctx->Message_Block[60] = ctx->Length_Low >> 24;
    ctx->Message_Block[61] = ctx->Length_Low >> 16;
    ctx->Message_Block[62] = ctx->Length_Low >> 8;
    ctx->Message_Block[63] = ctx->Length_Low;
    SHA1ProcessMessageBlock(ctx);
}

static void SHA1ProcessMessageBlock

(

SHA1_CTX *

ctx

)

[static]

Process the next 512 bits of the message stored in the array.

Definition at line 97 of file sha1.c.

References SHA1_CTX::Intermediate_Hash, SHA1_CTX::Message_Block, SHA1_CTX::Message_Block_Index, and SHA1CircularShift.

Referenced by SHA1PadMessage(), and SHA1Update().

{
    const uint32_t K[] =    {       /* Constants defined in SHA-1   */
                            0x5A827999,
                            0x6ED9EBA1,
                            0x8F1BBCDC,
                            0xCA62C1D6
                            };
    int        t;                 /* Loop counter                */
    uint32_t      temp;              /* Temporary word value        */
    uint32_t      W[80];             /* Word sequence               */
    uint32_t      A, B, C, D, E;     /* Word buffers                */

    /*
     *  Initialize the first 16 words in the array W
     */
    for  (t = 0; t < 16; t++)
    {
        W[t] = ctx->Message_Block[t * 4] << 24;
        W[t] |= ctx->Message_Block[t * 4 + 1] << 16;
        W[t] |= ctx->Message_Block[t * 4 + 2] << 8;
        W[t] |= ctx->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 = ctx->Intermediate_Hash[0];
    B = ctx->Intermediate_Hash[1];
    C = ctx->Intermediate_Hash[2];
    D = ctx->Intermediate_Hash[3];
    E = ctx->Intermediate_Hash[4];

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

    ctx->Intermediate_Hash[0] += A;
    ctx->Intermediate_Hash[1] += B;
    ctx->Intermediate_Hash[2] += C;
    ctx->Intermediate_Hash[3] += D;
    ctx->Intermediate_Hash[4] += E;
    ctx->Message_Block_Index = 0;
}

void SHA1Init

(

SHA1_CTX *

ctx

)

Initialize the SHA1 context.

Definition at line 40 of file sha1.c.

References SHA1_CTX::Intermediate_Hash, SHA1_CTX::Length_High, SHA1_CTX::Length_Low, and SHA1_CTX::Message_Block_Index.

Referenced by sha1_init().

{
    ctx->Length_Low             = 0;
    ctx->Length_High            = 0;
    ctx->Message_Block_Index    = 0;
    ctx->Intermediate_Hash[0]   = 0x67452301;
    ctx->Intermediate_Hash[1]   = 0xEFCDAB89;
    ctx->Intermediate_Hash[2]   = 0x98BADCFE;
    ctx->Intermediate_Hash[3]   = 0x10325476;
    ctx->Intermediate_Hash[4]   = 0xC3D2E1F0;
}

void SHA1Update	(	SHA1_CTX *	ctx,
		const uint8_t *	msg,
		int	len
	)

Accepts an array of octets as the next portion of the message.

Definition at line 55 of file sha1.c.

References SHA1_CTX::Length_High, SHA1_CTX::Length_Low, SHA1_CTX::Message_Block, SHA1_CTX::Message_Block_Index, and SHA1ProcessMessageBlock().

Referenced by sha1_update().

{
    while (len--)
    {
        ctx->Message_Block[ctx->Message_Block_Index++] = (*msg & 0xFF);

        ctx->Length_Low += 8;
        if (ctx->Length_Low == 0)
        {
            ctx->Length_High++;
        }

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

        msg++;
    }
}

void SHA1Final	(	SHA1_CTX *	ctx,
		uint8_t *	digest
	)

Return the 160-bit message digest into the user's array.

Definition at line 79 of file sha1.c.

References SHA1_CTX::Intermediate_Hash, SHA1_CTX::Length_High, SHA1_CTX::Length_Low, memset(), SHA1_CTX::Message_Block, SHA1_SIZE, and SHA1PadMessage().

Referenced by sha1_final().

{
    int i;

    SHA1PadMessage(ctx);
    memset(ctx->Message_Block, 0, 64);
    ctx->Length_Low = 0;    /* and clear length */
    ctx->Length_High = 0;

    for  (i = 0; i < SHA1_SIZE; i++)
    {
        digest[i] = ctx->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) );
    }
}