sha1 Namespace Reference

Functions
void	calc (const void *src, const int bytelength, unsigned char *hash)
	Calculate the SHA1 hash of some data set. More...
void	toHexString (const unsigned char *hash, char *hexstring)
	Calculate a string which represents the SHA1 hash as a hexadecimal number. More...

Function Documentation

calc()

void sha1::calc	(	const void *	src,
		const int	bytelength,
		unsigned char *	hash
	)

Calculate the SHA1 hash of some data set.

Parameters

src	Points to any kind of data to be hashed.
bytelength	The number of bytes to hash from the src pointer.
hash	Points to a buffer of at least 20 bytes of size for storing the sha1 result in.

Definition at line 150 of file sha1.cpp.

{
    // Init the result array.
    unsigned int result[5] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476,
                              0xc3d2e1f0};
 
    // Cast the void src pointer to be the byte array we can work with.
    const unsigned char *sarray = (const unsigned char *)src;
 
    // The reusable round buffer
    unsigned int w[80];
 
    // Loop through all complete 64byte blocks.
    const int endOfFullBlocks = bytelength - 64;
    int endCurrentBlock;
    int currentBlock = 0;
 
    while (currentBlock <= endOfFullBlocks)
    {
        endCurrentBlock = currentBlock + 64;
 
        // Init the round buffer with the 64 byte block data.
        for (int roundPos = 0; currentBlock < endCurrentBlock;
             currentBlock += 4)
        {
            // This line will swap endian on big endian and keep endian on
            // little endian.
            w[roundPos++] = (unsigned int)sarray[currentBlock + 3] |
                            (((unsigned int)sarray[currentBlock + 2]) << 8) |
                            (((unsigned int)sarray[currentBlock + 1]) << 16) |
                            (((unsigned int)sarray[currentBlock]) << 24);
        }
        innerHash(result, w);
    }
 
    // Handle the last and not full 64 byte block if existing.
    endCurrentBlock = bytelength - currentBlock;
    clearWBuffert(w);
    int lastBlockBytes = 0;
    for (; lastBlockBytes < endCurrentBlock; ++lastBlockBytes)
    {
        w[lastBlockBytes >> 2] |=
            (unsigned int)sarray[lastBlockBytes + currentBlock]
            << ((3 - (lastBlockBytes & 3)) << 3);
    }
    w[lastBlockBytes >> 2] |= 0x80 << ((3 - (lastBlockBytes & 3)) << 3);
    if (endCurrentBlock >= 56)
    {
        innerHash(result, w);
        clearWBuffert(w);
    }
    w[15] = bytelength << 3;
    innerHash(result, w);
 
    // Store hash in result pointer, and make sure we get in in the correct
    // order on both endian models.
    for (int hashByte = 20; --hashByte >= 0;)
    {
        hash[hashByte] =
            (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;
    }
}

References Nektar::UnitTests::w().

Referenced by Nektar::MetricFile::CalculateHash().

toHexString()

void sha1::toHexString	(	const unsigned char *	hash,
		char *	hexstring
	)

Calculate a string which represents the SHA1 hash as a hexadecimal number.

Parameters

hash	is 20 bytes of sha1 hash. This is the same data that is the result from the calc function.
hexstring	should point to a buffer of at least 41 bytes of size for storing the hexadecimal representation of the hash. A zero will be written at position 40, so the buffer will be a valid zero ended string.

Definition at line 213 of file sha1.cpp.

{
    const char hexDigits[] = {"0123456789abcdef"};
 
    for (int hashByte = 20; --hashByte >= 0;)
    {
        hexstring[hashByte << 1]       = hexDigits[(hash[hashByte] >> 4) & 0xf];
        hexstring[(hashByte << 1) + 1] = hexDigits[hash[hashByte] & 0xf];
    }
    hexstring[40] = 0;
}

Referenced by Nektar::MetricFile::CalculateHash().