sha1.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal

  This file is part of ANCH Framework.

  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  ANCH Framework is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANCH_CRYPTO_SHA1_H_
#define _ANCH_CRYPTO_SHA1_H_

#include "crypto/hash/hash.hpp"


namespace anch {
  namespace crypto {

    template<typename H> H HMAC(const std::string&, const std::string&);

    class SHA1: public Hash<20,64> {

      friend SHA1 anch::crypto::HMAC<SHA1>(const std::string&, const std::string&);

    private:
      typedef union {
        uint8_t bytes[64];

        uint32_t words[16];
      } Chunk;

      struct Context {
        std::array<uint32_t,5> state;

        uint64_t size;

        std::array<uint8_t,64> buffer;

        std::array<uint8_t,20> digest;

        Context() {
          reset();
        }

        void reset() {
          state = { {0x67452301,0xEFCDAB89,0x98BADCFE,0x10325476,0xC3D2E1F0} };
          size = 0;
        }
      };

      // Attributes +
    private:
      Context _context;
      // Attributes -


      // Constructors +
    public:
      SHA1();

      template<class CharT, class Traits, class Allocator>
      SHA1(const std::basic_string<CharT,Traits,Allocator>& data) {
        Hash::digest(data);
      }

      template<class CharT, class Traits>
      SHA1(std::basic_istream<CharT,Traits>& stream) {
        Hash::digest(stream);
      }

    private:
      SHA1(const uint8_t* data, std::size_t len) {
        Hash::digest(data, len);
      }
      // Constructors -


      // Destructor +
    public:
      virtual ~SHA1();
      // Destructor -


      // Methods +
    public:
      virtual const std::array<uint8_t,20>& digest() const override;

    protected:
      virtual void reset() override {
        _context.reset();
      }

      virtual void addData(const uint8_t* data, std::size_t len) override;

      virtual void finalize() override;

    private:
      void transform(const uint8_t* buffer);

      static inline uint32_t rol32(uint32_t value, unsigned int shift){
        return ((value << shift) | value >> (32 - shift));
      }

      static inline uint32_t word(Chunk& chunk, unsigned int position) {
        return (chunk.words[position & 0xf] = rol32(chunk.words[(position + 13)  & 0xf]
                                                    ^ chunk.words[(position + 8) & 0xf]
                                                    ^ chunk.words[(position + 2) & 0xf]
                                                    ^ chunk.words[(position)     & 0xf],
                                                    1));
      }

      static inline void round0(Chunk& chunk,
                                const unsigned int position,
                                uint32_t& v,
                                uint32_t& w,
                                uint32_t& x,
                                uint32_t& y,
                                uint32_t& z){
        z += ((( w & (x ^ y)) ^ y) + chunk.words[position] + 0x5A827999 + rol32(v, 5));
        w = rol32(w, 30);
      }

      static inline void round1(Chunk& chunk,
                                const unsigned int position,
                                uint32_t& v,
                                uint32_t& w,
                                uint32_t& x,
                                uint32_t& y,
                                uint32_t& z){
        z += ((( w & (x ^ y)) ^ y) + word(chunk,position) + 0x5A827999 + rol32(v, 5));
        w = rol32(w, 30);
      }

      static inline void round2(Chunk& chunk,
                                const unsigned int position,
                                uint32_t& v,
                                uint32_t& w,
                                uint32_t& x,
                                uint32_t& y,
                                uint32_t& z){
        z += (( w ^ x ^ y) + word(chunk, position) + 0x6ED9EBA1 + rol32(v, 5));
        w = rol32(w, 30);
      }

      static inline void round3(Chunk& chunk,
                                const unsigned int position,
                                uint32_t& v,
                                uint32_t& w,
                                uint32_t& x,
                                uint32_t& y,
                                uint32_t& z){
        z += (((( w | x) & y) | (w & x)) + word(chunk, position) + 0x8F1BBCDC + rol32(v, 5));
        w = rol32(w, 30);
      }

      static inline void round4(Chunk& chunk,
                                const unsigned int position,
                                uint32_t& v,
                                uint32_t& w,
                                uint32_t& x,
                                uint32_t& y,
                                uint32_t& z){
        z += ((w ^ x ^ y) + word(chunk, position) + 0xCA62C1D6 + rol32(v, 5));
        w = rol32(w, 30);
      }
      // Methods -

    };

    extern template SHA1 HMAC<SHA1>(const std::string&, const std::string&);

  }
}

#endif // _ANCH_CRYPTO_SHA1_H_