Line data Source code
1 : /*
2 : * Copyright (C) 2026 Andrea Mazzoleni
3 : *
4 : * This program is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 3 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * This program is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 : */
17 :
18 : /*
19 : * Derivative work from MuseAir 0.4-rc4 in the "Bfast" configuration
20 : *
21 : * This version extends the original MuseAirLoong to accept a full 128-bit seed.
22 : *
23 : * Note: The original algorithm's behavior can be perfectly replicated by
24 : * setting the low and high part of the seed to the same 64-bit value.
25 : *
26 : * https://github.com/eternal-io/museair
27 : */
28 :
29 : /*
30 : * MuseAir hash algorithm itself and its reference implementation (this file)
31 : * by K--Aethiax are released into the public domain under the CC0 1.0 license.
32 : * To view a copy of this license, visit: https://creativecommons.org/publicdomain/zero/1.0/
33 : */
34 :
35 : #define MUSEAIR_ALGORITHM_VERSION "0.4-rc4"
36 :
37 : #define u64x(N) (N * 8)
38 :
39 : /* AiryAi(0) fractional part calculated by Y-Cruncher */
40 : static const uint64_t MUSEAIR_CONSTANT[7] = {
41 : 0x5ae31e589c56e17aULL,
42 : 0x96d7bb04e64f6da9ULL,
43 : 0x7ab1006b26f9eb64ULL,
44 : 0x21233394220b8457ULL,
45 : 0x047cb9557c9f3b43ULL,
46 : 0xd24f2590c0bcee28ULL,
47 : 0x33ea8f71bb6016d8ULL
48 : };
49 :
50 : #define mult64_128(l, h, a, b) \
51 : do { \
52 : l = a; \
53 : h = b; \
54 : util_mum(&l, &h); \
55 : } while (0)
56 :
57 : #define likely(a) tommy_likely(a)
58 : #define unlikely(a) tommy_unlikely(a)
59 :
60 361 : static void MuseAirLoong(const void* bytes, size_t len, const uint8_t* seed, uint8_t* out)
61 : {
62 361 : const uint8_t* p = bytes;
63 361 : size_t q = len;
64 :
65 : /* EXTENSION: This algo doesn't support shorter lengths */
66 361 : assert(len >= 32);
67 :
68 : uint64_t i, j, k;
69 :
70 361 : uint64_t lo0, lo1, lo2, lo3, lo4, lo5 = MUSEAIR_CONSTANT[6];
71 : uint64_t hi0, hi1, hi2, hi3, hi4, hi5;
72 :
73 : /*
74 : * EXTENSION: Initialize primary state with 128-bit seed (seed0 and seed1)
75 : * Ensures both halves influence the hash.
76 : *
77 : * Original code was:
78 : * uint64_t state[6] = {MUSEAIR_CONSTANT[0] + seed, MUSEAIR_CONSTANT[1] - seed, MUSEAIR_CONSTANT[2] ^ seed,
79 : * MUSEAIR_CONSTANT[3] + seed, MUSEAIR_CONSTANT[4] - seed, MUSEAIR_CONSTANT[5] ^ seed};
80 : */
81 361 : uint64_t seed0 = util_read64(seed);
82 361 : uint64_t seed1 = util_read64(seed + 8);
83 361 : uint64_t state[6] = { MUSEAIR_CONSTANT[0] + seed0, MUSEAIR_CONSTANT[1] - seed1, MUSEAIR_CONSTANT[2] ^ seed0,
84 361 : MUSEAIR_CONSTANT[3] + seed1, MUSEAIR_CONSTANT[4] - seed0, MUSEAIR_CONSTANT[5] ^ seed1 };
85 :
86 361 : if (unlikely(q > u64x(12))) {
87 : do {
88 371504 : state[0] ^= util_read64(p + u64x(0));
89 371504 : state[1] ^= util_read64(p + u64x(1));
90 371504 : mult64_128(lo0, hi0, state[0], state[1]);
91 371504 : state[0] = lo5 ^ hi0;
92 :
93 371504 : state[1] ^= util_read64(p + u64x(2));
94 371504 : state[2] ^= util_read64(p + u64x(3));
95 371504 : mult64_128(lo1, hi1, state[1], state[2]);
96 371504 : state[1] = lo0 ^ hi1;
97 :
98 371504 : state[2] ^= util_read64(p + u64x(4));
99 371504 : state[3] ^= util_read64(p + u64x(5));
100 371504 : mult64_128(lo2, hi2, state[2], state[3]);
101 371504 : state[2] = lo1 ^ hi2;
102 :
103 371504 : state[3] ^= util_read64(p + u64x(6));
104 371504 : state[4] ^= util_read64(p + u64x(7));
105 371504 : mult64_128(lo3, hi3, state[3], state[4]);
106 371504 : state[3] = lo2 ^ hi3;
107 :
108 371504 : state[4] ^= util_read64(p + u64x(8));
109 371504 : state[5] ^= util_read64(p + u64x(9));
110 371504 : mult64_128(lo4, hi4, state[4], state[5]);
111 371504 : state[4] = lo3 ^ hi4;
112 :
113 371504 : state[5] ^= util_read64(p + u64x(10));
114 371504 : state[0] ^= util_read64(p + u64x(11));
115 371504 : mult64_128(lo5, hi5, state[5], state[0]);
116 371504 : state[5] = lo4 ^ hi5;
117 :
118 371504 : p += u64x(12);
119 371504 : q -= u64x(12);
120 :
121 371504 : } while (likely(q > u64x(12)));
122 :
123 296 : state[0] ^= lo5;
124 : }
125 :
126 361 : lo0 = 0, lo1 = 0, lo2 = 0, lo3 = 0, lo4 = 0, lo5 = 0;
127 361 : hi0 = 0, hi1 = 0, hi2 = 0, hi3 = 0, hi4 = 0, hi5 = 0;
128 :
129 361 : if (likely(q > u64x(4))) {
130 296 : state[0] ^= util_read64(p + u64x(0));
131 296 : state[1] ^= util_read64(p + u64x(1));
132 296 : mult64_128(lo0, hi0, state[0], state[1]);
133 :
134 296 : if (likely(q > u64x(6))) {
135 248 : state[1] ^= util_read64(p + u64x(2));
136 248 : state[2] ^= util_read64(p + u64x(3));
137 248 : mult64_128(lo1, hi1, state[1], state[2]);
138 :
139 248 : if (likely(q > u64x(8))) {
140 64 : state[2] ^= util_read64(p + u64x(4));
141 64 : state[3] ^= util_read64(p + u64x(5));
142 64 : mult64_128(lo2, hi2, state[2], state[3]);
143 :
144 64 : if (likely(q > u64x(10))) {
145 32 : state[3] ^= util_read64(p + u64x(6));
146 32 : state[4] ^= util_read64(p + u64x(7));
147 32 : mult64_128(lo3, hi3, state[3], state[4]);
148 : }
149 : }
150 : }
151 : }
152 :
153 361 : state[4] ^= util_read64(p + q - u64x(4));
154 361 : state[5] ^= util_read64(p + q - u64x(3));
155 361 : mult64_128(lo4, hi4, state[4], state[5]);
156 :
157 361 : state[5] ^= util_read64(p + q - u64x(2));
158 361 : state[0] ^= util_read64(p + q - u64x(1));
159 361 : mult64_128(lo5, hi5, state[5], state[0]);
160 :
161 361 : i = state[0] - state[1];
162 361 : j = state[2] - state[3];
163 361 : k = state[4] - state[5];
164 :
165 361 : int rot = len & 63;
166 361 : i = util_rotl64(i, rot);
167 361 : j = util_rotr64(j, rot);
168 361 : k ^= len;
169 :
170 361 : i += lo3 ^ hi3 ^ lo4 ^ hi4;
171 361 : j += lo5 ^ hi5 ^ lo0 ^ hi0;
172 361 : k += lo1 ^ hi1 ^ lo2 ^ hi2;
173 :
174 361 : mult64_128(lo0, hi0, i, j);
175 361 : mult64_128(lo1, hi1, j, k);
176 361 : mult64_128(lo2, hi2, k, i);
177 :
178 361 : util_write64(out, lo0 ^ lo1 ^ hi2);
179 361 : util_write64(out + 8, hi0 ^ hi1 ^ lo2);
180 361 : }
181 :
|
