digest.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/crypto/secure_erase.h>
 
#include <boost/endian/conversion.hpp>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace xrpl {

 
//------------------------------------------------------------------------------

struct OpensslRipemd160Hasher
{
public:
    static constexpr auto kEndian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 20>;
 
    OpensslRipemd160Hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[96]{};
};

struct OpensslSha512Hasher
{
public:
    static constexpr auto kEndian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 64>;
 
    OpensslSha512Hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[216]{};
};

struct OpensslSha256Hasher
{
public:
    static constexpr auto kEndian = boost::endian::order::native;
 
    using result_type = std::array<std::uint8_t, 32>;
 
    OpensslSha256Hasher();
 
    void
    operator()(void const* data, std::size_t size) noexcept;
 
    explicit
    operator result_type() noexcept;
 
private:
    char ctx_[112]{};
};
 
//------------------------------------------------------------------------------
 
using ripemd160_hasher = OpensslRipemd160Hasher;
using sha256_hasher = OpensslSha256Hasher;
using sha512_hasher = OpensslSha512Hasher;
 
//------------------------------------------------------------------------------

struct RipeshaHasher
{
private:
    sha256_hasher h_;
 
public:
    static constexpr auto kEndian = 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 BasicSha512HalfHasher
{
private:
    sha512_hasher h_;
 
public:
    static constexpr auto kEndian = boost::endian::order::big;
 
    using result_type = uint256;
 
    ~BasicSha512HalfHasher()
    {
        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:
    void
    erase(std::false_type)
    {
    }
 
    void
    erase(std::true_type)
    {
        secureErase(&h_, sizeof(h_));
    }
};
 
}  // namespace detail
 
using sha512_half_hasher = detail::BasicSha512HalfHasher<false>;
 
// secure version
using sha512_half_hasher_s = detail::BasicSha512HalfHasher<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<sha512_half_hasher::result_type>(h);
}

template <class... Args>
sha512_half_hasher_s::result_type
sha512HalfS(Args const&... args)
{
    sha512_half_hasher_s h;
    using beast::hash_append;
    hash_append(h, args...);
    return static_cast<sha512_half_hasher_s::result_type>(h);
}
 
}  // namespace xrpl