/tmp/bitcoin/src/crypto/siphash.cpp

Source
// 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.

#include <crypto/siphash.h>

#include <uint256.h>

#include <bit>
#include <cassert>
#include <span>

#define SIPROUND do { \
    v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
    v0 = std::rotl(v0, 32); \
    v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
    v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
    v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
    v2 = std::rotl(v2, 32); \
} while (0)

CSipHasher::CSipHasher(uint64_t k0, uint64_t k1) : m_state{k0, k1} {}

CSipHasher& CSipHasher::Write(uint64_t data)
{
    uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];

    assert(m_count % 8 == 0);

    v3 ^= data;
    SIPROUND;
    SIPROUND;
    v0 ^= data;

    m_state.v[0] = v0;
    m_state.v[1] = v1;
    m_state.v[2] = v2;
    m_state.v[3] = v3;

    m_count += 8;
    return *this;
}

CSipHasher& CSipHasher::Write(std::span<const unsigned char> data)
{
    uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
    uint64_t t = m_tmp;
    uint8_t c = m_count;

    while (data.size() > 0) {
        t |= uint64_t{data.front()} << (8 * (c % 8));
        c++;
        if ((c & 7) == 0) {
            v3 ^= t;
            SIPROUND;
            SIPROUND;
            v0 ^= t;
            t = 0;
        }
        data = data.subspan(1);
    }

    m_state.v[0] = v0;
    m_state.v[1] = v1;
    m_state.v[2] = v2;
    m_state.v[3] = v3;
    m_count = c;
    m_tmp = t;

    return *this;
}

uint64_t CSipHasher::Finalize() const
{
    uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];

    uint64_t t = m_tmp | (((uint64_t)m_count) << 56);

    v3 ^= t;
    SIPROUND;
    SIPROUND;
    v0 ^= t;
    v2 ^= 0xFF;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    return v0 ^ v1 ^ v2 ^ v3;
}

uint64_t PresaltedSipHasher::operator()(const uint256& val) const noexcept
{
    uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
    uint64_t d = val.GetUint64(0);
    v3 ^= d;

    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(1);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(2);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(3);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    v3 ^= (uint64_t{4}) << 59;
    SIPROUND;
    SIPROUND;
    v0 ^= (uint64_t{4}) << 59;
    v2 ^= 0xFF;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    return v0 ^ v1 ^ v2 ^ v3;
}

/** Specialized implementation for efficiency */
uint64_t PresaltedSipHasher::operator()(const uint256& val, uint32_t extra) const noexcept
{
    uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
    uint64_t d = val.GetUint64(0);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(1);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(2);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = val.GetUint64(3);
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    d = ((uint64_t{36}) << 56) | extra;
    v3 ^= d;
    SIPROUND;
    SIPROUND;
    v0 ^= d;
    v2 ^= 0xFF;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    SIPROUND;
    return v0 ^ v1 ^ v2 ^ v3;
}

Line	Count	Source
1		// Copyright (c) 2016-present The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5		#include <crypto/siphash.h>
6
7		#include <uint256.h>
8
9		#include <bit>
10		#include <cassert>
11		#include <span>
12
13	4.21G	#define SIPROUND do { \
14	4.21G	v0 += v1; v1 = std::rotl(v1, 13); v1 ^= v0; \
15	4.21G	v0 = std::rotl(v0, 32); \
16	4.21G	v2 += v3; v3 = std::rotl(v3, 16); v3 ^= v2; \
17	4.21G	v0 += v3; v3 = std::rotl(v3, 21); v3 ^= v0; \
18	4.21G	v2 += v1; v1 = std::rotl(v1, 17); v1 ^= v2; \
19	4.21G	v2 = std::rotl(v2, 32); \
20	4.21G	} while (0)
21
22	7.04M	CSipHasher::CSipHasher(uint64_t k0, uint64_t k1) : m_state{k0, k1} {}
23
24		CSipHasher& CSipHasher::Write(uint64_t data)
25	5.19M	{
26	5.19M	uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
27
28	5.19M	assert(m_count % 8 == 0);
29
30	5.19M	v3 ^= data;
31	5.19M	SIPROUND;
32	5.19M	SIPROUND;
33	5.19M	v0 ^= data;
34
35	5.19M	m_state.v[0] = v0;
36	5.19M	m_state.v[1] = v1;
37	5.19M	m_state.v[2] = v2;
38	5.19M	m_state.v[3] = v3;
39
40	5.19M	m_count += 8;
41	5.19M	return *this;
42	5.19M	}
43
44		CSipHasher& CSipHasher::Write(std::span<const unsigned char> data)
45	7.04M	{
46	7.04M	uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
47	7.04M	uint64_t t = m_tmp;
48	7.04M	uint8_t c = m_count;
49
50	234M	while (data.size() > 0) {
51	227M	t \|= uint64_t{data.front()} << (8 * (c % 8));
52	227M	c++;
53	227M	if ((c & 7) == 0) {
54	27.1M	v3 ^= t;
55	27.1M	SIPROUND;
56	27.1M	SIPROUND;
57	27.1M	v0 ^= t;
58	27.1M	t = 0;
59	27.1M	}
60	227M	data = data.subspan(1);
61	227M	}
62
63	7.04M	m_state.v[0] = v0;
64	7.04M	m_state.v[1] = v1;
65	7.04M	m_state.v[2] = v2;
66	7.04M	m_state.v[3] = v3;
67	7.04M	m_count = c;
68	7.04M	m_tmp = t;
69
70	7.04M	return *this;
71	7.04M	}
72
73		uint64_t CSipHasher::Finalize() const
74	7.04M	{
75	7.04M	uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
76
77	7.04M	uint64_t t = m_tmp \| (((uint64_t)m_count) << 56);
78
79	7.04M	v3 ^= t;
80	7.04M	SIPROUND;
81	7.04M	SIPROUND;
82	7.04M	v0 ^= t;
83	7.04M	v2 ^= 0xFF;
84	7.04M	SIPROUND;
85	7.04M	SIPROUND;
86	7.04M	SIPROUND;
87	7.04M	SIPROUND;
88	7.04M	return v0 ^ v1 ^ v2 ^ v3;
89	7.04M	}
90
91		uint64_t PresaltedSipHasher::operator()(const uint256& val) const noexcept
92	42.4M	{
93	42.4M	uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
94	42.4M	uint64_t d = val.GetUint64(0);
95	42.4M	v3 ^= d;
96
97	42.4M	SIPROUND;
98	42.4M	SIPROUND;
99	42.4M	v0 ^= d;
100	42.4M	d = val.GetUint64(1);
101	42.4M	v3 ^= d;
102	42.4M	SIPROUND;
103	42.4M	SIPROUND;
104	42.4M	v0 ^= d;
105	42.4M	d = val.GetUint64(2);
106	42.4M	v3 ^= d;
107	42.4M	SIPROUND;
108	42.4M	SIPROUND;
109	42.4M	v0 ^= d;
110	42.4M	d = val.GetUint64(3);
111	42.4M	v3 ^= d;
112	42.4M	SIPROUND;
113	42.4M	SIPROUND;
114	42.4M	v0 ^= d;
115	42.4M	v3 ^= (uint64_t{4}) << 59;
116	42.4M	SIPROUND;
117	42.4M	SIPROUND;
118	42.4M	v0 ^= (uint64_t{4}) << 59;
119	42.4M	v2 ^= 0xFF;
120	42.4M	SIPROUND;
121	42.4M	SIPROUND;
122	42.4M	SIPROUND;
123	42.4M	SIPROUND;
124	42.4M	return v0 ^ v1 ^ v2 ^ v3;
125	42.4M	}
126
127		/** Specialized implementation for efficiency */
128		uint64_t PresaltedSipHasher::operator()(const uint256& val, uint32_t extra) const noexcept
129	250M	{
130	250M	uint64_t v0 = m_state.v[0], v1 = m_state.v[1], v2 = m_state.v[2], v3 = m_state.v[3];
131	250M	uint64_t d = val.GetUint64(0);
132	250M	v3 ^= d;
133	250M	SIPROUND;
134	250M	SIPROUND;
135	250M	v0 ^= d;
136	250M	d = val.GetUint64(1);
137	250M	v3 ^= d;
138	250M	SIPROUND;
139	250M	SIPROUND;
140	250M	v0 ^= d;
141	250M	d = val.GetUint64(2);
142	250M	v3 ^= d;
143	250M	SIPROUND;
144	250M	SIPROUND;
145	250M	v0 ^= d;
146	250M	d = val.GetUint64(3);
147	250M	v3 ^= d;
148	250M	SIPROUND;
149	250M	SIPROUND;
150	250M	v0 ^= d;
151	250M	d = ((uint64_t{36}) << 56) \| extra;
152	250M	v3 ^= d;
153	250M	SIPROUND;
154	250M	SIPROUND;
155	250M	v0 ^= d;
156	250M	v2 ^= 0xFF;
157	250M	SIPROUND;
158	250M	SIPROUND;
159	250M	SIPROUND;
160	250M	SIPROUND;
161	250M	return v0 ^ v1 ^ v2 ^ v3;
162	250M	}

Coverage Report

Created: 2026-05-08 10:34