Add crypto hash SM3.
[libgcrypt.git] / cipher / keccak_permute_64.h
1 /* keccak_permute_64.h - Keccak permute function (simple 64bit)
2  * Copyright (C) 2015 Jussi Kivilinna <jussi.kivilinna@iki.fi>
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* The code is based on public-domain/CC0 "keccakc1024/simple/Keccak-simple.c"
21  * implementation by Ronny Van Keer from SUPERCOP toolkit package.
22  */
23
24 /* Function that computes the Keccak-f[1600] permutation on the given state. */
25 static unsigned int
26 KECCAK_F1600_PERMUTE_FUNC_NAME(KECCAK_STATE *hd)
27 {
28   const u64 *round_consts = _gcry_keccak_round_consts_64bit;
29   const u64 *round_consts_end = _gcry_keccak_round_consts_64bit + 24;
30   u64 Aba, Abe, Abi, Abo, Abu;
31   u64 Aga, Age, Agi, Ago, Agu;
32   u64 Aka, Ake, Aki, Ako, Aku;
33   u64 Ama, Ame, Ami, Amo, Amu;
34   u64 Asa, Ase, Asi, Aso, Asu;
35   u64 BCa, BCe, BCi, BCo, BCu;
36   u64 Da, De, Di, Do, Du;
37   u64 Eba, Ebe, Ebi, Ebo, Ebu;
38   u64 Ega, Ege, Egi, Ego, Egu;
39   u64 Eka, Eke, Eki, Eko, Eku;
40   u64 Ema, Eme, Emi, Emo, Emu;
41   u64 Esa, Ese, Esi, Eso, Esu;
42   u64 *state = hd->u.state64;
43
44   Aba = state[0];
45   Abe = state[1];
46   Abi = state[2];
47   Abo = state[3];
48   Abu = state[4];
49   Aga = state[5];
50   Age = state[6];
51   Agi = state[7];
52   Ago = state[8];
53   Agu = state[9];
54   Aka = state[10];
55   Ake = state[11];
56   Aki = state[12];
57   Ako = state[13];
58   Aku = state[14];
59   Ama = state[15];
60   Ame = state[16];
61   Ami = state[17];
62   Amo = state[18];
63   Amu = state[19];
64   Asa = state[20];
65   Ase = state[21];
66   Asi = state[22];
67   Aso = state[23];
68   Asu = state[24];
69
70   do
71     {
72       /* prepareTheta */
73       BCa = Aba ^ Aga ^ Aka ^ Ama ^ Asa;
74       BCe = Abe ^ Age ^ Ake ^ Ame ^ Ase;
75       BCi = Abi ^ Agi ^ Aki ^ Ami ^ Asi;
76       BCo = Abo ^ Ago ^ Ako ^ Amo ^ Aso;
77       BCu = Abu ^ Agu ^ Aku ^ Amu ^ Asu;
78
79       /* thetaRhoPiChiIotaPrepareTheta(round  , A, E) */
80       Da = BCu ^ ROL64(BCe, 1);
81       De = BCa ^ ROL64(BCi, 1);
82       Di = BCe ^ ROL64(BCo, 1);
83       Do = BCi ^ ROL64(BCu, 1);
84       Du = BCo ^ ROL64(BCa, 1);
85
86       Aba ^= Da;
87       BCa = Aba;
88       Age ^= De;
89       BCe = ROL64(Age, 44);
90       Aki ^= Di;
91       BCi = ROL64(Aki, 43);
92       Amo ^= Do;
93       BCo = ROL64(Amo, 21);
94       Asu ^= Du;
95       BCu = ROL64(Asu, 14);
96       Eba = BCa ^ ANDN64(BCe, BCi);
97       Eba ^= *(round_consts++);
98       Ebe = BCe ^ ANDN64(BCi, BCo);
99       Ebi = BCi ^ ANDN64(BCo, BCu);
100       Ebo = BCo ^ ANDN64(BCu, BCa);
101       Ebu = BCu ^ ANDN64(BCa, BCe);
102
103       Abo ^= Do;
104       BCa = ROL64(Abo, 28);
105       Agu ^= Du;
106       BCe = ROL64(Agu, 20);
107       Aka ^= Da;
108       BCi = ROL64(Aka, 3);
109       Ame ^= De;
110       BCo = ROL64(Ame, 45);
111       Asi ^= Di;
112       BCu = ROL64(Asi, 61);
113       Ega = BCa ^ ANDN64(BCe, BCi);
114       Ege = BCe ^ ANDN64(BCi, BCo);
115       Egi = BCi ^ ANDN64(BCo, BCu);
116       Ego = BCo ^ ANDN64(BCu, BCa);
117       Egu = BCu ^ ANDN64(BCa, BCe);
118
119       Abe ^= De;
120       BCa = ROL64(Abe, 1);
121       Agi ^= Di;
122       BCe = ROL64(Agi, 6);
123       Ako ^= Do;
124       BCi = ROL64(Ako, 25);
125       Amu ^= Du;
126       BCo = ROL64(Amu, 8);
127       Asa ^= Da;
128       BCu = ROL64(Asa, 18);
129       Eka = BCa ^ ANDN64(BCe, BCi);
130       Eke = BCe ^ ANDN64(BCi, BCo);
131       Eki = BCi ^ ANDN64(BCo, BCu);
132       Eko = BCo ^ ANDN64(BCu, BCa);
133       Eku = BCu ^ ANDN64(BCa, BCe);
134
135       Abu ^= Du;
136       BCa = ROL64(Abu, 27);
137       Aga ^= Da;
138       BCe = ROL64(Aga, 36);
139       Ake ^= De;
140       BCi = ROL64(Ake, 10);
141       Ami ^= Di;
142       BCo = ROL64(Ami, 15);
143       Aso ^= Do;
144       BCu = ROL64(Aso, 56);
145       Ema = BCa ^ ANDN64(BCe, BCi);
146       Eme = BCe ^ ANDN64(BCi, BCo);
147       Emi = BCi ^ ANDN64(BCo, BCu);
148       Emo = BCo ^ ANDN64(BCu, BCa);
149       Emu = BCu ^ ANDN64(BCa, BCe);
150
151       Abi ^= Di;
152       BCa = ROL64(Abi, 62);
153       Ago ^= Do;
154       BCe = ROL64(Ago, 55);
155       Aku ^= Du;
156       BCi = ROL64(Aku, 39);
157       Ama ^= Da;
158       BCo = ROL64(Ama, 41);
159       Ase ^= De;
160       BCu = ROL64(Ase, 2);
161       Esa = BCa ^ ANDN64(BCe, BCi);
162       Ese = BCe ^ ANDN64(BCi, BCo);
163       Esi = BCi ^ ANDN64(BCo, BCu);
164       Eso = BCo ^ ANDN64(BCu, BCa);
165       Esu = BCu ^ ANDN64(BCa, BCe);
166
167       /* prepareTheta */
168       BCa = Eba ^ Ega ^ Eka ^ Ema ^ Esa;
169       BCe = Ebe ^ Ege ^ Eke ^ Eme ^ Ese;
170       BCi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi;
171       BCo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso;
172       BCu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu;
173
174       /* thetaRhoPiChiIotaPrepareTheta(round+1, E, A) */
175       Da = BCu ^ ROL64(BCe, 1);
176       De = BCa ^ ROL64(BCi, 1);
177       Di = BCe ^ ROL64(BCo, 1);
178       Do = BCi ^ ROL64(BCu, 1);
179       Du = BCo ^ ROL64(BCa, 1);
180
181       Eba ^= Da;
182       BCa = Eba;
183       Ege ^= De;
184       BCe = ROL64(Ege, 44);
185       Eki ^= Di;
186       BCi = ROL64(Eki, 43);
187       Emo ^= Do;
188       BCo = ROL64(Emo, 21);
189       Esu ^= Du;
190       BCu = ROL64(Esu, 14);
191       Aba = BCa ^ ANDN64(BCe, BCi);
192       Aba ^= *(round_consts++);
193       Abe = BCe ^ ANDN64(BCi, BCo);
194       Abi = BCi ^ ANDN64(BCo, BCu);
195       Abo = BCo ^ ANDN64(BCu, BCa);
196       Abu = BCu ^ ANDN64(BCa, BCe);
197
198       Ebo ^= Do;
199       BCa = ROL64(Ebo, 28);
200       Egu ^= Du;
201       BCe = ROL64(Egu, 20);
202       Eka ^= Da;
203       BCi = ROL64(Eka, 3);
204       Eme ^= De;
205       BCo = ROL64(Eme, 45);
206       Esi ^= Di;
207       BCu = ROL64(Esi, 61);
208       Aga = BCa ^ ANDN64(BCe, BCi);
209       Age = BCe ^ ANDN64(BCi, BCo);
210       Agi = BCi ^ ANDN64(BCo, BCu);
211       Ago = BCo ^ ANDN64(BCu, BCa);
212       Agu = BCu ^ ANDN64(BCa, BCe);
213
214       Ebe ^= De;
215       BCa = ROL64(Ebe, 1);
216       Egi ^= Di;
217       BCe = ROL64(Egi, 6);
218       Eko ^= Do;
219       BCi = ROL64(Eko, 25);
220       Emu ^= Du;
221       BCo = ROL64(Emu, 8);
222       Esa ^= Da;
223       BCu = ROL64(Esa, 18);
224       Aka = BCa ^ ANDN64(BCe, BCi);
225       Ake = BCe ^ ANDN64(BCi, BCo);
226       Aki = BCi ^ ANDN64(BCo, BCu);
227       Ako = BCo ^ ANDN64(BCu, BCa);
228       Aku = BCu ^ ANDN64(BCa, BCe);
229
230       Ebu ^= Du;
231       BCa = ROL64(Ebu, 27);
232       Ega ^= Da;
233       BCe = ROL64(Ega, 36);
234       Eke ^= De;
235       BCi = ROL64(Eke, 10);
236       Emi ^= Di;
237       BCo = ROL64(Emi, 15);
238       Eso ^= Do;
239       BCu = ROL64(Eso, 56);
240       Ama = BCa ^ ANDN64(BCe, BCi);
241       Ame = BCe ^ ANDN64(BCi, BCo);
242       Ami = BCi ^ ANDN64(BCo, BCu);
243       Amo = BCo ^ ANDN64(BCu, BCa);
244       Amu = BCu ^ ANDN64(BCa, BCe);
245
246       Ebi ^= Di;
247       BCa = ROL64(Ebi, 62);
248       Ego ^= Do;
249       BCe = ROL64(Ego, 55);
250       Eku ^= Du;
251       BCi = ROL64(Eku, 39);
252       Ema ^= Da;
253       BCo = ROL64(Ema, 41);
254       Ese ^= De;
255       BCu = ROL64(Ese, 2);
256       Asa = BCa ^ ANDN64(BCe, BCi);
257       Ase = BCe ^ ANDN64(BCi, BCo);
258       Asi = BCi ^ ANDN64(BCo, BCu);
259       Aso = BCo ^ ANDN64(BCu, BCa);
260       Asu = BCu ^ ANDN64(BCa, BCe);
261     }
262   while (round_consts < round_consts_end);
263
264   state[0] = Aba;
265   state[1] = Abe;
266   state[2] = Abi;
267   state[3] = Abo;
268   state[4] = Abu;
269   state[5] = Aga;
270   state[6] = Age;
271   state[7] = Agi;
272   state[8] = Ago;
273   state[9] = Agu;
274   state[10] = Aka;
275   state[11] = Ake;
276   state[12] = Aki;
277   state[13] = Ako;
278   state[14] = Aku;
279   state[15] = Ama;
280   state[16] = Ame;
281   state[17] = Ami;
282   state[18] = Amo;
283   state[19] = Amu;
284   state[20] = Asa;
285   state[21] = Ase;
286   state[22] = Asi;
287   state[23] = Aso;
288   state[24] = Asu;
289
290   return sizeof(void *) * 4 + sizeof(u64) * 12 * 5;
291 }
292
293 static unsigned int
294 KECCAK_F1600_ABSORB_FUNC_NAME(KECCAK_STATE *hd, int pos, const byte *lanes,
295                               unsigned int nlanes, int blocklanes)
296 {
297   unsigned int burn = 0;
298
299   while (nlanes)
300     {
301       switch (blocklanes)
302         {
303         case 21:
304           /* SHAKE128 */
305           while (pos == 0 && nlanes >= 21)
306             {
307               nlanes -= 21;
308               absorb_lanes64_8(&hd->u.state64[0], lanes); lanes += 8 * 8;
309               absorb_lanes64_8(&hd->u.state64[8], lanes); lanes += 8 * 8;
310               absorb_lanes64_4(&hd->u.state64[16], lanes); lanes += 8 * 4;
311               absorb_lanes64_1(&hd->u.state64[20], lanes); lanes += 8 * 1;
312
313               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
314             }
315           break;
316
317         case 18:
318           /* SHA3-224 */
319           while (pos == 0 && nlanes >= 18)
320             {
321               nlanes -= 18;
322               absorb_lanes64_8(&hd->u.state64[0], lanes); lanes += 8 * 8;
323               absorb_lanes64_8(&hd->u.state64[8], lanes); lanes += 8 * 8;
324               absorb_lanes64_2(&hd->u.state64[16], lanes); lanes += 8 * 2;
325
326               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
327             }
328           break;
329
330         case 17:
331           /* SHA3-256 & SHAKE256 */
332           while (pos == 0 && nlanes >= 17)
333             {
334               nlanes -= 17;
335               absorb_lanes64_8(&hd->u.state64[0], lanes); lanes += 8 * 8;
336               absorb_lanes64_8(&hd->u.state64[8], lanes); lanes += 8 * 8;
337               absorb_lanes64_1(&hd->u.state64[16], lanes); lanes += 8 * 1;
338
339               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
340             }
341           break;
342
343         case 13:
344           /* SHA3-384 */
345           while (pos == 0 && nlanes >= 13)
346             {
347               nlanes -= 13;
348               absorb_lanes64_8(&hd->u.state64[0], lanes); lanes += 8 * 8;
349               absorb_lanes64_4(&hd->u.state64[8], lanes); lanes += 8 * 4;
350               absorb_lanes64_1(&hd->u.state64[12], lanes); lanes += 8 * 1;
351
352               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
353             }
354           break;
355
356         case 9:
357           /* SHA3-512 */
358           while (pos == 0 && nlanes >= 9)
359             {
360               nlanes -= 9;
361               absorb_lanes64_8(&hd->u.state64[0], lanes); lanes += 8 * 8;
362               absorb_lanes64_1(&hd->u.state64[8], lanes); lanes += 8 * 1;
363
364               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
365             }
366           break;
367         }
368
369       while (nlanes)
370         {
371           hd->u.state64[pos] ^= buf_get_le64(lanes);
372           lanes += 8;
373           nlanes--;
374
375           if (++pos == blocklanes)
376             {
377               burn = KECCAK_F1600_PERMUTE_FUNC_NAME(hd);
378               pos = 0;
379               break;
380             }
381         }
382     }
383
384   return burn;
385 }