lib/silccrypt/aes.c

   1 /* Modified for SILC. -Pekka */
   2 /* The AES */
   3
   4 /* This is an independent implementation of the encryption algorithm:   */
   5 /*                                                                      */
   6 /*         RIJNDAEL by Joan Daemen and Vincent Rijmen                   */
   7 /*                                                                      */
   8 /* which is a candidate algorithm in the Advanced Encryption Standard   */
   9 /* programme of the US National Institute of Standards and Technology.  */
  10 /*                                                                      */
  11 /* Copyright in this implementation is held by Dr B R Gladman but I     */
  12 /* hereby give permission for its free direct or derivative use subject */
  13 /* to acknowledgment of its origin and compliance with any conditions   */
  14 /* that the originators of the algorithm place on its exploitation.     */
  15 /*                                                                      */
  16 /* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999     */
  17
  18 /* Timing data for Rijndael (rijndael.c)
  19
  20 Algorithm: rijndael (rijndael.c)
  21
  22 128 bit key:
  23 Key Setup:    305/1389 cycles (encrypt/decrypt)
  24 Encrypt:       374 cycles =    68.4 mbits/sec
  25 Decrypt:       352 cycles =    72.7 mbits/sec
  26 Mean:          363 cycles =    70.5 mbits/sec
  27
  28 192 bit key:
  29 Key Setup:    277/1595 cycles (encrypt/decrypt)
  30 Encrypt:       439 cycles =    58.3 mbits/sec
  31 Decrypt:       425 cycles =    60.2 mbits/sec
  32 Mean:          432 cycles =    59.3 mbits/sec
  33
  34 256 bit key:
  35 Key Setup:    374/1960 cycles (encrypt/decrypt)
  36 Encrypt:       502 cycles =    51.0 mbits/sec
  37 Decrypt:       498 cycles =    51.4 mbits/sec
  38 Mean:          500 cycles =    51.2 mbits/sec
  39
  40 */
  41
  42 #include "silc.h"
  43 #include "rijndael_internal.h"
  44 #include "aes.h"
  45
  46 /*
  47  * SILC Crypto API for Rijndael
  48  */
  49
  50 /* Sets the key for the cipher. */
  51
  52 SILC_CIPHER_API_SET_KEY(aes)
  53 {
  54   SilcUInt32 k[8];
  55
  56   SILC_GET_WORD_KEY(key, k, keylen);
  57   rijndael_set_key((RijndaelContext *)context, k, keylen);
  58
  59   return TRUE;
  60 }
  61
  62 /* Sets the string as a new key for the cipher. The string is first
  63    hashed and then used as a new key. */
  64
  65 SILC_CIPHER_API_SET_KEY_WITH_STRING(aes)
  66 {
  67   return 1;
  68 }
  69
  70 /* Returns the size of the cipher context. */
  71
  72 SILC_CIPHER_API_CONTEXT_LEN(aes)
  73 {
  74   return sizeof(RijndaelContext);
  75 }
  76
  77 /* Encrypts with the cipher in CBC mode. Source and destination buffers
  78    maybe one and same. */
  79
  80 SILC_CIPHER_API_ENCRYPT_CBC(aes)
  81 {
  82   SilcUInt32 tiv[4];
  83   int i;
  84
  85   SILC_CBC_GET_IV(tiv, iv);
  86
  87   SILC_CBC_ENC_PRE(tiv, src);
  88   rijndael_encrypt((RijndaelContext *)context, tiv, tiv);
  89   SILC_CBC_ENC_POST(tiv, dst, src);
  90
  91   for (i = 16; i < len; i += 16) {
  92     SILC_CBC_ENC_PRE(tiv, src);
  93     rijndael_encrypt((RijndaelContext *)context, tiv, tiv);
  94     SILC_CBC_ENC_POST(tiv, dst, src);
  95   }
  96
  97   SILC_CBC_PUT_IV(tiv, iv);
  98
  99   return TRUE;
 100 }
 101
 102 /* Decrypts with the cipher in CBC mode. Source and destination buffers
 103    maybe one and same. */
 104
 105 SILC_CIPHER_API_DECRYPT_CBC(aes)
 106 {
 107   SilcUInt32 tmp[4], tmp2[4], tiv[4];
 108   int i;
 109
 110   SILC_CBC_GET_IV(tiv, iv);
 111
 112   SILC_CBC_DEC_PRE(tmp, src);
 113   rijndael_decrypt((RijndaelContext *)context, tmp, tmp2);
 114   SILC_CBC_DEC_POST(tmp2, dst, src, tmp, tiv);
 115
 116   for (i = 16; i < len; i += 16) {
 117     SILC_CBC_DEC_PRE(tmp, src);
 118     rijndael_decrypt((RijndaelContext *)context, tmp, tmp2);
 119     SILC_CBC_DEC_POST(tmp2, dst, src, tmp, tiv);
 120   }
 121
 122   SILC_CBC_PUT_IV(tiv, iv);
 123
 124   return TRUE;
 125 }
 126
 127 #define LARGE_TABLES
 128
 129 u1byte  pow_tab[256];
 130 u1byte  log_tab[256];
 131 u1byte  sbx_tab[256];
 132 u1byte  isb_tab[256];
 133 u4byte  rco_tab[ 10];
 134 u4byte  ft_tab[4][256];
 135 u4byte  it_tab[4][256];
 136
 137 u4byte  fl_tab[4][256];
 138 u4byte  il_tab[4][256];
 139
 140 u4byte  tab_gen = 0;
 141
 142 #define ff_mult(a,b)    (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0)
 143
 144 #define f_rn(bo, bi, n, k)                          \
 145     bo[n] =  ft_tab[0][byte(bi[n],0)] ^             \
 146              ft_tab[1][byte(bi[(n + 1) & 3],1)] ^   \
 147              ft_tab[2][byte(bi[(n + 2) & 3],2)] ^   \
 148              ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
 149
 150 #define i_rn(bo, bi, n, k)                          \
 151     bo[n] =  it_tab[0][byte(bi[n],0)] ^             \
 152              it_tab[1][byte(bi[(n + 3) & 3],1)] ^   \
 153              it_tab[2][byte(bi[(n + 2) & 3],2)] ^   \
 154              it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
 155
 156 #ifdef LARGE_TABLES
 157
 158 #define ls_box(x)                \
 159     ( fl_tab[0][byte(x, 0)] ^    \
 160       fl_tab[1][byte(x, 1)] ^    \
 161       fl_tab[2][byte(x, 2)] ^    \
 162       fl_tab[3][byte(x, 3)] )
 163
 164 #define f_rl(bo, bi, n, k)                          \
 165     bo[n] =  fl_tab[0][byte(bi[n],0)] ^             \
 166              fl_tab[1][byte(bi[(n + 1) & 3],1)] ^   \
 167              fl_tab[2][byte(bi[(n + 2) & 3],2)] ^   \
 168              fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
 169
 170 #define i_rl(bo, bi, n, k)                          \
 171     bo[n] =  il_tab[0][byte(bi[n],0)] ^             \
 172              il_tab[1][byte(bi[(n + 3) & 3],1)] ^   \
 173              il_tab[2][byte(bi[(n + 2) & 3],2)] ^   \
 174              il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
 175
 176 #else
 177
 178 #define ls_box(x)                            \
 179     ((u4byte)sbx_tab[byte(x, 0)] <<  0) ^    \
 180     ((u4byte)sbx_tab[byte(x, 1)] <<  8) ^    \
 181     ((u4byte)sbx_tab[byte(x, 2)] << 16) ^    \
 182     ((u4byte)sbx_tab[byte(x, 3)] << 24)
 183
 184 #define f_rl(bo, bi, n, k)                                      \
 185     bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^                    \
 186         rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]),  8) ^  \
 187         rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^  \
 188         rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n)
 189
 190 #define i_rl(bo, bi, n, k)                                      \
 191     bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^                    \
 192         rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]),  8) ^  \
 193         rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^  \
 194         rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)
 195
 196 #endif
 197
 198 void gen_tabs(void)
 199 {   u4byte  i, t;
 200     u1byte  p, q;
 201
 202     /* log and power tables for GF(2**8) finite field with  */
 203     /* 0x11b as modular polynomial - the simplest prmitive  */
 204     /* root is 0x11, used here to generate the tables       */
 205
 206     for(i = 0,p = 1; i < 256; ++i)
 207     {
 208         pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i;
 209
 210         p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0);
 211     }
 212
 213     log_tab[1] = 0; p = 1;
 214
 215     for(i = 0; i < 10; ++i)
 216     {
 217         rco_tab[i] = p;
 218
 219         p = (p << 1) ^ (p & 0x80 ? 0x1b : 0);
 220     }
 221
 222     /* note that the affine byte transformation matrix in   */
 223     /* rijndael specification is in big endian format with  */
 224     /* bit 0 as the most significant bit. In the remainder  */
 225     /* of the specification the bits are numbered from the  */
 226     /* least significant end of a byte.                     */
 227
 228     for(i = 0; i < 256; ++i)
 229     {
 230         p = (i ? pow_tab[255 - log_tab[i]] : 0); q = p;
 231         q = (q >> 7) | (q << 1); p ^= q;
 232         q = (q >> 7) | (q << 1); p ^= q;
 233         q = (q >> 7) | (q << 1); p ^= q;
 234         q = (q >> 7) | (q << 1); p ^= q ^ 0x63;
 235         sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i;
 236     }
 237
 238     for(i = 0; i < 256; ++i)
 239     {
 240         p = sbx_tab[i];
 241
 242 #ifdef  LARGE_TABLES
 243
 244         t = p; fl_tab[0][i] = t;
 245         fl_tab[1][i] = rotl(t,  8);
 246         fl_tab[2][i] = rotl(t, 16);
 247         fl_tab[3][i] = rotl(t, 24);
 248 #endif
 249         t = ((u4byte)ff_mult(2, p)) |
 250             ((u4byte)p <<  8) |
 251             ((u4byte)p << 16) |
 252             ((u4byte)ff_mult(3, p) << 24);
 253
 254         ft_tab[0][i] = t;
 255         ft_tab[1][i] = rotl(t,  8);
 256         ft_tab[2][i] = rotl(t, 16);
 257         ft_tab[3][i] = rotl(t, 24);
 258
 259         p = isb_tab[i];
 260
 261 #ifdef  LARGE_TABLES
 262
 263         t = p; il_tab[0][i] = t;
 264         il_tab[1][i] = rotl(t,  8);
 265         il_tab[2][i] = rotl(t, 16);
 266         il_tab[3][i] = rotl(t, 24);
 267 #endif
 268         t = ((u4byte)ff_mult(14, p)) |
 269             ((u4byte)ff_mult( 9, p) <<  8) |
 270             ((u4byte)ff_mult(13, p) << 16) |
 271             ((u4byte)ff_mult(11, p) << 24);
 272
 273         it_tab[0][i] = t;
 274         it_tab[1][i] = rotl(t,  8);
 275         it_tab[2][i] = rotl(t, 16);
 276         it_tab[3][i] = rotl(t, 24);
 277     }
 278
 279     tab_gen = 1;
 280 };
 281
 282 #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b)
 283
 284 #define imix_col(y,x)       \
 285     u   = star_x(x);        \
 286     v   = star_x(u);        \
 287     w   = star_x(v);        \
 288     t   = w ^ (x);          \
 289    (y)  = u ^ v ^ w;        \
 290    (y) ^= rotr(u ^ t,  8) ^ \
 291           rotr(v ^ t, 16) ^ \
 292           rotr(t,24)
 293
 294 /* initialise the key schedule from the user supplied key   */
 295
 296 #define loop4(i)                                    \
 297 { \
 298    t = ls_box(rotr(t,  8)) ^ rco_tab[i];           \
 299     t ^= e_key[4 * i];     e_key[4 * i + 4] = t;    \
 300     t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t;    \
 301     t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t;    \
 302     t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t;    \
 303 }
 304
 305 #define loop6(i)                                    \
 306 {   t = ls_box(rotr(t,  8)) ^ rco_tab[i];           \
 307     t ^= e_key[6 * i];     e_key[6 * i + 6] = t;    \
 308     t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t;    \
 309     t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t;    \
 310     t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t;    \
 311     t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t;   \
 312     t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t;   \
 313 }
 314
 315 #define loop8(i)                                    \
 316 {   t = ls_box(rotr(t,  8)) ^ rco_tab[i];           \
 317     t ^= e_key[8 * i];     e_key[8 * i + 8] = t;    \
 318     t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t;    \
 319     t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t;   \
 320     t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t;   \
 321     t  = e_key[8 * i + 4] ^ ls_box(t);              \
 322     e_key[8 * i + 12] = t;                          \
 323     t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t;   \
 324     t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t;   \
 325     t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t;   \
 326 }
 327
 328 u4byte *rijndael_set_key(RijndaelContext *ctx,
 329                          const u4byte in_key[], const u4byte key_len)
 330 {
 331     u4byte  i, t, u, v, w;
 332     u4byte *e_key = ctx->e_key;
 333     u4byte *d_key = ctx->d_key;
 334     u4byte k_len;
 335
 336     if(!tab_gen)
 337         gen_tabs();
 338
 339     k_len = ctx->k_len = (key_len + 31) / 32;
 340
 341     e_key[0] = in_key[0]; e_key[1] = in_key[1];
 342     e_key[2] = in_key[2]; e_key[3] = in_key[3];
 343
 344     switch(k_len)
 345     {
 346         case 4: t = e_key[3];
 347                 for(i = 0; i < 10; ++i)
 348                     loop4(i);
 349                 break;
 350
 351         case 6: e_key[4] = in_key[4]; t = e_key[5] = in_key[5];
 352                 for(i = 0; i < 8; ++i)
 353                     loop6(i);
 354                 break;
 355
 356         case 8: e_key[4] = in_key[4]; e_key[5] = in_key[5];
 357                 e_key[6] = in_key[6]; t = e_key[7] = in_key[7];
 358                 for(i = 0; i < 7; ++i)
 359                     loop8(i);
 360                 break;
 361     }
 362
 363     d_key[0] = e_key[0]; d_key[1] = e_key[1];
 364     d_key[2] = e_key[2]; d_key[3] = e_key[3];
 365
 366     for(i = 4; i < 4 * k_len + 24; ++i)
 367     {
 368         imix_col(d_key[i], e_key[i]);
 369     }
 370
 371     return e_key;
 372 };
 373
 374 /* encrypt a block of text  */
 375
 376 #define f_nround(bo, bi, k) \
 377     f_rn(bo, bi, 0, k);     \
 378     f_rn(bo, bi, 1, k);     \
 379     f_rn(bo, bi, 2, k);     \
 380     f_rn(bo, bi, 3, k);     \
 381     k += 4
 382
 383 #define f_lround(bo, bi, k) \
 384     f_rl(bo, bi, 0, k);     \
 385     f_rl(bo, bi, 1, k);     \
 386     f_rl(bo, bi, 2, k);     \
 387     f_rl(bo, bi, 3, k)
 388
 389 void rijndael_encrypt(RijndaelContext *ctx,
 390                       const u4byte in_blk[4], u4byte out_blk[4])
 391 {
 392     u4byte  b0[4], b1[4], *kp;
 393     u4byte *e_key = ctx->e_key;
 394     u4byte k_len = ctx->k_len;
 395
 396     b0[0] = in_blk[0] ^ e_key[0]; b0[1] = in_blk[1] ^ e_key[1];
 397     b0[2] = in_blk[2] ^ e_key[2]; b0[3] = in_blk[3] ^ e_key[3];
 398
 399     kp = e_key + 4;
 400
 401     if(k_len > 6)
 402     {
 403         f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 404     }
 405
 406     if(k_len > 4)
 407     {
 408         f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 409     }
 410
 411     f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 412     f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 413     f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 414     f_nround(b1, b0, kp); f_nround(b0, b1, kp);
 415     f_nround(b1, b0, kp); f_lround(b0, b1, kp);
 416
 417     out_blk[0] = b0[0]; out_blk[1] = b0[1];
 418     out_blk[2] = b0[2]; out_blk[3] = b0[3];
 419 };
 420
 421 /* decrypt a block of text  */
 422
 423 #define i_nround(bo, bi, k) \
 424     i_rn(bo, bi, 0, k);     \
 425     i_rn(bo, bi, 1, k);     \
 426     i_rn(bo, bi, 2, k);     \
 427     i_rn(bo, bi, 3, k);     \
 428     k -= 4
 429
 430 #define i_lround(bo, bi, k) \
 431     i_rl(bo, bi, 0, k);     \
 432     i_rl(bo, bi, 1, k);     \
 433     i_rl(bo, bi, 2, k);     \
 434     i_rl(bo, bi, 3, k)
 435
 436 void rijndael_decrypt(RijndaelContext *ctx,
 437                       const u4byte in_blk[4], u4byte out_blk[4])
 438 {
 439     u4byte  b0[4], b1[4], *kp;
 440     u4byte *e_key = ctx->e_key;
 441     u4byte *d_key = ctx->d_key;
 442     u4byte k_len = ctx->k_len;
 443
 444     b0[0] = in_blk[0] ^ e_key[4 * k_len + 24]; b0[1] = in_blk[1] ^ e_key[4 * k_len + 25];
 445     b0[2] = in_blk[2] ^ e_key[4 * k_len + 26]; b0[3] = in_blk[3] ^ e_key[4 * k_len + 27];
 446
 447     kp = d_key + 4 * (k_len + 5);
 448
 449     if(k_len > 6)
 450     {
 451         i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 452     }
 453
 454     if(k_len > 4)
 455     {
 456         i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 457     }
 458
 459     i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 460     i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 461     i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 462     i_nround(b1, b0, kp); i_nround(b0, b1, kp);
 463     i_nround(b1, b0, kp); i_lround(b0, b1, kp);
 464
 465     out_blk[0] = b0[0]; out_blk[1] = b0[1];
 466     out_blk[2] = b0[2]; out_blk[3] = b0[3];
 467 };