sha1.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TOOLS_HASH_SHA1_H_
#define GENESIS_UTILS_TOOLS_HASH_SHA1_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 {
 
// ================================================================================================
//     SHA1
// ================================================================================================
 
class SHA1
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Constants
    // -------------------------------------------------------------------------
 
    // Number of 32bit integers per SHA1 block.
    static const size_t BlockInts  = 16;
    static const size_t BlockBytes = BlockInts * 4;
 
    using DigestType = std::array< uint32_t, 5 >;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    SHA1();
    ~SHA1() = default;
 
    SHA1( SHA1 const& ) = default;
    SHA1( SHA1&& )      = default;
 
    SHA1& operator= ( SHA1 const& ) = default;
    SHA1& operator= ( SHA1&& )      = 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 );
 
    std::string final_hex();
 
    DigestType  final_digest();
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    void reset_();
 
    uint32_t rol_(const uint32_t value, const size_t bits);
    uint32_t blk_(const uint32_t block[SHA1::BlockInts], const size_t i);
 
    void R0_(
        const uint32_t block[SHA1::BlockInts], const uint32_t v, uint32_t& w, const uint32_t x,
        const uint32_t y, uint32_t& z, const size_t i
    );
    void R1_(
        uint32_t block[SHA1::BlockInts], const uint32_t v, uint32_t& w, const uint32_t x,
        const uint32_t y, uint32_t& z, const size_t i
    );
    void R2_(
        uint32_t block[SHA1::BlockInts], const uint32_t v, uint32_t& w, const uint32_t x,
        const uint32_t y, uint32_t& z, const size_t i
    );
    void R3_(
        uint32_t block[SHA1::BlockInts], const uint32_t v, uint32_t& w, const uint32_t x,
        const uint32_t y, uint32_t& z, const size_t i
    );
    void R4_(
        uint32_t block[SHA1::BlockInts], const uint32_t v, uint32_t& w, const uint32_t x,
        const uint32_t y, uint32_t& z, const size_t i
    );
 
    void transform_( uint32_t block[SHA1::BlockInts] );
 
    void buffer_to_block_(const std::string& buffer, uint32_t block[SHA1::BlockInts]);
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    DigestType  digest_;
    std::string buffer_;
    size_t      transforms_;
 
};
 
} // namespace utils
} // namespace genesis
 
// ================================================================================================
//     Standard Hash Function
// ================================================================================================
 
namespace std
{
    template<>
    struct hash<genesis::utils::SHA1::DigestType>
    {
        using argument_type = genesis::utils::SHA1::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];
            return result;
        }
    };
}
 
#endif // include guard