lib/silccrypt/twofish.c

   1 /* Modified for SILC. -Pekka */
   2
   3 /* This is an independent implementation of the encryption algorithm:   */
   4 /*                                                                      */
   5 /*         Twofish by Bruce Schneier and colleagues                     */
   6 /*                                                                      */
   7 /* which is a candidate algorithm in the Advanced Encryption Standard   */
   8 /* programme of the US National Institute of Standards and Technology.  */
   9 /*                                                                      */
  10 /* Copyright in this implementation is held by Dr B R Gladman but I     */
  11 /* hereby give permission for its free direct or derivative use subject */
  12 /* to acknowledgment of its origin and compliance with any conditions   */
  13 /* that the originators of t he algorithm place on its exploitation.     */
  14 /*                                                                      */
  15 /* My thanks to Doug Whiting and Niels Ferguson for comments that led   */
  16 /* to improvements in this implementation.                              */
  17 /*                                                                      */
  18 /* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999     */
  19
  20 /* Timing data for Twofish (twofish.c)
  21
  22 128 bit key:
  23 Key Setup:    8414 cycles
  24 Encrypt:       376 cycles =    68.1 mbits/sec
  25 Decrypt:       374 cycles =    68.4 mbits/sec
  26 Mean:          375 cycles =    68.3 mbits/sec
  27
  28 192 bit key:
  29 Key Setup:   11628 cycles
  30 Encrypt:       376 cycles =    68.1 mbits/sec
  31 Decrypt:       374 cycles =    68.4 mbits/sec
  32 Mean:          375 cycles =    68.3 mbits/sec
  33
  34 256 bit key:
  35 Key Setup:   15457 cycles
  36 Encrypt:       381 cycles =    67.2 mbits/sec
  37 Decrypt:       374 cycles =    68.4 mbits/sec
  38 Mean:          378 cycles =    67.8 mbits/sec
  39
  40 */
  41
  42 #include "silc.h"
  43 #include "twofish_internal.h"
  44 #include "twofish.h"
  45
  46 /*
  47  * SILC Crypto API for Twofish
  48  */
  49
  50 /* Sets the key for the cipher. */
  51
  52 SILC_CIPHER_API_SET_KEY(twofish)
  53 {
  54   SilcUInt32 k[8];
  55
  56   SILC_GET_WORD_KEY(key, k, keylen);
  57   twofish_set_key((TwofishContext *)context, k, keylen);
  58
  59   return TRUE;
  60 }
  61
  62 /* Sets IV for the cipher. */
  63
  64 SILC_CIPHER_API_SET_IV(twofish)
  65 {
  66   if (cipher->mode == SILC_CIPHER_MODE_CTR) {
  67     TwofishContext *twofish = context;
  68
  69     /* Starts new block. */
  70     twofish->padlen = 0;
  71   }
  72 }
  73
  74 /* Returns the size of the cipher context. */
  75
  76 SILC_CIPHER_API_CONTEXT_LEN(twofish)
  77 {
  78   return sizeof(TwofishContext);
  79 }
  80
  81 /* Encrypts with the cipher. Source and destination buffers maybe one
  82    and same. */
  83
  84 SILC_CIPHER_API_ENCRYPT(twofish)
  85 {
  86   TwofishContext *twofish = context;
  87   SilcUInt32 tmp[4], ctr[4];
  88   int i;
  89
  90   switch (cipher->mode) {
  91
  92   case SILC_CIPHER_MODE_CBC:
  93     SILC_ASSERT((len & (16 - 1)) == 0);
  94     if (len & (16 - 1))
  95       return FALSE;
  96     SILC_CBC_GET_IV(tmp, iv);
  97
  98     SILC_CBC_ENC_PRE(tmp, src);
  99     twofish_encrypt(twofish, tmp, tmp);
 100     SILC_CBC_ENC_POST(tmp, dst, src);
 101
 102     for (i = 16; i < len; i += 16) {
 103       SILC_CBC_ENC_PRE(tmp, src);
 104       twofish_encrypt(twofish, tmp, tmp);
 105       SILC_CBC_ENC_POST(tmp, dst, src);
 106     }
 107
 108     SILC_CBC_PUT_IV(tmp, iv);
 109     break;
 110
 111   case SILC_CIPHER_MODE_CTR:
 112     SILC_GET32_MSB(ctr[0], iv);
 113     SILC_GET32_MSB(ctr[1], iv + 4);
 114     SILC_GET32_MSB(ctr[2], iv + 8);
 115     SILC_GET32_MSB(ctr[3], iv + 12);
 116
 117     i = twofish->padlen;
 118     if (!i)
 119       i = 16;
 120
 121     while (len-- > 0) {
 122       if (i == 16) {
 123         if (++ctr[3] == 0)
 124           if (++ctr[2] == 0)
 125             if (++ctr[1] == 0)
 126               ++ctr[0];
 127
 128         tmp[0] = SILC_SWAB_32(ctr[0]);
 129         tmp[1] = SILC_SWAB_32(ctr[1]);
 130         tmp[2] = SILC_SWAB_32(ctr[2]);
 131         tmp[3] = SILC_SWAB_32(ctr[3]);
 132
 133         twofish_encrypt(twofish, tmp, tmp);
 134
 135         SILC_PUT32_LSB(tmp[0], iv);
 136         SILC_PUT32_LSB(tmp[1], iv + 4);
 137         SILC_PUT32_LSB(tmp[2], iv + 8);
 138         SILC_PUT32_LSB(tmp[3], iv + 12);
 139         i = 0;
 140       }
 141       *dst++ = *src++ ^ iv[i++];
 142     }
 143     twofish->padlen = i;
 144
 145     SILC_PUT32_MSB(ctr[0], iv);
 146     SILC_PUT32_MSB(ctr[1], iv + 4);
 147     SILC_PUT32_MSB(ctr[2], iv + 8);
 148     SILC_PUT32_MSB(ctr[3], iv + 12);
 149     break;
 150
 151   default:
 152     return FALSE;
 153   }
 154
 155   return TRUE;
 156 }
 157
 158 /* Decrypts with the cipher. Source and destination buffers maybe one
 159    and same. */
 160
 161 SILC_CIPHER_API_DECRYPT(twofish)
 162 {
 163   SilcUInt32 tmp[4], tmp2[4], tiv[4];
 164   int i;
 165
 166   switch (cipher->mode) {
 167
 168   case SILC_CIPHER_MODE_CBC:
 169     if (len & (16 - 1))
 170       return FALSE;
 171
 172     SILC_CBC_GET_IV(tiv, iv);
 173
 174     SILC_CBC_DEC_PRE(tmp, src);
 175     twofish_decrypt((TwofishContext *)context, tmp, tmp2);
 176     SILC_CBC_DEC_POST(tmp2, dst, src, tmp, tiv);
 177
 178     for (i = 16; i < len; i += 16) {
 179       SILC_CBC_DEC_PRE(tmp, src);
 180       twofish_decrypt((TwofishContext *)context, tmp, tmp2);
 181       SILC_CBC_DEC_POST(tmp2, dst, src, tmp, tiv);
 182     }
 183
 184     SILC_CBC_PUT_IV(tiv, iv);
 185
 186   case SILC_CIPHER_MODE_CTR:
 187     return silc_twofish_encrypt(cipher, context, src, dst, len, iv);
 188     break;
 189
 190   default:
 191     return FALSE;
 192   }
 193
 194   return TRUE;
 195 }
 196
 197 #if 0
 198 #define Q_TABLES
 199 #define M_TABLE
 200 #define MK_TABLE
 201 #define ONE_STEP
 202 #endif
 203
 204 /* finite field arithmetic for GF(2**8) with the modular    */
 205 /* polynomial x^8 + x^6 + x^5 + x^3 + 1 (0x169)             */
 206
 207 #define G_M 0x0169
 208
 209 u1byte  tab_5b[4] = { 0, G_M >> 2, G_M >> 1, (G_M >> 1) ^ (G_M >> 2) };
 210 u1byte  tab_ef[4] = { 0, (G_M >> 1) ^ (G_M >> 2), G_M >> 1, G_M >> 2 };
 211
 212 #define ffm_01(x)    (x)
 213 #define ffm_5b(x)   ((x) ^ ((x) >> 2) ^ tab_5b[(x) & 3])
 214 #define ffm_ef(x)   ((x) ^ ((x) >> 1) ^ ((x) >> 2) ^ tab_ef[(x) & 3])
 215
 216 u1byte ror4[16] = { 0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15 };
 217 u1byte ashx[16] = { 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 5, 14, 7 };
 218
 219 u1byte qt0[2][16] =
 220 {   { 8, 1, 7, 13, 6, 15, 3, 2, 0, 11, 5, 9, 14, 12, 10, 4 },
 221     { 2, 8, 11, 13, 15, 7, 6, 14, 3, 1, 9, 4, 0, 10, 12, 5 }
 222 };
 223
 224 u1byte qt1[2][16] =
 225 {   { 14, 12, 11, 8, 1, 2, 3, 5, 15, 4, 10, 6, 7, 0, 9, 13 },
 226     { 1, 14, 2, 11, 4, 12, 3, 7, 6, 13, 10, 5, 15, 9, 0, 8 }
 227 };
 228
 229 u1byte qt2[2][16] =
 230 {   { 11, 10, 5, 14, 6, 13, 9, 0, 12, 8, 15, 3, 2, 4, 7, 1 },
 231     { 4, 12, 7, 5, 1, 6, 9, 10, 0, 14, 13, 8, 2, 11, 3, 15 }
 232 };
 233
 234 u1byte qt3[2][16] =
 235 {   { 13, 7, 15, 4, 1, 2, 6, 14, 9, 11, 3, 0, 8, 5, 12, 10 },
 236     { 11, 9, 5, 1, 12, 3, 13, 14, 6, 4, 7, 15, 2, 0, 8, 10 }
 237 };
 238
 239 u1byte qp(const u4byte n, const u1byte x)
 240 {   u1byte  a0, a1, a2, a3, a4, b0, b1, b2, b3, b4;
 241
 242     a0 = x >> 4; b0 = x & 15;
 243     a1 = a0 ^ b0; b1 = ror4[b0] ^ ashx[a0];
 244     a2 = qt0[n][a1]; b2 = qt1[n][b1];
 245     a3 = a2 ^ b2; b3 = ror4[b2] ^ ashx[a2];
 246     a4 = qt2[n][a3]; b4 = qt3[n][b3];
 247     return (b4 << 4) | a4;
 248 }
 249
 250 #ifdef  Q_TABLES
 251
 252 u4byte  qt_gen = 0;
 253 u1byte  q_tab[2][256];
 254
 255 #define q(n,x)  q_tab[n][x]
 256
 257 void gen_qtab(void)
 258 {   u4byte  i;
 259
 260     for(i = 0; i < 256; ++i)
 261     {
 262         q(0,i) = qp(0, (u1byte)i);
 263         q(1,i) = qp(1, (u1byte)i);
 264     }
 265 }
 266
 267 #else
 268
 269 #define q(n,x)  qp(n, x)
 270
 271 #endif
 272
 273 #ifdef  M_TABLE
 274
 275 u4byte  mt_gen = 0;
 276 u4byte  m_tab[4][256];
 277
 278 void gen_mtab(void)
 279 {   u4byte  i, f01, f5b, fef;
 280
 281     for(i = 0; i < 256; ++i)
 282     {
 283         f01 = q(1,i); f5b = ffm_5b(f01); fef = ffm_ef(f01);
 284         m_tab[0][i] = f01 + (f5b << 8) + (fef << 16) + (fef << 24);
 285         m_tab[2][i] = f5b + (fef << 8) + (f01 << 16) + (fef << 24);
 286
 287         f01 = q(0,i); f5b = ffm_5b(f01); fef = ffm_ef(f01);
 288         m_tab[1][i] = fef + (fef << 8) + (f5b << 16) + (f01 << 24);
 289         m_tab[3][i] = f5b + (f01 << 8) + (fef << 16) + (f5b << 24);
 290     }
 291 }
 292
 293 #define mds(n,x)    m_tab[n][x]
 294
 295 #else
 296
 297 #define fm_00   ffm_01
 298 #define fm_10   ffm_5b
 299 #define fm_20   ffm_ef
 300 #define fm_30   ffm_ef
 301 #define q_0(x)  q(1,x)
 302
 303 #define fm_01   ffm_ef
 304 #define fm_11   ffm_ef
 305 #define fm_21   ffm_5b
 306 #define fm_31   ffm_01
 307 #define q_1(x)  q(0,x)
 308
 309 #define fm_02   ffm_5b
 310 #define fm_12   ffm_ef
 311 #define fm_22   ffm_01
 312 #define fm_32   ffm_ef
 313 #define q_2(x)  q(1,x)
 314
 315 #define fm_03   ffm_5b
 316 #define fm_13   ffm_01
 317 #define fm_23   ffm_ef
 318 #define fm_33   ffm_5b
 319 #define q_3(x)  q(0,x)
 320
 321 #define f_0(n,x)    ((u4byte)fm_0##n(x))
 322 #define f_1(n,x)    ((u4byte)fm_1##n(x) << 8)
 323 #define f_2(n,x)    ((u4byte)fm_2##n(x) << 16)
 324 #define f_3(n,x)    ((u4byte)fm_3##n(x) << 24)
 325
 326 #define mds(n,x)    f_0(n,q_##n(x)) ^ f_1(n,q_##n(x)) ^ f_2(n,q_##n(x)) ^ f_3(n,q_##n(x))
 327
 328 #endif
 329
 330 u4byte h_fun(TwofishContext *ctx, const u4byte x, const u4byte key[])
 331 {   u4byte  b0, b1, b2, b3;
 332
 333 #ifndef M_TABLE
 334     u4byte  m5b_b0, m5b_b1, m5b_b2, m5b_b3;
 335     u4byte  mef_b0, mef_b1, mef_b2, mef_b3;
 336 #endif
 337
 338     b0 = byte(x, 0); b1 = byte(x, 1); b2 = byte(x, 2); b3 = byte(x, 3);
 339
 340     switch(ctx->k_len)
 341     {
 342     case 4: b0 = q(1, b0) ^ byte(key[3],0);
 343             b1 = q(0, b1) ^ byte(key[3],1);
 344             b2 = q(0, b2) ^ byte(key[3],2);
 345             b3 = q(1, b3) ^ byte(key[3],3);
 346     case 3: b0 = q(1, b0) ^ byte(key[2],0);
 347             b1 = q(1, b1) ^ byte(key[2],1);
 348             b2 = q(0, b2) ^ byte(key[2],2);
 349             b3 = q(0, b3) ^ byte(key[2],3);
 350     case 2: b0 = q(0,q(0,b0) ^ byte(key[1],0)) ^ byte(key[0],0);
 351             b1 = q(0,q(1,b1) ^ byte(key[1],1)) ^ byte(key[0],1);
 352             b2 = q(1,q(0,b2) ^ byte(key[1],2)) ^ byte(key[0],2);
 353             b3 = q(1,q(1,b3) ^ byte(key[1],3)) ^ byte(key[0],3);
 354     }
 355 #ifdef  M_TABLE
 356
 357     return  mds(0, b0) ^ mds(1, b1) ^ mds(2, b2) ^ mds(3, b3);
 358
 359 #else
 360
 361     b0 = q(1, b0); b1 = q(0, b1); b2 = q(1, b2); b3 = q(0, b3);
 362     m5b_b0 = ffm_5b(b0); m5b_b1 = ffm_5b(b1); m5b_b2 = ffm_5b(b2); m5b_b3 = ffm_5b(b3);
 363     mef_b0 = ffm_ef(b0); mef_b1 = ffm_ef(b1); mef_b2 = ffm_ef(b2); mef_b3 = ffm_ef(b3);
 364     b0 ^= mef_b1 ^ m5b_b2 ^ m5b_b3; b3 ^= m5b_b0 ^ mef_b1 ^ mef_b2;
 365     b2 ^= mef_b0 ^ m5b_b1 ^ mef_b3; b1 ^= mef_b0 ^ mef_b2 ^ m5b_b3;
 366
 367     return b0 | (b3 << 8) | (b2 << 16) | (b1 << 24);
 368
 369 #endif
 370 }
 371
 372 #ifdef  MK_TABLE
 373
 374 #ifdef  ONE_STEP
 375 u4byte  mk_tab[4][256];
 376 #else
 377 u1byte  sb[4][256];
 378 #endif
 379
 380 #define q20(x)  q(0,q(0,x) ^ byte(key[1],0)) ^ byte(key[0],0)
 381 #define q21(x)  q(0,q(1,x) ^ byte(key[1],1)) ^ byte(key[0],1)
 382 #define q22(x)  q(1,q(0,x) ^ byte(key[1],2)) ^ byte(key[0],2)
 383 #define q23(x)  q(1,q(1,x) ^ byte(key[1],3)) ^ byte(key[0],3)
 384
 385 #define q30(x)  q(0,q(0,q(1, x) ^ byte(key[2],0)) ^ byte(key[1],0)) ^ byte(key[0],0)
 386 #define q31(x)  q(0,q(1,q(1, x) ^ byte(key[2],1)) ^ byte(key[1],1)) ^ byte(key[0],1)
 387 #define q32(x)  q(1,q(0,q(0, x) ^ byte(key[2],2)) ^ byte(key[1],2)) ^ byte(key[0],2)
 388 #define q33(x)  q(1,q(1,q(0, x) ^ byte(key[2],3)) ^ byte(key[1],3)) ^ byte(key[0],3)
 389
 390 #define q40(x)  q(0,q(0,q(1, q(1, x) ^ byte(key[3],0)) ^ byte(key[2],0)) ^ byte(key[1],0)) ^ byte(key[0],0)
 391 #define q41(x)  q(0,q(1,q(1, q(0, x) ^ byte(key[3],1)) ^ byte(key[2],1)) ^ byte(key[1],1)) ^ byte(key[0],1)
 392 #define q42(x)  q(1,q(0,q(0, q(0, x) ^ byte(key[3],2)) ^ byte(key[2],2)) ^ byte(key[1],2)) ^ byte(key[0],2)
 393 #define q43(x)  q(1,q(1,q(0, q(1, x) ^ byte(key[3],3)) ^ byte(key[2],3)) ^ byte(key[1],3)) ^ byte(key[0],3)
 394
 395 void gen_mk_tab(TwofishContext *ctx, u4byte key[])
 396 {   u4byte  i;
 397     u1byte  by;
 398
 399     switch(ctx->k_len)
 400     {
 401     case 2: for(i = 0; i < 256; ++i)
 402             {
 403                 by = (u1byte)i;
 404 #ifdef ONE_STEP
 405                 mk_tab[0][i] = mds(0, q20(by)); mk_tab[1][i] = mds(1, q21(by));
 406                 mk_tab[2][i] = mds(2, q22(by)); mk_tab[3][i] = mds(3, q23(by));
 407 #else
 408                 sb[0][i] = q20(by); sb[1][i] = q21(by);
 409                 sb[2][i] = q22(by); sb[3][i] = q23(by);
 410 #endif
 411             }
 412             break;
 413
 414     case 3: for(i = 0; i < 256; ++i)
 415             {
 416                 by = (u1byte)i;
 417 #ifdef ONE_STEP
 418                 mk_tab[0][i] = mds(0, q30(by)); mk_tab[1][i] = mds(1, q31(by));
 419                 mk_tab[2][i] = mds(2, q32(by)); mk_tab[3][i] = mds(3, q33(by));
 420 #else
 421                 sb[0][i] = q30(by); sb[1][i] = q31(by);
 422                 sb[2][i] = q32(by); sb[3][i] = q33(by);
 423 #endif
 424             }
 425             break;
 426
 427     case 4: for(i = 0; i < 256; ++i)
 428             {
 429                 by = (u1byte)i;
 430 #ifdef ONE_STEP
 431                 mk_tab[0][i] = mds(0, q40(by)); mk_tab[1][i] = mds(1, q41(by));
 432                 mk_tab[2][i] = mds(2, q42(by)); mk_tab[3][i] = mds(3, q43(by));
 433 #else
 434                 sb[0][i] = q40(by); sb[1][i] = q41(by);
 435                 sb[2][i] = q42(by); sb[3][i] = q43(by);
 436 #endif
 437             }
 438     }
 439 }
 440
 441 #  ifdef ONE_STEP
 442 #    define g0_fun(x) ( mk_tab[0][byte(x,0)] ^ mk_tab[1][byte(x,1)] \
 443                       ^ mk_tab[2][byte(x,2)] ^ mk_tab[3][byte(x,3)] )
 444 #    define g1_fun(x) ( mk_tab[0][byte(x,3)] ^ mk_tab[1][byte(x,0)] \
 445                       ^ mk_tab[2][byte(x,1)] ^ mk_tab[3][byte(x,2)] )
 446 #  else
 447 #    define g0_fun(x) ( mds(0, sb[0][byte(x,0)]) ^ mds(1, sb[1][byte(x,1)]) \
 448                       ^ mds(2, sb[2][byte(x,2)]) ^ mds(3, sb[3][byte(x,3)]) )
 449 #    define g1_fun(x) ( mds(0, sb[0][byte(x,3)]) ^ mds(1, sb[1][byte(x,0)]) \
 450                       ^ mds(2, sb[2][byte(x,1)]) ^ mds(3, sb[3][byte(x,2)]) )
 451 #  endif
 452
 453 #else
 454
 455 #define g0_fun(x)   h_fun(ctx,x,s_key)
 456 #define g1_fun(x)   h_fun(ctx,rotl(x,8),s_key)
 457
 458 #endif
 459
 460 /* The (12,8) Reed Soloman code has the generator polynomial
 461
 462   g(x) = x^4 + (a + 1/a) * x^3 + a * x^2 + (a + 1/a) * x + 1
 463
 464 where the coefficients are in the finite field GF(2^8) with a
 465 modular polynomial a^8 + a^6 + a^3 + a^2 + 1. To generate the
 466 remainder we have to start with a 12th order polynomial with our
 467 eight input bytes as the coefficients of the 4th to 11th terms.
 468 That is:
 469
 470   m[7] * x^11 + m[6] * x^10 ... + m[0] * x^4 + 0 * x^3 +... + 0
 471
 472 We then multiply the generator polynomial by m[7] * x^7 and subtract
 473 it - xor in GF(2^8) - from the above to eliminate the x^7 term (the
 474 artihmetic on the coefficients is done in GF(2^8). We then multiply
 475 the generator polynomial by x^6 * coeff(x^10) and use this to remove
 476 the x^10 term. We carry on in this way until the x^4 term is removed
 477 so that we are left with:
 478
 479   r[3] * x^3 + r[2] * x^2 + r[1] 8 x^1 + r[0]
 480
 481 which give the resulting 4 bytes of the remainder. This is equivalent
 482 to the matrix multiplication in the Twofish description but much faster
 483 to implement.
 484
 485 */
 486
 487 #define G_MOD   0x0000014d
 488
 489 u4byte mds_rem(u4byte p0, u4byte p1)
 490 {   u4byte  i, t, u;
 491
 492     for(i = 0; i < 8; ++i)
 493     {
 494         t = p1 >> 24;   /* get most significant coefficient */
 495
 496         p1 = (p1 << 8) | (p0 >> 24); p0 <<= 8;  /* shift others up */
 497
 498         /* multiply t by a (the primitive element - i.e. left shift) */
 499
 500         u = (t << 1);
 501
 502         if(t & 0x80)            /* subtract modular polynomial on overflow */
 503
 504             u ^= G_MOD;
 505
 506         p1 ^= t ^ (u << 16);    /* remove t * (a * x^2 + 1) */
 507
 508         u ^= (t >> 1);          /* form u = a * t + t / a = t * (a + 1 / a); */
 509
 510         if(t & 0x01)            /* add the modular polynomial on underflow */
 511
 512             u ^= G_MOD >> 1;
 513
 514         p1 ^= (u << 24) | (u << 8); /* remove t * (a + 1/a) * (x^3 + x) */
 515     }
 516
 517     return p1;
 518 }
 519
 520 /* initialise the key schedule from the user supplied key   */
 521
 522 u4byte *twofish_set_key(TwofishContext *ctx,
 523                         const u4byte in_key[], const u4byte key_len)
 524 {
 525     u4byte  i, a, b, me_key[4], mo_key[4];
 526     u4byte *l_key = ctx->l_key;
 527     u4byte *s_key = ctx->s_key;
 528
 529 #ifdef Q_TABLES
 530     if(!qt_gen)
 531     {
 532         gen_qtab(); qt_gen = 1;
 533     }
 534 #endif
 535
 536 #ifdef M_TABLE
 537     if(!mt_gen)
 538     {
 539         gen_mtab(); mt_gen = 1;
 540     }
 541 #endif
 542
 543     ctx->k_len = ctx->k_len = key_len / 64;   /* 2, 3 or 4 */
 544
 545     for(i = 0; i < ctx->k_len; ++i)
 546     {
 547         a = in_key[i + i];     me_key[i] = a;
 548         b = in_key[i + i + 1]; mo_key[i] = b;
 549         s_key[ctx->k_len - i - 1] = mds_rem(a, b);
 550     }
 551
 552     for(i = 0; i < 40; i += 2)
 553     {
 554         a = 0x01010101 * i; b = a + 0x01010101;
 555         a = h_fun(ctx,a, me_key);
 556         b = rotl(h_fun(ctx,b, mo_key), 8);
 557         l_key[i] = a + b;
 558         l_key[i + 1] = rotl(a + 2 * b, 9);
 559     }
 560
 561 #ifdef MK_TABLE
 562     gen_mk_tab(ctx,s_key);
 563 #endif
 564
 565     return l_key;
 566 }
 567
 568 /* encrypt a block of text  */
 569
 570 #define f_rnd(i)                                                    \
 571     t1 = g1_fun(blk[1]); t0 = g0_fun(blk[0]);                       \
 572     blk[2] = rotr(blk[2] ^ (t0 + t1 + l_key[4 * (i) + 8]), 1);      \
 573     blk[3] = rotl(blk[3], 1) ^ (t0 + 2 * t1 + l_key[4 * (i) + 9]);  \
 574     t1 = g1_fun(blk[3]); t0 = g0_fun(blk[2]);                       \
 575     blk[0] = rotr(blk[0] ^ (t0 + t1 + l_key[4 * (i) + 10]), 1);     \
 576     blk[1] = rotl(blk[1], 1) ^ (t0 + 2 * t1 + l_key[4 * (i) + 11])
 577
 578 void twofish_encrypt(TwofishContext *ctx,
 579                      const u4byte in_blk[4], u4byte out_blk[])
 580 {
 581     u4byte  t0, t1, blk[4];
 582     u4byte *l_key = ctx->l_key;
 583     u4byte *s_key = ctx->s_key;
 584
 585     blk[0] = in_blk[0] ^ l_key[0];
 586     blk[1] = in_blk[1] ^ l_key[1];
 587     blk[2] = in_blk[2] ^ l_key[2];
 588     blk[3] = in_blk[3] ^ l_key[3];
 589
 590     f_rnd(0); f_rnd(1); f_rnd(2); f_rnd(3);
 591     f_rnd(4); f_rnd(5); f_rnd(6); f_rnd(7);
 592
 593     out_blk[0] = blk[2] ^ l_key[4];
 594     out_blk[1] = blk[3] ^ l_key[5];
 595     out_blk[2] = blk[0] ^ l_key[6];
 596     out_blk[3] = blk[1] ^ l_key[7];
 597 }
 598
 599 /* decrypt a block of text  */
 600
 601 #define i_rnd(i)                                                        \
 602         t1 = g1_fun(blk[1]); t0 = g0_fun(blk[0]);                       \
 603         blk[2] = rotl(blk[2], 1) ^ (t0 + t1 + l_key[4 * (i) + 10]);     \
 604         blk[3] = rotr(blk[3] ^ (t0 + 2 * t1 + l_key[4 * (i) + 11]), 1); \
 605         t1 = g1_fun(blk[3]); t0 = g0_fun(blk[2]);                       \
 606         blk[0] = rotl(blk[0], 1) ^ (t0 + t1 + l_key[4 * (i) +  8]);     \
 607         blk[1] = rotr(blk[1] ^ (t0 + 2 * t1 + l_key[4 * (i) +  9]), 1)
 608
 609 void twofish_decrypt(TwofishContext *ctx,
 610                      const u4byte in_blk[4], u4byte out_blk[4])
 611 {
 612     u4byte  t0, t1, blk[4];
 613     u4byte *l_key = ctx->l_key;
 614     u4byte *s_key = ctx->s_key;
 615
 616     blk[0] = in_blk[0] ^ l_key[4];
 617     blk[1] = in_blk[1] ^ l_key[5];
 618     blk[2] = in_blk[2] ^ l_key[6];
 619     blk[3] = in_blk[3] ^ l_key[7];
 620
 621     i_rnd(7); i_rnd(6); i_rnd(5); i_rnd(4);
 622     i_rnd(3); i_rnd(2); i_rnd(1); i_rnd(0);
 623
 624     out_blk[0] = blk[2] ^ l_key[0];
 625     out_blk[1] = blk[3] ^ l_key[1];
 626     out_blk[2] = blk[0] ^ l_key[2];
 627     out_blk[3] = blk[1] ^ l_key[3];
 628 }