sha2.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/>.
*/
#pragma once
 
#include "crypto/hash/hash.hpp"
 
namespace anch::crypto {

  template<std::size_t O, std::size_t B, typename W, uint32_t R, const std::array<W,8>& I>
  class SHA2: public Hash<O,B> {
 
  protected:
    typedef union {
      uint8_t bytes[B * sizeof(W)];

      W words[B];
    } Chunk;

    template<const std::array<W,8>& Init>
    struct Context {
      std::array<W,8> state;

      uint64_t size;

      uint8_t buffer[B];

      std::array<uint8_t,O> digest;

      Context();

      void reset();
 
    };
 
    // Attributes +
  protected:
    Context<I> _context;
    // Attributes -
 
 
    // Constructors +
  public:
    SHA2();
    // Constructors -
 
  public:
    // Destructor +
    virtual ~SHA2();
    // Destructor -
 
 
    // Methods +
  public:
    virtual const std::array<uint8_t,O>& digest() const override;
 
  protected:
    static constexpr inline W shiftRight(uint8_t bits, W word) {
      return (word >> bits);
    }

    static constexpr inline W rotateLeft(uint8_t bits, W word) {
      return ((word << bits) | (word >> (sizeof(W) * 8 - bits)));
    }

    static constexpr inline W rotateRight(uint8_t bits, W word) {
      return ((word >> bits) | (word << (sizeof(W) * 8 - bits)));
    }
 
  private:
    virtual void reset() override;

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

    virtual void finalize() override;

    virtual const std::array<W,R>& getTranslationArray() const = 0;

    void transform(const uint8_t* buffer);

    static void bytesSwap(W* buf, uint8_t count);

    static W ch(W x, W y, W z);

    static W maj(W x, W y, W z);

    virtual W SIGMA0(W word) const = 0;

    virtual W SIGMA1(W word) const = 0;

    virtual W sigma0(W word) const = 0;

    virtual W sigma1(W word) const = 0;
    // Methods -
 
  };
 
}
 
#include "crypto/hash/impl/sha2.hpp"