websocketpp::sha1 Namespace Reference

Functions
void	calc (void const *src, size_t bytelength, unsigned char *hash)
	Calculate a SHA1 hash.

Function Documentation

calc()

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

inline

Parameters

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

Definition at line 127 of file sha1.hpp.

                                                                            {
    // 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.
    unsigned char const * sarray = (unsigned char const *) src;
 
    // The reusable round buffer
    unsigned int w[80];
 
    // Loop through all complete 64byte blocks.
 
    size_t endCurrentBlock;
    size_t currentBlock = 0;
 
    if (bytelength >= 64) {
        size_t const endOfFullBlocks = bytelength - 64;
 
        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);
    size_t 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;
    }
}

Here is the caller graph for this function: