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 Ripemd160Hasher = OpensslRipemd160Hasher;
using Sha256Hasher = OpensslSha256Hasher;
using Sha512Hasher = OpensslSha512Hasher;
 
//------------------------------------------------------------------------------

struct RipeshaHasher
{
private:
    Sha256Hasher 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 = Sha256Hasher::result_type(h_);
        Ripemd160Hasher rh;
        rh(d0.data(), d0.size());
        return Ripemd160Hasher::result_type(rh);
    }
};
 
//------------------------------------------------------------------------------
 
namespace detail {

template <bool Secure>
struct BasicSha512HalfHasher
{
private:
    Sha512Hasher 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 = Sha512Hasher::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 Sha512HalfHasher = detail::BasicSha512HalfHasher<false>;
 
// secure version
using Sha512HalfHasherS = detail::BasicSha512HalfHasher<true>;
 
//------------------------------------------------------------------------------

template <class... Args>
Sha512HalfHasher::result_type
sha512Half(Args const&... args)
{
    Sha512HalfHasher h;
    using beast::hash_append;
    hash_append(h, args...);
    return static_cast<Sha512HalfHasher::result_type>(h);
}

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