hasher.hpp

Go to the documentation of this file.

/*
This code is written by kerukuro and released into public domain.
*/
 
#ifndef DIGESTPP_HASHER_HPP
#define DIGESTPP_HASHER_HPP
 
#include <string>
#include <array>
#include <algorithm>
#include <vector>
#include <iterator>
#include <sstream>
#include <cstring>
#include <iomanip>
#include <cstdint>
 
#include "detail/traits.hpp"
#include "detail/stream_width_fixer.hpp"
#include "algorithm/mixin/null_mixin.hpp"
 
namespace digestpp
{
 
template<class HashProvider, template <class> class Mixin = mixin::null_mixin>
class hasher : public Mixin<HashProvider>
{
    public:
 
    template<typename H=HashProvider, typename std::enable_if<std::is_default_constructible<H>::value>::type* = nullptr>
    hasher()
    {
        provider.init();
    }
 
    template<typename H=HashProvider, typename std::enable_if<!detail::is_xof<H>::value>::type* = nullptr>
    hasher(size_t hashsize) : provider(hashsize)
    {
        provider.init();
    }
 
    template<typename T, typename std::enable_if<detail::is_byte<T>::value>::type* = nullptr>
    inline hasher& absorb(const T* data, size_t len)
    {
        provider.update(reinterpret_cast<const unsigned char*>(data), len);
        return *this;
    }
 
    template<typename T, size_t N, typename std::enable_if<detail::is_byte<T>::value>::type* = nullptr>
    inline hasher& absorb(const std::array<T, N>& arr)
    {
        return absorb(arr.data(), arr.size());
    }
 
    template<typename T,
        typename std::enable_if<detail::is_byte<T>::value && !std::is_same<T, std::string::value_type>::value>::type* = nullptr>
    inline hasher& absorb(const std::basic_string<T>& str)
    {
        if (!str.empty())
            provider.update(reinterpret_cast<const unsigned char*>(&str[0]), str.size());
        return *this;
    }
 
    inline hasher& absorb(const std::string& str)
    {
        if (!str.empty())
            provider.update(reinterpret_cast<const unsigned char*>(&str[0]), str.size());
        return *this;
    }
 
    template<typename T, typename std::enable_if<detail::is_byte<T>::value>::type* = nullptr>
    inline hasher& absorb(std::basic_istream<T>& istr)
    {
        const int tmp_buffer_size = 65536;
        unsigned char buffer[tmp_buffer_size];
        while (istr.read(reinterpret_cast<T*>(buffer), sizeof(buffer)))
        {
            provider.update(buffer, sizeof(buffer));
        }
        size_t gcount = istr.gcount();
        if (gcount)
        {
            provider.update(buffer, gcount);
        }
        return *this;
    }
 
    template<typename IT>
    inline hasher& absorb(IT begin, IT end)
    {
        while (begin != end)
        {
            unsigned char byte = *begin++;
            provider.update(&byte, 1);
        }
        return *this;
    }
 
    template<typename T, typename H=HashProvider,
        typename std::enable_if<detail::is_byte<T>::value && detail::is_xof<H>::value>::type* = nullptr>
    inline void squeeze(T* buf, size_t len)
    {
        provider.squeeze(reinterpret_cast<unsigned char*>(buf), len);
    }
 
    template<typename T, size_t N, typename H=HashProvider,
        typename std::enable_if<detail::is_byte<T>::value && detail::is_xof<H>::value>::type* = nullptr>
    inline void squeeze(T(&arr)[N])
    {
        squeeze(arr, N);
    }
 
    template<typename T, size_t N, typename H=HashProvider,
        typename std::enable_if<detail::is_byte<T>::value && detail::is_xof<H>::value>::type* = nullptr>
    inline void squeeze(std::array<T, N>& arr)
    {
        squeeze(arr.data(), arr.size());
    }
 
    template<typename OI, typename H=HashProvider, typename std::enable_if<detail::is_xof<H>::value>::type* = nullptr>
    inline void squeeze(size_t len, OI it)
    {
        std::vector<unsigned char> hash(len);
        provider.squeeze(&hash[0], len);
        std::copy(hash.begin(), hash.end(), it);
    }
 
    template<typename H=HashProvider, typename std::enable_if<detail::is_xof<H>::value>::type* = nullptr>
    inline std::string hexsqueeze(size_t len)
    {
        std::ostringstream res;
        res << std::setfill('0') << std::hex;
        squeeze(len, std::ostream_iterator<detail::stream_width_fixer<unsigned int, 2>>(res, ""));
        return res.str();
    }
 
    template<typename T, typename H=HashProvider,
        typename std::enable_if<detail::is_byte<T>::value && !detail::is_xof<H>::value>::type* = nullptr>
    inline void digest(T* buf, size_t len) const
    {
        if (len < provider.hash_size() / 8)
            throw std::runtime_error("Invalid buffer size");
 
        HashProvider copy(provider);
        copy.final(buf);
    }
 
    template<typename OI, typename H=HashProvider, typename std::enable_if<!detail::is_xof<H>::value>::type* = nullptr>
    inline void digest(OI it) const
    {
        HashProvider copy(provider);
        std::vector<unsigned char> hash(provider.hash_size() / 8);
        copy.final(&hash[0]);
        std::copy(hash.begin(), hash.end(), it);
    }
 
    template<typename H=HashProvider, typename std::enable_if<!detail::is_xof<H>::value>::type* = nullptr>
    inline std::string hexdigest() const
    {
        std::ostringstream res;
        res << std::setfill('0') << std::hex;
        digest(std::ostream_iterator<detail::stream_width_fixer<unsigned int, 2>>(res, ""));
        return res.str();
    }
 
    inline void reset(bool resetParameters = false)
    {
        if (resetParameters)
            provider.clear();
        provider.init();
    }
 
private:
    friend Mixin<HashProvider>;
    HashProvider provider;
};
 
 
} // namespace digestpp
 
#endif // DIGESTPP_HASHER_HPP