fhicl::SHA1 Class Reference

#include <sha1.h>

Public Member Functions
	SHA1 ()
void	Reset ()
bool	Result (unsigned *message_digest_array)
void	Input (const unsigned char *message_array, unsigned length)
void	Input (const char *message_array, unsigned length)
void	Input (unsigned char message_element)
void	Input (char message_element)
SHA1 &	operator<< (const char *message_array)
SHA1 &	operator<< (const unsigned char *message_array)
SHA1 &	operator<< (const char message_element)
SHA1 &	operator<< (const unsigned char message_element)

Private Member Functions
void	ProcessMessageBlock ()
void	PadMessage ()
unsigned	CircularShift (int bits, unsigned word)

Private Attributes
unsigned	H [5]
unsigned	Length_Low
unsigned	Length_High
unsigned char	Message_Block [64]
int	Message_Block_Index
bool	Computed
bool	Corrupted

Detailed Description

Definition at line 29 of file sha1.h.

Constructor & Destructor Documentation

fhicl::SHA1::SHA1

(

)

Definition at line 59 of file sha1.cpp.

{ Reset(); }

Member Function Documentation

unsigned fhicl::SHA1::CircularShift ( int  bits, unsigned  word  )

inlineprivate

Definition at line 549 of file sha1.cpp.

  {
    return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32 - bits));
  }

void fhicl::SHA1::Input	(	const unsigned char *	message_array,
		unsigned	length
	)

Definition at line 152 of file sha1.cpp.

  {
    if (!length) {
      return;
    }

    if (Computed || Corrupted) {
      Corrupted = true;
      return;
    }

    while (length-- && !Corrupted) {
      Message_Block[Message_Block_Index++] = (*message_array & 0xFF);

      Length_Low += 8;
      Length_Low &= 0xFFFFFFFF; // Force it to 32 bits
      if (Length_Low == 0) {
        Length_High++;
        Length_High &= 0xFFFFFFFF; // Force it to 32 bits
        if (Length_High == 0) {
          Corrupted = true; // Message is too long
        }
      }

      if (Message_Block_Index == 64) {
        ProcessMessageBlock();
      }

      message_array++;
    }
  }

void fhicl::SHA1::Input	(	const char *	message_array,
		unsigned	length
	)

Definition at line 205 of file sha1.cpp.

  {
    Input((unsigned char*)message_array, length);
  }

void fhicl::SHA1::Input

(

unsigned char

message_element

)

Definition at line 227 of file sha1.cpp.

  {
    Input(&message_element, 1);
  }

void fhicl::SHA1::Input

(

char

message_element

)

Definition at line 249 of file sha1.cpp.

  {
    Input((unsigned char*)&message_element, 1);
  }

SHA1 & fhicl::SHA1::operator<<

(

const char *

message_array

)

Definition at line 273 of file sha1.cpp.

  {
    const char* p = message_array;

    while (*p) {
      Input(*p);
      p++;
    }

    return *this;
  }

SHA1 & fhicl::SHA1::operator<<

(

const unsigned char *

message_array

)

Definition at line 304 of file sha1.cpp.

  {
    const unsigned char* p = message_array;

    while (*p) {
      Input(*p);
      p++;
    }

    return *this;
  }

SHA1 & fhicl::SHA1::operator<<

(

const char

message_element

)

Definition at line 334 of file sha1.cpp.

  {
    Input((unsigned char*)&message_element, 1);

    return *this;
  }

SHA1 & fhicl::SHA1::operator<<

(

const unsigned char

message_element

)

Definition at line 359 of file sha1.cpp.

  {
    Input(&message_element, 1);

    return *this;
  }

void fhicl::SHA1::PadMessage ( )

private

Definition at line 490 of file sha1.cpp.

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

      ProcessMessageBlock();

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

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

    ProcessMessageBlock();
  }

void fhicl::SHA1::ProcessMessageBlock ( )

private

Definition at line 386 of file sha1.cpp.

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

    /*
     *  Initialize the first 16 words in the array W
     */
    for (t = 0; t < 16; t++) {
      W[t] = ((unsigned)Message_Block[t * 4]) << 24;
      W[t] |= ((unsigned)Message_Block[t * 4 + 1]) << 16;
      W[t] |= ((unsigned)Message_Block[t * 4 + 2]) << 8;
      W[t] |= ((unsigned)Message_Block[t * 4 + 3]);
    }

    for (t = 16; t < 80; t++) {
      W[t] = CircularShift(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
    }

    A = H[0];
    B = H[1];
    C = H[2];
    D = H[3];
    E = H[4];

    for (t = 0; t < 20; t++) {
      temp = CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
      temp &= 0xFFFFFFFF;
      E = D;
      D = C;
      C = CircularShift(30, B);
      B = A;
      A = temp;
    }

    for (t = 20; t < 40; t++) {
      temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1];
      temp &= 0xFFFFFFFF;
      E = D;
      D = C;
      C = CircularShift(30, B);
      B = A;
      A = temp;
    }

    for (t = 40; t < 60; t++) {
      temp =
        CircularShift(5, A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
      temp &= 0xFFFFFFFF;
      E = D;
      D = C;
      C = CircularShift(30, B);
      B = A;
      A = temp;
    }

    for (t = 60; t < 80; t++) {
      temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3];
      temp &= 0xFFFFFFFF;
      E = D;
      D = C;
      C = CircularShift(30, B);
      B = A;
      A = temp;
    }

    H[0] = (H[0] + A) & 0xFFFFFFFF;
    H[1] = (H[1] + B) & 0xFFFFFFFF;
    H[2] = (H[2] + C) & 0xFFFFFFFF;
    H[3] = (H[3] + D) & 0xFFFFFFFF;
    H[4] = (H[4] + E) & 0xFFFFFFFF;

    Message_Block_Index = 0;
  }

void fhicl::SHA1::Reset

(

)

Definition at line 78 of file sha1.cpp.

  {
    Length_Low = 0;
    Length_High = 0;
    Message_Block_Index = 0;

    H[0] = 0x67452301;
    H[1] = 0xEFCDAB89;
    H[2] = 0x98BADCFE;
    H[3] = 0x10325476;
    H[4] = 0xC3D2E1F0;

    Computed = false;
    Corrupted = false;
  }

bool fhicl::SHA1::Result

(

unsigned *

message_digest_array

)

Definition at line 113 of file sha1.cpp.

  {
    int i; // Counter

    if (Corrupted) {
      return false;
    }

    if (!Computed) {
      PadMessage();
      Computed = true;
    }

    for (i = 0; i < 5; i++) {
      message_digest_array[i] = H[i];
    }

    return true;
  }

Member Data Documentation

bool fhicl::SHA1::Computed

private

Definition at line 80 of file sha1.h.

bool fhicl::SHA1::Corrupted

private

Definition at line 81 of file sha1.h.

unsigned fhicl::SHA1::H[5]

private

Definition at line 72 of file sha1.h.

unsigned fhicl::SHA1::Length_High

private

Definition at line 75 of file sha1.h.

unsigned fhicl::SHA1::Length_Low

private

Definition at line 74 of file sha1.h.

unsigned char fhicl::SHA1::Message_Block[64]

private

Definition at line 77 of file sha1.h.

int fhicl::SHA1::Message_Block_Index

private

Definition at line 78 of file sha1.h.

---

The documentation for this class was generated from the following files:

• cetlib/cetlib/test/sha1.h
• cetlib/cetlib/test/sha1.cpp