bee2-rs 0.2.1

Bindings for cryptographic library Bee2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355

/*
*******************************************************************************
\file bash_fneon.c
\brief STB 34.101.77 (bash): bash-f optimized for ARM NEON
\project bee2 [cryptographic library]
\created 2020.10.26
\version 2023.02.02
\copyright The Bee2 authors
\license Licensed under the Apache License, Version 2.0 (see LICENSE.txt).
*******************************************************************************
*/

#ifndef _M_ARM64
	#include <arm_neon.h>
#else
	#include <arm64_neon.h>
#endif

#include "bee2/core/mem.h"
#include "bee2/core/util.h"
#include "bee2/crypto/bash.h"

/*
*******************************************************************************
Сокращения для используемых intrinsic

Нотация:
- W (прописные буквы) -- 128-разрядное слово;
- w (строчные буквы) -- 64-разрядное слово;
- в W = (w0, w1) слово w0 -- младшее, w1 -- старшее.

\remark Указатель на память при загрузке и выгрузке в LOAD и STORE должен быть
выровнен на границу 64 бит (8 байт).

\todo На AArch64 использовать vld4q_u64 и vld4q_u64 для загрузки и выгрузки.
\todo На AArch64 использовать veor3q_u64 для X3.
\todo Использовать vtbl4_u8 и vtbx4_u8 для более эффективной реализации
перестановки.
*******************************************************************************
*/

#define LOAD(s) vld1q_u64((uint64_t const *) (s))
#define STORE(s, W) vst1q_u64((uint64_t *)(s), (W))

#define S2(w0, w1) vsetq_lane_u64(w0, vmovq_n_u64(w1), 0)
#define X2(W1, W2) veorq_u64(W1, W2)
#define X3(W1, W2, W3) X2(W1, X2(W2, W3))
#define O2(W1, W2) vorrq_u64(W1, W2)
#define A2(W1, W2) vandq_u64(W1, W2)
#define NO2(W1, W2) vornq_u64(W1, W2)

#define SL2(W, m) vshlq_n_u64(W, m)
#define SR2(W, m) vshrq_n_u64(W, m)

#define P2_10(W) vextq_u64(W, W, 1)
#define P2_02(W0, W1) vsetq_lane_u64(vgetq_lane_u64(W1, 0), W0, 1)
#define P2_13(W0, W1) vsetq_lane_u64(vgetq_lane_u64(W0, 1), W1, 0)

/*
*******************************************************************************
Состояние

64-разрядные слова состояния Si, i = 0, 1,..., 23, объединяются в пары --
128-разрядные слова Wi:
	W0 [S0 ,S1 ] W1 [S2 ,S3 ] W2 [S4 ,S5 ] W3 [S6 ,S7 ]
	W4 [S8 ,S9 ] W5 [S10,S11] W6 [S12,S13] W7 [S14,S15]
	W8 [S16,S17] W9 [S18,S19] W10[S20,S21] W11[S22,S23]

Преобразования столбцов, т.е. троек слов Si, распространяются на тройки
слов Wi. Так преобразование тройки (W0, W4, W8) состоит в одновременном
преобразовании столбцов (S0, S8, S16) и (S1, S9, S17).

Для организации перестановки P используются макросы, определенные выше:
- P2_10: переставить половинки 128-разрядного слова;
- P2_02: объединить младшие половинки 128-разрядных слов;
- P2_13: объединить старшие половинки 128-разрядных слов.

Макрос R2 выполняет циклические сдвиги половинок 128-разрядного слова:
- к младшей половинке применяется сдвиг RotHi^i0;
- к старшей половинке применяется сдвиг RotHi^i1.
*******************************************************************************
*/

#define R2(W, i0,i1)\
  P2_02(X2(SL2(W, i0), SR2(W, 64-i0)), P2_10(X2(SL2(W, i1),SR2(W, 64-i1))))

/*
*******************************************************************************
Bash-S
*******************************************************************************
*/

