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 }