siphash.h

Go to the documentation of this file.

// Copyright (c) 2016-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_CRYPTO_SIPHASH_H
#define BITCOIN_CRYPTO_SIPHASH_H
 
#include <attributes.h>
#include <uint256.h>
 
#include <bit>
#include <cstdint>
#include <span>
 
class SipHashState
{
    static constexpr uint64_t C0{0x736f6d6570736575}, C1{0x646f72616e646f6d}, C2{0x6c7967656e657261}, C3{0x7465646279746573};
    static constexpr uint64_t FINALIZER{0xFF};
    static constexpr uint64_t FINALIZER_UNPADDED{0x6465646461706e75};
    static_assert(FINALIZER_UNPADDED != FINALIZER);
 
    ALWAYS_INLINE SipHashState(uint64_t v0, uint64_t v1, uint64_t v2, uint64_t v3) noexcept : m_v0{v0}, m_v1{v1}, m_v2{v2}, m_v3{v3} {}
 
    uint64_t m_v0, m_v1, m_v2, m_v3;
 
    ALWAYS_INLINE void SipRound() noexcept
    {
        m_v0 += m_v1; m_v1 = std::rotl(m_v1, 13); m_v1 ^= m_v0;
        m_v0 = std::rotl(m_v0, 32);
        m_v2 += m_v3; m_v3 = std::rotl(m_v3, 16); m_v3 ^= m_v2;
        m_v0 += m_v3; m_v3 = std::rotl(m_v3, 21); m_v3 ^= m_v0;
        m_v2 += m_v1; m_v1 = std::rotl(m_v1, 17); m_v1 ^= m_v2;
        m_v2 = std::rotl(m_v2, 32);
    }
 
public:
    explicit ALWAYS_INLINE SipHashState(uint64_t k0, uint64_t k1) noexcept : SipHashState{C0 ^ k0, C1 ^ k1, C2 ^ k0, C3 ^ k1} {}
    ALWAYS_INLINE SipHashState Copy() const noexcept { return {m_v0, m_v1, m_v2, m_v3}; }
    ALWAYS_INLINE SipHashState& Compress1(uint64_t data) noexcept
    {
        m_v3 ^= data;
        SipRound();
        m_v0 ^= data;
        return *this;
    }
    ALWAYS_INLINE SipHashState& Compress1Jumbo(const uint256& data) noexcept
    {
        const uint64_t d0{data.GetUint64(0)}, d1{data.GetUint64(1)}, d2{data.GetUint64(2)}, d3{data.GetUint64(3)};
        m_v3 ^= d0; m_v0 ^= d1; m_v1 ^= d2; m_v2 ^= d3;
        SipRound();
        m_v0 ^= d0; m_v1 ^= d1; m_v2 ^= d2; m_v3 ^= d3;
        return *this;
    }
    ALWAYS_INLINE SipHashState& Compress2(uint64_t data) noexcept
    {
        m_v3 ^= data;
        SipRound();
        SipRound();
        m_v0 ^= data;
        return *this;
    }
    ALWAYS_INLINE uint64_t Finalize4() noexcept
    {
        m_v2 ^= FINALIZER;
        SipRound();
        SipRound();
        SipRound();
        SipRound();
        return m_v0 ^ m_v1 ^ m_v2 ^ m_v3;
    }
    ALWAYS_INLINE uint64_t Finalize3U() noexcept
    {
        m_v2 ^= FINALIZER_UNPADDED;
        SipRound();
        SipRound();
        SipRound();
        return m_v0 ^ m_v1 ^ m_v2 ^ m_v3;
    }
};
 
class CSipHasher
{
    SipHashState m_state;
    uint64_t m_tmp{0};
    uint8_t m_count{0}; 
 
public:
    CSipHasher(uint64_t k0, uint64_t k1);
    CSipHasher& Write(uint64_t data);
    CSipHasher& Write(std::span<const unsigned char> data);
    uint64_t Finalize() const;
};
 
class SipHasher13UJ
{
    SipHashState m_state;
 
public:
    SipHasher13UJ(uint64_t k0, uint64_t k1) noexcept : m_state{k0, k1} {}
    SipHasher13UJ& Write(uint64_t data) noexcept;
    SipHasher13UJ& WriteJumbo(const uint256& hash) noexcept;
    uint64_t Finalize() const noexcept;
 
    ALWAYS_INLINE uint64_t Hash(const uint256& hash) const noexcept
    {
        return m_state.Copy()
                      .Compress1Jumbo(hash)
                      .Finalize3U();
    }
 
    ALWAYS_INLINE uint64_t Hash(const uint256& hash, uint64_t extra) const noexcept
    {
        return m_state.Copy()
                      .Compress1Jumbo(hash)
                      .Compress1(extra)
                      .Finalize3U();
    }
};
 
class PresaltedSipHasher
{
    const SipHashState m_state;
 
public:
    explicit PresaltedSipHasher(uint64_t k0, uint64_t k1) noexcept : m_state{k0, k1} {}
 
    uint64_t operator()(const uint256& val) const noexcept;
 
    uint64_t operator()(const uint256& val, uint32_t extra) const noexcept;
};
 
#endif // BITCOIN_CRYPTO_SIPHASH_H