#define bashS(W0,W1,W2, M1,N1,M2,N2)\
	Z2 = M1(W0);\
	U0 = X3(W0, W1, W2);\
	Z1 = X2(W1, N1(U0));\
	U2 = X3(W2, M2(W2), N2(Z1));\
	U1 = X2(Z1, Z2);\
	T1 = O2(U0, U2);\
	T2 = A2(U0, U1);\
	T0 = NO2(U1, U2);\
	W1 = X2(U1, T1);\
	W2 = X2(U2, T2);\
	W0 = X2(U0, T0)

/*
*******************************************************************************
Перестановка P

Вместо перестановки P используются более простые для реализации
перестановки P0 и P1 такие, что P1 P0 = P^2. P0 применяется на тактах
1, 3, ...., P1 -- на тактах 2, 4, .....

P0 и P1 выбраны так, что P0 = delta P, P1 = P delta, а delta^2 = id.
Конкретнее, delta переставляет столбцы по правилу 01234567 -> 10234576.

Инструкции NEON имеют ограничения по перемешиванию 64-битных слов в регистрах.
Использование дополнительной подстановки delta позволяет
сократить число инструкций по сравнению с тривиальной реализацией.

Cлова на входах тактов 2, 4, ... перемешаны относительно стандартного
порядка, поэтому сдвиговые константы на этих тактах также перемешаны.
*******************************************************************************
*/

#define bashP10(W0, W1, W2)\
	W0 = P2_10(W0);\
	W1 = P2_10(W1);\
	W2 = P2_10(W2)

#define bashPP(W0, W1, W2, W3, W4, W5)\
	T0 = W4;\
	T1 = W5;\
	W4 = P2_02(W0, W1);\
	W5 = P2_13(W0, W1);\
	W1 = P2_02(W2, W3);\
	W0 = P2_13(W2, W3);\
	W2 = T0;\
	W3 = T1

/* W0 [S0 ,S1 ] W1 [S2 ,S3 ] W2 [S4 ,S5 ] W3 [S6 ,S7 ]
   W4 [S8 ,S9 ] W5 [S10,S11] W6 [S12,S13] W7 [S14,S15]
   W8 [S16,S17] W9 [S18,S19] W10[S20,S21] W11[S22,S23]
-> W0 [S10,S15] W1 [S9 ,S12] W2 [S11,S14] W3 [S8 ,S13]
   W4 [S16,S17] W5 [S19,S18] W6 [S21,S20] W7 [S22,S23]
   W8 [S3 ,S6 ] W9 [S0 ,S5 ] W10[S2 ,S7 ] W11[S1 ,S4 ] */
#define bashP0\
	bashP10(W1, W6, W10);\
	bashPP(W1, W3, W4, W6, W8, W10);\
	bashP10(W2, W5, W9);\
	bashPP(W0, W2, W5, W7, W9, W11)

/* W0 [S0 ,S1 ] W1 [S2 ,S3 ] W2 [S4 ,S5 ] W3 [S6 ,S7 ]
   W4 [S8 ,S9 ] W5 [S10,S11] W6 [S12,S13] W7 [S14,S15]
   W8 [S16,S17] W9 [S18,S19] W10[S20,S21] W11[S22,S23]
-> W0 [S14,S10] W1 [S8 ,S12] W2 [S11,S15] W3 [S13,S9 ]
   W4 [S16,S17] W5 [S19,S18] W6 [S21,S20] W7 [S22,S23]
   W8 [S7 ,S3 ] W9 [S1 ,S5 ] W10[S2 ,S6 ] W11[S4 ,S0 ] */
#define bashP1\
	bashPP(W3, W1, W6, W4, W10, W8);\
	bashP10(W1, W6, W10);\
	bashPP(W2, W0, W7, W5, W11, W9);\
	bashP10(W2, W5, W9)

/*
*******************************************************************************
Сдвиговые константы

Cлова на входах тактов 2, 4, ... перемешаны относительно стандартного
порядка, поэтому сдвиговые константы на этих тактах также перемешиваются:
R2_X_1(W, i) = R2_X_0(W, delta(i)).
*******************************************************************************
*/

#define R2_0_0(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i0,i1)
#define R2_1_0(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i2,i3)
#define R2_2_0(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i4,i5)
#define R2_3_0(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i6,i7)
#define R2_0_1(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i1,i0)
#define R2_1_1(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i2,i3)
#define R2_2_1(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i4,i5)
#define R2_3_1(W, i0,i1,i2,i3,i4,i5,i6,i7) R2(W, i7,i6)

