digest.h

#ifndef XRPL_PROTOCOL_DIGEST_H_INCLUDED
#define XRPL_PROTOCOL_DIGEST_H_INCLUDED
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/crypto/secure_erase.h>
 
#include <boost/endian/conversion.hpp>
 
#include <array>
 
namespace ripple {
 
//------------------------------------------------------------------------------
 
struct openssl_ripemd160_hasher
{
public:
    static constexpr auto const endian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 20>;
 
    openssl_ripemd160_hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[96];
};
 
struct openssl_sha512_hasher
{
public:
    static constexpr auto const endian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 64>;
 
    openssl_sha512_hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[216];
};
 
struct openssl_sha256_hasher
{
public:
    static constexpr auto const endian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 32>;
 
    openssl_sha256_hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[112];
};
 
//------------------------------------------------------------------------------
 
using ripemd160_hasher = openssl_ripemd160_hasher;
using sha256_hasher = openssl_sha256_hasher;
using sha512_hasher = openssl_sha512_hasher;
 
//------------------------------------------------------------------------------
 
struct ripesha_hasher
{
private:
    sha256_hasher h_;
 
public:
    static constexpr auto const endian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 20>;
 
    void
    operator()(void const* data, std::size_t size) noexcept
    {
        h_(data, size);
    }
 
    explicit
    operator result_type() noexcept
    {
        auto const d0 = sha256_hasher::result_type(h_);
        ripemd160_hasher rh;
        rh(d0.data(), d0.size());
        return ripemd160_hasher::result_type(rh);
    }
};
 
//------------------------------------------------------------------------------
 
namespace detail {
 
template <bool Secure>
struct basic_sha512_half_hasher
{
private:
    sha512_hasher h_;
 
public:
    static constexpr auto const endian = boost::endian::order::big;
 
    using result_type = uint256;
 
    ~basic_sha512_half_hasher()
    {
        erase(std::integral_constant<bool, Secure>{});
    }
 
    void
    operator()(void const* data, std::size_t size) noexcept
    {
        h_(data, size);
    }
 
    explicit
    operator result_type() noexcept
    {
        auto const digest = sha512_hasher::result_type(h_);
        return result_type::fromVoid(digest.data());
    }
 
private:
    inline void
    erase(std::false_type)
    {
    }
 
    inline void
    erase(std::true_type)
    {
        secure_erase(&h_, sizeof(h_));
    }
};
 
}  // namespace detail
 
using sha512_half_hasher = detail::basic_sha512_half_hasher<false>;
 
// secure version
using sha512_half_hasher_s = detail::basic_sha512_half_hasher<true>;
 
//------------------------------------------------------------------------------
 
template <class... Args>
sha512_half_hasher::result_type
sha512Half(Args const&... args)
{
    sha512_half_hasher h;
    using beast::hash_append;
    hash_append(h, args...);
    return static_cast<typename sha512_half_hasher::result_type>(h);
}
 
template <class... Args>
sha512_half_hasher_s::result_type
sha512Half_s(Args const&... args)
{
    sha512_half_hasher_s h;
    using beast::hash_append;
    hash_append(h, args...);
    return static_cast<typename sha512_half_hasher_s::result_type>(h);
}
 
}  // namespace ripple
 
#endif