md5.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_TOOLS_HASH_MD5_H_
#define GENESIS_UTILS_TOOLS_HASH_MD5_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2018 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 {
 
// ================================================================================================
//     MD5
// ================================================================================================
 
class MD5
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Constants
    // -------------------------------------------------------------------------
 
    using size_type = uint32_t;
 
    static const size_t BlockSize = 64;
 
    using DigestType = std::array< uint8_t, 16 >;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    MD5();
    ~MD5() = default;
 
    MD5( MD5 const& ) = default;
    MD5( MD5&& )      = default;
 
    MD5& operator= ( MD5 const& ) = default;
    MD5& operator= ( MD5&& )      = 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_type length );
 
    std::string final_hex();
 
    DigestType  final_digest();
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    void reset_();
 
    // MD5 block update operation. Continues an MD5 message-digest
    // operation, processing another message block
    void update_( unsigned char const* input, size_type length );
 
    // F, G, H and I are basic MD5 functions.
    static inline uint32_t F_(uint32_t x, uint32_t y, uint32_t z);
    static inline uint32_t G_(uint32_t x, uint32_t y, uint32_t z);
    static inline uint32_t H_(uint32_t x, uint32_t y, uint32_t z);
    static inline uint32_t I_(uint32_t x, uint32_t y, uint32_t z);
 
    // rotates x left n bits.
    static inline uint32_t rotate_left_(uint32_t x, int n);
 
    // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
    // Rotation is separate from addition to prevent recomputation.
    static inline void FF_(
        uint32_t &a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac
    );
    static inline void GG_(
        uint32_t &a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac
    );
    static inline void HH_(
        uint32_t &a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac
    );
    static inline void II_(
        uint32_t &a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac
    );
 
    // apply MD5 algo on a block
    void transform_( const uint8_t block[MD5::BlockSize] );
 
    // decodes input (unsigned char) into output (uint32_t). Assumes len is a multiple of 4.
    static void decode_( uint32_t output[], const uint8_t input[],  size_type len );
 
    // encodes input (uint32_t) into output (unsigned char). Assumes len is a multiple of 4.
    static void encode_( uint8_t  output[], const uint32_t input[], size_type len );
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    uint8_t buffer_[MD5::BlockSize]; // bytes that didn't fit in last 64 byte chunk
    uint32_t count_[2];   // 64bit counter for number of bits (lo, hi)
    uint32_t state_[4];   // digest so far
 
    DigestType digest_;
 
};
 
} // namespace utils
} // namespace genesis
 
// ================================================================================================
//     Standard Hash Function
// ================================================================================================
 
namespace std
{
    template<>
    struct hash<genesis::utils::MD5::DigestType>
    {
        using argument_type = genesis::utils::MD5::DigestType;
        using result_type   = std::size_t;
 
        // We use two intermediate hashes to allow better optimization.
        result_type operator()( argument_type const& s ) const {
            result_type hash1 = 0;
            result_type hash2 = 0;
            hash1 ^= ( static_cast<result_type>( s[0]  ) <<  0 );
            hash1 ^= ( static_cast<result_type>( s[1]  ) <<  8 );
            hash1 ^= ( static_cast<result_type>( s[2]  ) << 16 );
            hash1 ^= ( static_cast<result_type>( s[3]  ) << 24 );
            hash1 ^= ( static_cast<result_type>( s[4]  ) << 32 );
            hash1 ^= ( static_cast<result_type>( s[5]  ) << 40 );
            hash1 ^= ( static_cast<result_type>( s[6]  ) << 48 );
            hash1 ^= ( static_cast<result_type>( s[7]  ) << 56 );
            hash2 ^= ( static_cast<result_type>( s[8]  ) <<  0 );
            hash2 ^= ( static_cast<result_type>( s[9]  ) <<  8 );
            hash2 ^= ( static_cast<result_type>( s[10] ) << 16 );
            hash2 ^= ( static_cast<result_type>( s[11] ) << 24 );
            hash2 ^= ( static_cast<result_type>( s[12] ) << 32 );
            hash2 ^= ( static_cast<result_type>( s[13] ) << 40 );
            hash2 ^= ( static_cast<result_type>( s[14] ) << 48 );
            hash2 ^= ( static_cast<result_type>( s[15] ) << 56 );
            return hash1 ^ hash2;
        }
    };
}
 
#endif // include guard