#define M1_0_0(W) R2_0_0(W,  8,56, 8,56, 8,56, 8,56)
#define M1_1_0(W) R2_1_0(W,  8,56, 8,56, 8,56, 8,56)
#define M1_2_0(W) R2_2_0(W,  8,56, 8,56, 8,56, 8,56)
#define M1_3_0(W) R2_3_0(W,  8,56, 8,56, 8,56, 8,56)
#define M1_0_1(W) R2_0_1(W,  8,56, 8,56, 8,56, 8,56)
#define M1_1_1(W) R2_1_1(W,  8,56, 8,56, 8,56, 8,56)
#define M1_2_1(W) R2_2_1(W,  8,56, 8,56, 8,56, 8,56)
#define M1_3_1(W) R2_3_1(W,  8,56, 8,56, 8,56, 8,56)
#define N1_0_0(W) R2_0_0(W, 53,51,37, 3,21,19, 5,35)
#define N1_1_0(W) R2_1_0(W, 53,51,37, 3,21,19, 5,35)
#define N1_2_0(W) R2_2_0(W, 53,51,37, 3,21,19, 5,35)
#define N1_3_0(W) R2_3_0(W, 53,51,37, 3,21,19, 5,35)
#define N1_0_1(W) R2_0_1(W, 53,51,37, 3,21,19, 5,35)
#define N1_1_1(W) R2_1_1(W, 53,51,37, 3,21,19, 5,35)
#define N1_2_1(W) R2_2_1(W, 53,51,37, 3,21,19, 5,35)
#define N1_3_1(W) R2_3_1(W, 53,51,37, 3,21,19, 5,35)
#define M2_0_0(W) R2_0_0(W, 14,34,46, 2,14,34,46, 2)
#define M2_1_0(W) R2_1_0(W, 14,34,46, 2,14,34,46, 2)
#define M2_2_0(W) R2_2_0(W, 14,34,46, 2,14,34,46, 2)
#define M2_3_0(W) R2_3_0(W, 14,34,46, 2,14,34,46, 2)
#define M2_0_1(W) R2_0_1(W, 14,34,46, 2,14,34,46, 2)
#define M2_1_1(W) R2_1_1(W, 14,34,46, 2,14,34,46, 2)
#define M2_2_1(W) R2_2_1(W, 14,34,46, 2,14,34,46, 2)
#define M2_3_1(W) R2_3_1(W, 14,34,46, 2,14,34,46, 2)
#define N2_0_0(W) R2_0_0(W,  1, 7,49,23,33,39,17,55)
#define N2_1_0(W) R2_1_0(W,  1, 7,49,23,33,39,17,55)
#define N2_2_0(W) R2_2_0(W,  1, 7,49,23,33,39,17,55)
#define N2_3_0(W) R2_3_0(W,  1, 7,49,23,33,39,17,55)
#define N2_0_1(W) R2_0_1(W,  1, 7,49,23,33,39,17,55)
#define N2_1_1(W) R2_1_1(W,  1, 7,49,23,33,39,17,55)
#define N2_2_1(W) R2_2_1(W,  1, 7,49,23,33,39,17,55)
#define N2_3_1(W) R2_3_1(W,  1, 7,49,23,33,39,17,55)

/*
*******************************************************************************
Такт
*******************************************************************************
*/

