camellia-set-encrypt-key.c

   1 /* camellia-set-encrypt-key.c
   2  *
   3  * Key setup for the camellia block cipher.
   4  */
   5 /*
   6  * Copyright (C) 2006,2007
   7  * NTT (Nippon Telegraph and Telephone Corporation).
   8  *
   9  * Copyright (C) 2010 Niels Möller
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  24  */
  25
  26 /*
  27  * Algorithm Specification
  28  *  http://info.isl.ntt.co.jp/crypt/eng/camellia/specifications.html
  29  */
  30
  31 /* Based on camellia.c ver 1.2.0, see
  32    http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/camellia-LGPL-1.2.0.tar.gz.
  33  */
  34 #if HAVE_CONFIG_H
  35 # include "config.h"
  36 #endif
  37
  38 #include <assert.h>
  39
  40 #include "camellia-internal.h"
  41
  42 #include "macros.h"
  43
  44 /* key constants */
  45
  46 #define SIGMA1 0xA09E667F3BCC908BULL
  47 #define SIGMA2 0xB67AE8584CAA73B2ULL
  48 #define SIGMA3 0xC6EF372FE94F82BEULL
  49 #define SIGMA4 0x54FF53A5F1D36F1CULL
  50 #define SIGMA5 0x10E527FADE682D1DULL
  51 #define SIGMA6 0xB05688C2B3E6C1FDULL
  52
  53 #define CAMELLIA_SP1110(INDEX) (_nettle_camellia_table.sp1110[(int)(INDEX)])
  54 #define CAMELLIA_SP0222(INDEX) (_nettle_camellia_table.sp0222[(int)(INDEX)])
  55 #define CAMELLIA_SP3033(INDEX) (_nettle_camellia_table.sp3033[(int)(INDEX)])
  56 #define CAMELLIA_SP4404(INDEX) (_nettle_camellia_table.sp4404[(int)(INDEX)])
  57
  58 #define CAMELLIA_F(x, k, y) do {                \
  59     uint32_t __yl, __yr;                        \
  60     uint64_t __i = (x) ^ (k);                   \
  61     __yl                                        \
  62       = CAMELLIA_SP1110( __i & 0xff)            \
  63       ^ CAMELLIA_SP0222((__i >> 24) & 0xff)     \
  64       ^ CAMELLIA_SP3033((__i >> 16) & 0xff)     \
  65       ^ CAMELLIA_SP4404((__i >> 8) & 0xff);     \
  66     __yr                                        \
  67       = CAMELLIA_SP1110( __i >> 56)             \
  68       ^ CAMELLIA_SP0222((__i >> 48) & 0xff)     \
  69       ^ CAMELLIA_SP3033((__i >> 40) & 0xff)     \
  70       ^ CAMELLIA_SP4404((__i >> 32) & 0xff);    \
  71     __yl ^= __yr;                               \
  72     __yr = ROL32(24, __yr);                     \
  73     __yr ^= __yl;                               \
  74     (y) = ((uint64_t) __yl << 32) | __yr;       \
  75   } while (0)
  76
  77 #define CAMELLIA_F_HALF_INV(x) do {             \
  78     uint32_t __t, __w;                          \
  79     __t = (x) >> 32;                            \
  80     __w = __t ^(x);                             \
  81     __w = ROL32(8, __w);                        \
  82     (x) = ((uint64_t) __w << 32) | (__t ^ __w); \
  83   } while (0)
  84
  85 void
  86 camellia_set_encrypt_key(struct camellia_ctx *ctx,
  87                          unsigned length, const uint8_t *key)
  88 {
  89   uint64_t k0, k1;
  90
  91   uint64_t subkey[34];
  92   uint64_t w, kw2, kw4;
  93
  94   uint32_t dw, tl, tr;
  95   unsigned i;
  96
  97   k0 = READ_UINT64(key);
  98   k1 = READ_UINT64(key +  8);
  99
 100   if (length == 16)
 101     {
 102       ctx->nkeys = 24;
 103       /**
 104        * generate KL dependent subkeys
 105        */
 106       subkey[0] = k0; subkey[1] = k1;
 107       ROL128(15, k0, k1);
 108       subkey[4] = k0; subkey[5] = k1;
 109       ROL128(30, k0, k1);
 110       subkey[10] = k0; subkey[11] = k1;
 111       ROL128(15, k0, k1);
 112       subkey[13] = k1;
 113       ROL128(17, k0, k1);
 114       subkey[16] = k0; subkey[17] = k1;
 115       ROL128(17, k0, k1);
 116       subkey[18] = k0; subkey[19] = k1;
 117       ROL128(17, k0, k1);
 118       subkey[22] = k0; subkey[23] = k1;
 119
 120       /* generate KA. D1 is k0, d2 is k1. */
 121       /* FIXME: Make notation match the spec better. */
 122       /* For the 128-bit case, KR = 0, the construction of KA reduces to:
 123
 124          D1 = KL >> 64;
 125          W = KL & MASK64;
 126          D2 = F(D1, Sigma1);
 127          W = D2 ^ W
 128          D1 = F(W, Sigma2)
 129          D2 = D2 ^ F(D1, Sigma3);
 130          D1 = D1 ^ F(D2, Sigma4);
 131          KA = (D1 << 64) | D2;
 132       */
 133       k0 = subkey[0]; w = subkey[1];
 134       CAMELLIA_F(k0, SIGMA1, k1);
 135       w ^= k1;
 136       CAMELLIA_F(w, SIGMA2, k0);
 137       CAMELLIA_F(k0, SIGMA3, w);
 138       k1 ^= w;
 139       CAMELLIA_F(k1, SIGMA4, w);
 140       k0 ^= w;
 141
 142       /* generate KA dependent subkeys */
 143       subkey[2] = k0; subkey[3] = k1;
 144       ROL128(15, k0, k1);
 145       subkey[6] = k0; subkey[7] = k1;
 146       ROL128(15, k0, k1);
 147       subkey[8] = k0; subkey[9] = k1;
 148       ROL128(15, k0, k1);
 149       subkey[12] = k0;
 150       ROL128(15, k0, k1);
 151       subkey[14] = k0; subkey[15] = k1;
 152       ROL128(34, k0, k1);
 153       subkey[20] = k0; subkey[21] = k1;
 154       ROL128(17, k0, k1);
 155       subkey[24] = k0; subkey[25] = k1;
 156     }
 157   else
 158     {
 159       uint64_t k2, k3;
 160
 161       ctx->nkeys = 32;
 162       k2 = READ_UINT64(key + 16);
 163
 164       if (length == 24)
 165         k3 = ~k2;
 166       else
 167         {
 168           assert (length == 32);
 169           k3 = READ_UINT64(key + 24);
 170         }
 171       /* generate KL dependent subkeys */
 172       subkey[0] = k0; subkey[1] = k1;
 173       ROL128(45, k0, k1);
 174       subkey[12] = k0; subkey[13] = k1;
 175       ROL128(15, k0, k1);
 176       subkey[16] = k0; subkey[17] = k1;
 177       ROL128(17, k0, k1);
 178       subkey[22] = k0; subkey[23] = k1;
 179       ROL128(34, k0, k1);
 180       subkey[30] = k0; subkey[31] = k1;
 181
 182       /* generate KR dependent subkeys */
 183       ROL128(15, k2, k3);
 184       subkey[4] = k2; subkey[5] = k3;
 185       ROL128(15, k2, k3);
 186       subkey[8] = k2; subkey[9] = k3;
 187       ROL128(30, k2, k3);
 188       subkey[18] = k2; subkey[19] = k3;
 189       ROL128(34, k2, k3);
 190       subkey[26] = k2; subkey[27] = k3;
 191       ROL128(34, k2, k3);
 192
 193       /* generate KA */
 194       /* The construction of KA is done as
 195
 196          D1 = (KL ^ KR) >> 64
 197          D2 = (KL ^ KR) & MASK64
 198          W = F(D1, SIGMA1)
 199          D2 = D2 ^ W
 200          D1 = F(D2, SIGMA2) ^ (KR >> 64)
 201          D2 = F(D1, SIGMA3) ^ W ^ (KR & MASK64)
 202          D1 = D1 ^ F(W, SIGMA2)
 203          D2 = D2 ^ F(D1, SIGMA3)
 204          D1 = D1 ^ F(D2, SIGMA4)
 205       */
 206
 207       k0 = subkey[0] ^ k2;
 208       k1 = subkey[1] ^ k3;
 209
 210       CAMELLIA_F(k0, SIGMA1, w);
 211       k1 ^= w;
 212
 213       CAMELLIA_F(k1, SIGMA2, k0);
 214       k0 ^= k2;
 215
 216       CAMELLIA_F(k0, SIGMA3, k1);
 217       k1 ^= w ^ k3;
 218
 219       CAMELLIA_F(k1, SIGMA4, w);
 220       k0 ^= w;
 221
 222       /* generate KB */
 223       k2 ^= k0; k3 ^= k1;
 224       CAMELLIA_F(k2, SIGMA5, w);
 225       k3 ^= w;
 226       CAMELLIA_F(k3, SIGMA6, w);
 227       k2 ^= w;
 228
 229       /* generate KA dependent subkeys */
 230       ROL128(15, k0, k1);
 231       subkey[6] = k0; subkey[7] = k1;
 232       ROL128(30, k0, k1);
 233       subkey[14] = k0; subkey[15] = k1;
 234       ROL128(32, k0, k1);
 235       subkey[24] = k0; subkey[25] = k1;
 236       ROL128(17, k0, k1);
 237       subkey[28] = k0; subkey[29] = k1;
 238
 239       /* generate KB dependent subkeys */
 240       subkey[2] = k2; subkey[3] = k3;
 241       ROL128(30, k2, k3);
 242       subkey[10] = k2; subkey[11] = k3;
 243       ROL128(30, k2, k3);
 244       subkey[20] = k2; subkey[21] = k3;
 245       ROL128(51, k2, k3);
 246       subkey[32] = k2; subkey[33] = k3;
 247     }
 248
 249   /* At this point, the subkey array contains the subkeys as described
 250      in the spec, 26 for short keys and 34 for large keys. */
 251
 252   /* absorb kw2 to other subkeys */
 253   kw2 = subkey[1];
 254
 255   subkey[3] ^= kw2;
 256   subkey[5] ^= kw2;
 257   subkey[7] ^= kw2;
 258   for (i = 8; i < ctx->nkeys; i += 8)
 259     {
 260       /* FIXME: gcc for x86_32 is smart enough to fetch the 32 low bits
 261          and xor the result into the 32 high bits, but it still generates
 262          worse code than for explicit 32-bit operations. */
 263       kw2 ^= (kw2 & ~subkey[i+1]) << 32;
 264       dw = (kw2 & subkey[i+1]) >> 32; kw2 ^= ROL32(1, dw);
 265
 266       subkey[i+3] ^= kw2;
 267       subkey[i+5] ^= kw2;
 268       subkey[i+7] ^= kw2;
 269     }
 270   subkey[i] ^= kw2;
 271
 272   /* absorb kw4 to other subkeys */
 273   kw4 = subkey[ctx->nkeys + 1];
 274
 275   for (i = ctx->nkeys - 8; i > 0; i -= 8)
 276     {
 277       subkey[i+6] ^= kw4;
 278       subkey[i+4] ^= kw4;
 279       subkey[i+2] ^= kw4;
 280       kw4 ^= (kw4 & ~subkey[i]) << 32;
 281       dw = (kw4 & subkey[i]) >> 32; kw4 ^= ROL32(1, dw);
 282     }
 283
 284   subkey[6] ^= kw4;
 285   subkey[4] ^= kw4;
 286   subkey[2] ^= kw4;
 287   subkey[0] ^= kw4;
 288
 289   /* key XOR is end of F-function */
 290   ctx->keys[0] = subkey[0] ^ subkey[2];
 291   ctx->keys[1] = subkey[3];
 292
 293   ctx->keys[2] = subkey[2] ^ subkey[4];
 294   ctx->keys[3] = subkey[3] ^ subkey[5];
 295   ctx->keys[4] = subkey[4] ^ subkey[6];
 296   ctx->keys[5] = subkey[5] ^ subkey[7];
 297
 298   for (i = 8; i < ctx->nkeys; i += 8)
 299     {
 300       tl = (subkey[i+2] >> 32) ^ (subkey[i+2] & ~subkey[i]);
 301       dw = tl & (subkey[i] >> 32);
 302       tr = subkey[i+2] ^ ROL32(1, dw);
 303       ctx->keys[i-2] = subkey[i-2] ^ ( ((uint64_t) tl << 32) | tr);
 304
 305       ctx->keys[i-1] = subkey[i];
 306       ctx->keys[i] = subkey[i+1];
 307
 308       tl = (subkey[i-1] >> 32) ^ (subkey[i-1] & ~subkey[i+1]);
 309       dw = tl & (subkey[i+1] >> 32);
 310       tr = subkey[i-1] ^ ROL32(1, dw);
 311       ctx->keys[i+1] = subkey[i+3] ^ ( ((uint64_t) tl << 32) | tr);
 312
 313       ctx->keys[i+2] = subkey[i+2] ^ subkey[i+4];
 314       ctx->keys[i+3] = subkey[i+3] ^ subkey[i+5];
 315       ctx->keys[i+4] = subkey[i+4] ^ subkey[i+6];
 316       ctx->keys[i+5] = subkey[i+5] ^ subkey[i+7];
 317     }
 318   ctx->keys[i-2] = subkey[i-2];
 319   ctx->keys[i-1] = subkey[i] ^ subkey[i-1];
 320
 321   for (i = 0; i < ctx->nkeys; i += 8)
 322     {
 323       /* apply the inverse of the last half of F-function */
 324       CAMELLIA_F_HALF_INV(ctx->keys[i+1]);
 325       CAMELLIA_F_HALF_INV(ctx->keys[i+2]);
 326       CAMELLIA_F_HALF_INV(ctx->keys[i+3]);
 327       CAMELLIA_F_HALF_INV(ctx->keys[i+4]);
 328       CAMELLIA_F_HALF_INV(ctx->keys[i+5]);
 329       CAMELLIA_F_HALF_INV(ctx->keys[i+6]);
 330     }
 331 }