sha256.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TOOLS_HASH_SHA256_H_
#define GENESIS_UTILS_TOOLS_HASH_SHA256_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2019 Lucas Czech and HITS gGmbH
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/
 
#include "genesis/utils/io/input_source.hpp"
 
#include <array>
#include <cstdint>
#include <iosfwd>
#include <string>
 
namespace genesis {
namespace utils {
 
// ================================================================================================
//     SHA256
// ================================================================================================
 
class SHA256
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Constants
    // -------------------------------------------------------------------------
 
    static const size_t BlockSize = ( 512 / 8 );
    static const size_t DigestSize = ( 256 / 8);
 
    using DigestType = std::array< uint32_t, 8 >;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    SHA256();
    ~SHA256() = default;
 
    SHA256( SHA256 const& ) = default;
    SHA256( SHA256&& )      = default;
 
    SHA256& operator= ( SHA256 const& ) = default;
    SHA256& operator= ( SHA256&& )      = default;
 
    // -------------------------------------------------------------------------
    //     Full Hashing
    // -------------------------------------------------------------------------
 
    static std::string read_hex( std::shared_ptr<BaseInputSource> source );
 
    static DigestType  read_digest( std::shared_ptr<BaseInputSource> source );
 
    static std::string digest_to_hex( DigestType const& digest );
    static DigestType hex_to_digest( std::string const& hex );
 
    // -------------------------------------------------------------------------
    //     Iterative Hashing
    // -------------------------------------------------------------------------
 
    void clear();
 
    void update( std::shared_ptr<BaseInputSource> source );
    void update( std::string const& s );
    void update( std::istream& is );
    void update( char const* input, size_t length );
 
    std::string final_hex();
 
    DigestType  final_digest();
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    void reset_();
 
    // SHA256 block update operation. Continues an SHA256 message-digest
    // operation, processing another message block
    void update_( unsigned char const* message, size_t len );
 
    void transform_( unsigned char const* message, unsigned int block_nb );
 
    static inline uint32_t SHA2_SHFR( uint32_t x, uint32_t n )
    {
        return x >> n;
    }
 
    static inline uint32_t SHA2_ROTR( uint32_t x, uint32_t n )
    {
        return ((x >> n) | (x << ((sizeof(x) << 3) - n)));
    }
 
    static inline uint32_t SHA2_ROTL( uint32_t x, uint32_t n )
    {
        return ((x << n) | (x >> ((sizeof(x) << 3) - n)));
    }
 
    static inline uint32_t SHA2_CH( uint32_t x, uint32_t y, uint32_t z )
    {
        return ((x & y) ^ (~x & z));
    }
 
    static inline uint32_t SHA2_MAJ( uint32_t x, uint32_t y, uint32_t z )
    {
        return ((x & y) ^ (x & z) ^ (y & z));
    }
 
    static inline uint32_t SHA256_F1( uint32_t x )
    {
        return (SHA2_ROTR(x,  2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22));
    }
 
    static inline uint32_t SHA256_F2( uint32_t x )
    {
        return (SHA2_ROTR(x,  6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25));
    }
 
    static inline uint32_t SHA256_F3( uint32_t x )
    {
        return (SHA2_ROTR(x,  7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x,  3));
    }
 
    static inline uint32_t SHA256_F4( uint32_t x )
    {
        return (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10));
    }
 
    static inline uint32_t SHA2_PACK32( unsigned char const* str )
    {
        return   ((uint32_t) *((str) + 3)      )
               | ((uint32_t) *((str) + 2) <<  8)
               | ((uint32_t) *((str) + 1) << 16)
               | ((uint32_t) *((str) + 0) << 24)
        ;
    }
 
    static inline void SHA2_UNPACK32( uint32_t x, unsigned char* str)
    {
        *((str) + 3) = (uint8_t) ((x)      );
        *((str) + 2) = (uint8_t) ((x) >>  8);
        *((str) + 1) = (uint8_t) ((x) >> 16);
        *((str) + 0) = (uint8_t) ((x) >> 24);
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    const static uint32_t sha256_k[];
 
    unsigned int  tot_len_;
    unsigned int  len_;
    unsigned char block_[ 2 * BlockSize ];
 
    DigestType digest_;
 
};
 
} // namespace utils
} // namespace genesis
 
// ================================================================================================
//     Standard Hash Function
// ================================================================================================
 
namespace std
{
    template<>
    struct hash<genesis::utils::SHA256::DigestType>
    {
        using argument_type = genesis::utils::SHA256::DigestType;
        using result_type   = std::size_t;
 
        result_type operator()( argument_type const& s ) const {
            result_type result = 0;
            result ^= s[0] ^ ( static_cast<result_type>( s[1] ) << 32 );
            result ^= s[2] ^ ( static_cast<result_type>( s[3] ) << 32 );
            result ^= s[4] ^ ( static_cast<result_type>( s[5] ) << 32 );
            result ^= s[6] ^ ( static_cast<result_type>( s[7] ) << 32 );
            return result;
        }
    };
}
 
#endif // include guard