#define bashR0(i)\
	bashS(W0,W4,W8,  M1_0_0,N1_0_0,M2_0_0,N2_0_0);\
	bashS(W1,W5,W9,  M1_1_0,N1_1_0,M2_1_0,N2_1_0);\
	bashS(W2,W6,W10, M1_2_0,N1_2_0,M2_2_0,N2_2_0);\
	bashS(W3,W7,W11, M1_3_0,N1_3_0,M2_3_0,N2_3_0);\
	bashP0;\
	W11 = X2(W11, S2(c##i,0))

#define bashR1(i)\
	bashS(W0,W4,W8,  M1_0_1,N1_0_1,M2_0_1,N2_0_1);\
	bashS(W1,W5,W9,  M1_1_1,N1_1_1,M2_1_1,N2_1_1);\
	bashS(W2,W6,W10, M1_2_1,N1_2_1,M2_2_1,N2_2_1);\
	bashS(W3,W7,W11, M1_3_1,N1_3_1,M2_3_1,N2_3_1);\
	bashP1;\
	W11 = X2(W11, S2(0,c##i))

/*
*******************************************************************************
Тактовые константы
*******************************************************************************
*/

#define c1  0x3BF5080AC8BA94B1ull
#define c2  0xC1D1659C1BBD92F6ull
#define c3  0x60E8B2CE0DDEC97Bull
#define c4  0xEC5FB8FE790FBC13ull
#define c5  0xAA043DE6436706A7ull
#define c6  0x8929FF6A5E535BFDull
#define c7  0x98BF1E2C50C97550ull
#define c8  0x4C5F8F162864BAA8ull
#define c9  0x262FC78B14325D54ull
#define c10 0x1317E3C58A192EAAull
#define c11 0x098BF1E2C50C9755ull
#define c12 0xD8EE19681D669304ull
#define c13 0x6C770CB40EB34982ull
#define c14 0x363B865A0759A4C1ull
#define c15 0xC73622B47C4C0ACEull
#define c16 0x639B115A3E260567ull
#define c17 0xEDE6693460F3DA1Dull
#define c18 0xAAD8D5034F9935A0ull
#define c19 0x556C6A81A7CC9AD0ull
#define c20 0x2AB63540D3E64D68ull
#define c21 0x155B1AA069F326B4ull
#define c22 0x0AAD8D5034F9935Aull
#define c23 0x0556C6A81A7CC9ADull
#define c24 0xDE8082CD72DEBC78ull

/*
*******************************************************************************
Bash-f
*******************************************************************************
*/

#define bashF0\
	bashR0(1);\
	bashR1(2);\
	bashR0(3);\
	bashR1(4);\
	bashR0(5);\
	bashR1(6);\
	bashR0(7);\
	bashR1(8);\
	bashR0(9);\
	bashR1(10);\
	bashR0(11);\
	bashR1(12);\
	bashR0(13);\
	bashR1(14);\
	bashR0(15);\
	bashR1(16);\
	bashR0(17);\
	bashR1(18);\
	bashR0(19);\
	bashR1(20);\
	bashR0(21);\
	bashR1(22);\
	bashR0(23);\
	bashR1(24)

/*
*******************************************************************************
Bash-f на памяти, выровненной на границу 8 байт, stack не используется
*******************************************************************************
*/

static void bashF2(octet block[192], void* stack)
{
	register uint64x2_t Z1, Z2, T0, T1, T2, U0, U1, U2;
	register uint64x2_t W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11;

	ASSERT(memIsValid(block, 192));
	ASSERT(memIsAligned(block, 8));
	W0 = LOAD(block + 0);
	W1 = LOAD(block + 16);
	W2 = LOAD(block + 32);
	W3 = LOAD(block + 48);
	W4 = LOAD(block + 64);
	W5 = LOAD(block + 80);
	W6 = LOAD(block + 96);
	W7 = LOAD(block + 112);
	W8 = LOAD(block + 128);
	W9 = LOAD(block + 144);
	W10 = LOAD(block + 160);
	W11 = LOAD(block + 176);
	bashF0;
	STORE(block + 0, W0);
	STORE(block + 16, W1);
	STORE(block + 32, W2);
	STORE(block + 48, W3);
	STORE(block + 64, W4);
	STORE(block + 80, W5);
	STORE(block + 96, W6);
	STORE(block + 112, W7);
	STORE(block + 128, W8);
	STORE(block + 144, W9);
	STORE(block + 160, W10);
	STORE(block + 176, W11);
}

void bashF(octet block_unaligned[192], void* stack)
{
	octet *block_aligned = (octet*)((((uintptr_t)stack) + 7) & ~((uintptr_t)7));

	ASSERT(memIsDisjoint2(block_unaligned, 192, stack, bashF_deep()));
	memCopy(block_aligned, block_unaligned, 192);
	bashF2(block_aligned, (octet*)stack + bashF_deep());
	memCopy(block_unaligned, block_aligned, 192);
}

size_t bashF_deep()
{
	return 192 + 8;
}