/*

 * SHA1 Wikipedia Page: http://en.wikipedia.org/wiki/SHA-1

 *

 * Copyright (c) 2012-22 SAURAV MOHAPATRA <mohaps@gmail.com>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

/**

 * \file TinySHA1.hpp

 * \author SAURAV MOHAPATRA <mohaps@gmail.com>

 * \date 2012-22

 * \brief TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based

 * on the implementation in boost::uuid::details.

 *

 * In this file are defined:

 * - sha1::SHA1

 */

#ifndef _TINY_SHA1_HPP_

#define _TINY_SHA1_HPP_

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <stdint.h>

/**

 * \namespace sha1

 * \brief Here is defined the SHA1 class

 */

namespace sha1

{

    /**

     * \class SHA1

     * \brief A tiny SHA1 algorithm implementation used internally in the

     * Crow server (specifically in crow/websocket.h).

     */

    class SHA1

    {

    public:

        typedef uint32_t digest32_t[5];

        typedef uint8_t digest8_t[20];

        inline static uint32_t LeftRotate(uint32_t value, size_t count) {

            return (value << count) ^ (value >> (32-count));

        }

        SHA1(){ reset(); }

        virtual ~SHA1() {}

        SHA1(const SHA1& s) { *this = s; }

        const SHA1& operator = (const SHA1& s) {

            memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t));

            memcpy(m_block, s.m_block, 64);

            m_blockByteIndex = s.m_blockByteIndex;

            m_byteCount = s.m_byteCount;

            return *this;

        }

        SHA1& reset() {

            m_digest[0] = 0x67452301;

            m_digest[1] = 0xEFCDAB89;

            m_digest[2] = 0x98BADCFE;

            m_digest[3] = 0x10325476;

            m_digest[4] = 0xC3D2E1F0;

            m_blockByteIndex = 0;

            m_byteCount = 0;

            return *this;

        }

        SHA1& processByte(uint8_t octet) {

            this->m_block[this->m_blockByteIndex++] = octet;

            ++this->m_byteCount;

            if(m_blockByteIndex == 64) {

                this->m_blockByteIndex = 0;

                processBlock();

            }

            return *this;

        }

        SHA1& processBlock(const void* const start, const void* const end) {

            const uint8_t* begin = static_cast<const uint8_t*>(start);

            const uint8_t* finish = static_cast<const uint8_t*>(end);

            while(begin != finish) {

                processByte(*begin);

                begin++;

            }

            return *this;

        }

        SHA1& processBytes(const void* const data, size_t len) {

            const uint8_t* block = static_cast<const uint8_t*>(data);

            processBlock(block, block + len);

            return *this;

        }

        const uint32_t* getDigest(digest32_t digest) {

            size_t bitCount = this->m_byteCount * 8;

            processByte(0x80);

            if (this->m_blockByteIndex > 56) {

                while (m_blockByteIndex != 0) {

                    processByte(0);

                }

                while (m_blockByteIndex < 56) {

                    processByte(0);

                }

            } else {

                while (m_blockByteIndex < 56) {

                    processByte(0);

                }

            }

            processByte(0);

            processByte(0);

            processByte(0);

            processByte(0);

            processByte( static_cast<unsigned char>((bitCount>>24) & 0xFF));

            processByte( static_cast<unsigned char>((bitCount>>16) & 0xFF));

            processByte( static_cast<unsigned char>((bitCount>>8 ) & 0xFF));

            processByte( static_cast<unsigned char>((bitCount)     & 0xFF));

            memcpy(digest, m_digest, 5 * sizeof(uint32_t));

            return digest;

        }

        const uint8_t* getDigestBytes(digest8_t digest) {

            digest32_t d32;

            getDigest(d32);

            size_t di = 0;

            digest[di++] = ((d32[0] >> 24) & 0xFF);

            digest[di++] = ((d32[0] >> 16) & 0xFF);

            digest[di++] = ((d32[0] >> 8) & 0xFF);

            digest[di++] = ((d32[0]) & 0xFF);

            digest[di++] = ((d32[1] >> 24) & 0xFF);

            digest[di++] = ((d32[1] >> 16) & 0xFF);

            digest[di++] = ((d32[1] >> 8) & 0xFF);

            digest[di++] = ((d32[1]) & 0xFF);

            digest[di++] = ((d32[2] >> 24) & 0xFF);

            digest[di++] = ((d32[2] >> 16) & 0xFF);

            digest[di++] = ((d32[2] >> 8) & 0xFF);

            digest[di++] = ((d32[2]) & 0xFF);

            digest[di++] = ((d32[3] >> 24) & 0xFF);

            digest[di++] = ((d32[3] >> 16) & 0xFF);

            digest[di++] = ((d32[3] >> 8) & 0xFF);

            digest[di++] = ((d32[3]) & 0xFF);

            digest[di++] = ((d32[4] >> 24) & 0xFF);

            digest[di++] = ((d32[4] >> 16) & 0xFF);

            digest[di++] = ((d32[4] >> 8) & 0xFF);

            digest[di++] = ((d32[4]) & 0xFF);

            return digest;

        }

    protected:

        void processBlock() {

            uint32_t w[80];

            for (size_t i = 0; i < 16; i++) {

                w[i]  = (m_block[i*4 + 0] << 24);

                w[i] |= (m_block[i*4 + 1] << 16);

                w[i] |= (m_block[i*4 + 2] << 8);

                w[i] |= (m_block[i*4 + 3]);

            }

            for (size_t i = 16; i < 80; i++) {

                w[i] = LeftRotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);

            }

            uint32_t a = m_digest[0];

            uint32_t b = m_digest[1];

            uint32_t c = m_digest[2];

            uint32_t d = m_digest[3];

            uint32_t e = m_digest[4];

            for (std::size_t i=0; i<80; ++i) {

                uint32_t f = 0;

                uint32_t k = 0;

                if (i<20) {

                    f = (b & c) | (~b & d);

                    k = 0x5A827999;

                } else if (i<40) {

                    f = b ^ c ^ d;

                    k = 0x6ED9EBA1;

                } else if (i<60) {

                    f = (b & c) | (b & d) | (c & d);

                    k = 0x8F1BBCDC;

                } else {

                    f = b ^ c ^ d;

                    k = 0xCA62C1D6;

                }

                uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i];

                e = d;

                d = c;

                c = LeftRotate(b, 30);

                b = a;

                a = temp;

            }

            m_digest[0] += a;

            m_digest[1] += b;

            m_digest[2] += c;

            m_digest[3] += d;

            m_digest[4] += e;

        }

    private:

        digest32_t m_digest;

        uint8_t m_block[64];

        size_t m_blockByteIndex;

        size_t m_byteCount;

    };

}

#endif