lib/silccrypt/e2.c

   1 /* Modified for SILC. -Pekka */\r
   2 \r
   3 /* This is an independent implementation of the encryption algorithm:   */\r
   4 /*                                                                      */\r
   5 /*         E2 by Nippon Telegraph and Telephone (NTT) Japan             */\r
   6 /*                                                                      */\r
   7 /* which is a candidate algorithm in the Advanced Encryption Standard   */\r
   8 /* programme of the US National Institute of Standards and Technology.  */\r
   9 /*                                                                      */\r
  10 /* Copyright in this implementation is held by Dr B R Gladman but I     */\r
  11 /* hereby give permission for its free direct or derivative use subject */\r
  12 /* to acknowledgment of its origin and compliance with any conditions   */\r
  13 /* that the originators of the algorithm place on its exploitation.     */\r
  14 /*                                                                      */\r
  15 /* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999     */\r
  16 /*                                                                      */\r
  17 /* In accordance with the wishes of NTT this implementation is made     */\r
  18 /* available for academic and study purposes only.   I gratefully       */\r
  19 /* acknowledge the contributions made by Kazumaro Aoki of NTT Japan     */\r
  20 /* for ways to increase the speed of this implementation.               */\r
  21 \r
  22 /* Timing data for E2 (e28.c)\r
  23 \r
  24 Core timing without I/O endian conversion:\r
  25 \r
  26 128 bit key:\r
  27 Key Setup:    9473 cycles\r
  28 Encrypt:       687 cycles =    37.3 mbits/sec\r
  29 Decrypt:       691 cycles =    37.0 mbits/sec\r
  30 Mean:          689 cycles =    37.2 mbits/sec\r
  31 \r
  32 192 bit key:\r
  33 Key Setup:    9540 cycles\r
  34 Encrypt:       696 cycles =    36.8 mbits/sec\r
  35 Decrypt:       693 cycles =    36.9 mbits/sec\r
  36 Mean:          695 cycles =    36.9 mbits/sec\r
  37 \r
  38 256 bit key:\r
  39 Key Setup:    9913 cycles\r
  40 Encrypt:       691 cycles =    37.0 mbits/sec\r
  41 Decrypt:       706 cycles =    36.3 mbits/sec\r
  42 Mean:          699 cycles =    36.6 mbits/sec\r
  43 \r
  44 Full timing with I/O endian conversion:\r
  45 \r
  46 128 bit key:\r
  47 Key Setup:    9598 cycles\r
  48 Encrypt:       730 cycles =    35.1 mbits/sec\r
  49 Decrypt:       723 cycles =    35.4 mbits/sec\r
  50 Mean:          727 cycles =    35.2 mbits/sec\r
  51 \r
  52 192 bit key:\r
  53 Key Setup:    9393 cycles\r
  54 Encrypt:       730 cycles =    35.1 mbits/sec\r
  55 Decrypt:       720 cycles =    35.6 mbits/sec\r
  56 Mean:          725 cycles =    35.3 mbits/sec\r
  57 \r
  58 256 bit key:\r
  59 Key Setup:    9720 cycles\r
  60 Encrypt:       727 cycles =    35.2 mbits/sec\r
  61 Decrypt:       721 cycles =    35.5 mbits/sec\r
  62 Mean:          724 cycles =    35.4 mbits/sec\r
  63 \r
  64 */\r
  65 \r
  66 #include <stdio.h>\r
  67 #include <sys/types.h>\r
  68 #include "e2_internal.h"\r
  69 \r
  70 u1byte  s_box[] =\r
  71 {\r
  72  0xe1, 0x42, 0x3e, 0x81, 0x4e, 0x17, 0x9e, 0xfd, 0xb4, 0x3f, 0x2c, 0xda,\r
  73  0x31, 0x1e, 0xe0, 0x41, 0xcc, 0xf3, 0x82, 0x7d, 0x7c, 0x12, 0x8e, 0xbb,\r
  74  0xe4, 0x58, 0x15, 0xd5, 0x6f, 0xe9, 0x4c, 0x4b, 0x35, 0x7b, 0x5a, 0x9a,\r
  75  0x90, 0x45, 0xbc, 0xf8, 0x79, 0xd6, 0x1b, 0x88, 0x02, 0xab, 0xcf, 0x64,\r
  76  0x09, 0x0c, 0xf0, 0x01, 0xa4, 0xb0, 0xf6, 0x93, 0x43, 0x63, 0x86, 0xdc,\r
  77  0x11, 0xa5, 0x83, 0x8b, 0xc9, 0xd0, 0x19, 0x95, 0x6a, 0xa1, 0x5c, 0x24,\r
  78  0x6e, 0x50, 0x21, 0x80, 0x2f, 0xe7, 0x53, 0x0f, 0x91, 0x22, 0x04, 0xed,\r
  79  0xa6, 0x48, 0x49, 0x67, 0xec, 0xf7, 0xc0, 0x39, 0xce, 0xf2, 0x2d, 0xbe,\r
  80  0x5d, 0x1c, 0xe3, 0x87, 0x07, 0x0d, 0x7a, 0xf4, 0xfb, 0x32, 0xf5, 0x8c,\r
  81  0xdb, 0x8f, 0x25, 0x96, 0xa8, 0xea, 0xcd, 0x33, 0x65, 0x54, 0x06, 0x8d,\r
  82  0x89, 0x0a, 0x5e, 0xd9, 0x16, 0x0e, 0x71, 0x6c, 0x0b, 0xff, 0x60, 0xd2,\r
  83  0x2e, 0xd3, 0xc8, 0x55, 0xc2, 0x23, 0xb7, 0x74, 0xe2, 0x9b, 0xdf, 0x77,\r
  84  0x2b, 0xb9, 0x3c, 0x62, 0x13, 0xe5, 0x94, 0x34, 0xb1, 0x27, 0x84, 0x9f,\r
  85  0xd7, 0x51, 0x00, 0x61, 0xad, 0x85, 0x73, 0x03, 0x08, 0x40, 0xef, 0x68,\r
  86  0xfe, 0x97, 0x1f, 0xde, 0xaf, 0x66, 0xe8, 0xb8, 0xae, 0xbd, 0xb3, 0xeb,\r
  87  0xc6, 0x6b, 0x47, 0xa9, 0xd8, 0xa7, 0x72, 0xee, 0x1d, 0x7e, 0xaa, 0xb6,\r
  88  0x75, 0xcb, 0xd4, 0x30, 0x69, 0x20, 0x7f, 0x37, 0x5b, 0x9d, 0x78, 0xa3,\r
  89  0xf1, 0x76, 0xfa, 0x05, 0x3d, 0x3a, 0x44, 0x57, 0x3b, 0xca, 0xc7, 0x8a,\r
  90  0x18, 0x46, 0x9c, 0xbf, 0xba, 0x38, 0x56, 0x1a, 0x92, 0x4d, 0x26, 0x29,\r
  91  0xa2, 0x98, 0x10, 0x99, 0x70, 0xa0, 0xc5, 0x28, 0xc1, 0x6d, 0x14, 0xac,\r
  92  0xf9, 0x5f, 0x4f, 0xc4, 0xc3, 0xd1, 0xfc, 0xdd, 0xb2, 0x59, 0xe6, 0xb5,\r
  93  0x36, 0x52, 0x4a, 0x2a\r
  94 };\r
  95 \r
  96 u4byte  l_box[4][256];\r
  97 u4byte  lb_init = 0;\r
  98 \r
  99 #define v_0     0x67452301\r
 100 #define v_1     0xefcdab89\r
 101 \r
 102 /* s_fun(s_fun(s_fun(v)))           */\r
 103 \r
 104 #define k2_0    0x30d32e58\r
 105 #define k2_1    0xb89e4984\r
 106 \r
 107 /* s_fun(s_fun(s_fun(s_fun(v))))    */\r
 108 \r
 109 #define k3_0    0x0957cfec\r
 110 #define k3_1    0xd800502e\r
 111 \r
 112 #define bp_fun(a,b,c,d,e,f,g,h)     \\r
 113     u = (e ^ g) & 0x00ffff00;       \\r
 114     v = (f ^ h) & 0x0000ffff;       \\r
 115     a = e ^ u; c = g ^ u;           \\r
 116     b = f ^ v; d = h ^ v\r
 117 \r
 118 #define ibp_fun(a,b,c,d,e,f,g,h)    \\r
 119     u = (e ^ g) & 0xff0000ff;       \\r
 120     v = (f ^ h) & 0xffff0000;       \\r
 121     a = e ^ u; c = g ^ u;           \\r
 122     b = f ^ v; d = h ^ v\r
 123 \r
 124 #define bp2_fun(x,y)                \\r
 125     w = (x ^ y) & 0x00ff00ff;       \\r
 126     x ^= w; y ^= w;                 \\r
 127 \r
 128 #define s_fun(x,y)          \\r
 129     p = x; q = x >> 8;      \\r
 130     r = y; s = y >> 8;      \\r
 131     x  = l_box[0][r & 255]; \\r
 132     y  = l_box[0][p & 255]; \\r
 133     p >>=  16; r >>=  16;   \\r
 134     x |= l_box[1][q & 255]; \\r
 135     y |= l_box[1][s & 255]; \\r
 136     x |= l_box[2][r & 255]; \\r
 137     y |= l_box[2][p & 255]; \\r
 138     x |= l_box[3][p >> 8];  \\r
 139     y |= l_box[3][r >> 8]\r
 140 \r
 141 #define sx_fun(x,y)         \\r
 142     p = x >>  8;            \\r
 143     q = x >> 16;            \\r
 144     x  = l_box[0][x & 255]; \\r
 145     x |= l_box[1][p & 255]; \\r
 146     x |= l_box[2][q & 255]; \\r
 147     x |= l_box[3][q >> 8];  \\r
 148     p = y >>  8;            \\r
 149     q = y >> 16;            \\r
 150     y  = l_box[0][y & 255]; \\r
 151     y |= l_box[1][p & 255]; \\r
 152     y |= l_box[2][q & 255]; \\r
 153     y |= l_box[3][q >> 8]\r
 154 \r
 155 #define spx_fun(x,y)        \\r
 156     sx_fun(x,y);            \\r
 157     y ^= x;                 \\r
 158     x ^= rotr(y, 16);       \\r
 159     y ^= rotr(x, 8);        \\r
 160     x ^= y\r
 161 \r
 162 #define sp_fun(x,y)         \\r
 163     s_fun(x,y);             \\r
 164     y ^= x;                 \\r
 165     x ^= rotr(y, 16);       \\r
 166     y ^= rotr(x, 8);        \\r
 167     x ^= y\r
 168 \r
 169 #define sr_fun(x,y)         \\r
 170     p = x; q = x >> 8;      \\r
 171     r = y; s = y >> 8;      \\r
 172     y  = l_box[1][p & 255]; \\r
 173     x  = l_box[1][r & 255]; \\r
 174     p >>= 16; r >>= 16;     \\r
 175     x |= l_box[2][q & 255]; \\r
 176     y |= l_box[2][s & 255]; \\r
 177     y |= l_box[3][p & 255]; \\r
 178     x |= l_box[3][r & 255]; \\r
 179     x |= l_box[0][r >>  8]; \\r
 180     y |= l_box[0][p >>  8]\r
 181 \r
 182 #define f_fun(a,b,c,d,k)            \\r
 183     u = c ^ *(k); v = d ^ *(k + 1); \\r
 184     sp_fun(u, v);                   \\r
 185     u ^= *(k + 2); v ^= *(k + 3);   \\r
 186     sr_fun(u, v);                   \\r
 187     a ^= v;                         \\r
 188     b ^= u\r
 189 \r
 190 #define byte_adr(x,n)   *(((u1byte*)&x)+n)\r
 191 \r
 192 u4byte  mod_inv(u4byte x)\r
 193 {   u4byte  y1, y2, a, b, q;\r
 194 \r
 195     y1 = ~((-x) / x); y2 = 1;\r
 196 \r
 197     a = x; b = y1 * x;\r
 198 \r
 199     for(;;)\r
 200     {\r
 201         q = a / b; \r
 202         \r
 203         if((a -= q * b) == 0)\r
 204 \r
 205             return (x * y1 == 1 ? y1 : -y1);\r
 206         \r
 207         y2 -= q * y1;\r
 208 \r
 209         q = b / a; \r
 210         \r
 211         if((b -= q * a) == 0)\r
 212         \r
 213             return (x * y2 == 1 ? y2 : -y2);\r
 214 \r
 215         y1 -= q * y2;\r
 216     }\r
 217 };\r
 218 \r
 219 void g_fun(u4byte y[8], u4byte l[8], u4byte v[2])\r
 220 {   u4byte  p,q;\r
 221 \r
 222     spx_fun(y[0], y[1]); spx_fun(v[0], v[1]); \r
 223     l[0] = v[0] ^= y[0]; l[1] = v[1] ^= y[1];\r
 224 \r
 225     spx_fun(y[2], y[3]); spx_fun(v[0], v[1]); \r
 226     l[2] = v[0] ^= y[2]; l[3] = v[1] ^= y[3];\r
 227 \r
 228     spx_fun(y[4], y[5]); spx_fun(v[0], v[1]);  \r
 229     l[4] = v[0] ^= y[4]; l[5] = v[1] ^= y[5];\r
 230 \r
 231     spx_fun(y[6], y[7]); spx_fun(v[0], v[1]); \r
 232     l[6] = v[0] ^= y[6]; l[7] = v[1] ^= y[7];\r
 233 };\r
 234 \r
 235 u4byte *e2_set_key(E2Context *ctx,\r
 236                    const u4byte in_key[], const u4byte key_len)\r
 237 {   \r
 238     u4byte  lk[8], v[2], lout[8];\r
 239     u4byte  i, j, k, w;\r
 240     u4byte *l_key = ctx->l_key;\r
 241 \r
 242     if(!lb_init)\r
 243     {\r
 244         for(i = 0; i < 256; ++i)\r
 245         {\r
 246             l_box[0][i] = ((u4byte)(s_box[i]));\r
 247             l_box[1][i] = ((u4byte)(s_box[i])) <<  8;\r
 248             l_box[2][i] = ((u4byte)(s_box[i])) << 16;\r
 249             l_box[3][i] = ((u4byte)(s_box[i])) << 24;\r
 250         }\r
 251 \r
 252         lb_init = 1;\r
 253     }\r
 254 \r
 255     v[0] = bswap(v_0); v[1] = bswap(v_1);\r
 256 \r
 257     lk[0] = io_swap(in_key[0]); lk[1] = io_swap(in_key[1]);\r
 258     lk[2] = io_swap(in_key[2]); lk[3] = io_swap(in_key[3]);\r
 259 \r
 260     lk[4] = io_swap(key_len > 128 ? in_key[4] : k2_0);\r
 261     lk[5] = io_swap(key_len > 128 ? in_key[5] : k2_1);\r
 262 \r
 263     lk[6] = io_swap(key_len > 192 ? in_key[6] : k3_0);\r
 264     lk[7] = io_swap(key_len > 192 ? in_key[7] : k3_1);\r
 265 \r
 266     g_fun(lk, lout, v);\r
 267 \r
 268     for(i = 0; i < 8; ++i)\r
 269     {\r
 270         g_fun(lk, lout, v);\r
 271 \r
 272         for(j = 0; j < 4; ++j)\r
 273         {\r
 274             // this is complex because of a byte swap in each 32 bit output word\r
 275 \r
 276             k = 2 * (48 - 16 * j + 2 * (i / 2) - i % 2);\r
 277 \r
 278             ((u1byte*)l_key)[k + 3]   = ((u1byte*)lout)[j];\r
 279             ((u1byte*)l_key)[k + 2]   = ((u1byte*)lout)[j + 16];\r
 280 \r
 281             ((u1byte*)l_key)[k + 19]  = ((u1byte*)lout)[j +  8];\r
 282             ((u1byte*)l_key)[k + 18]  = ((u1byte*)lout)[j + 24];\r
 283 \r
 284             ((u1byte*)l_key)[k + 131] = ((u1byte*)lout)[j +  4];\r
 285             ((u1byte*)l_key)[k + 130] = ((u1byte*)lout)[j + 20];\r
 286 \r
 287             ((u1byte*)l_key)[k + 147] = ((u1byte*)lout)[j + 12];\r
 288             ((u1byte*)l_key)[k + 146] = ((u1byte*)lout)[j + 28];\r
 289         }\r
 290     }\r
 291 \r
 292     for(i = 52; i < 60; ++i)\r
 293     {\r
 294         l_key[i] |= 1; l_key[i + 12] = mod_inv(l_key[i]);\r
 295     }\r
 296 \r
 297     for(i = 0; i < 48; i += 4)\r
 298     {\r
 299         bp2_fun(l_key[i], l_key[i + 1]);\r
 300     }\r
 301 \r
 302     return (u4byte*)&l_key;\r
 303 };\r
 304 \r
 305 void e2_encrypt(E2Context *ctx, const u4byte in_blk[4], u4byte out_blk[4])\r
 306 {   \r
 307     u4byte      a,b,c,d,p,q,r,s,u,v;\r
 308     u4byte *l_key = ctx->l_key;\r
 309 \r
 310     p = io_swap(in_blk[0]); q = io_swap(in_blk[1]); \r
 311     r = io_swap(in_blk[2]); s = io_swap(in_blk[3]);\r
 312     \r
 313     p ^= l_key[48]; q ^= l_key[49]; r ^= l_key[50]; s ^= l_key[51]; \r
 314     p *= l_key[52]; q *= l_key[53]; r *= l_key[54]; s *= l_key[55];\r
 315 \r
 316     bp_fun(a, b, c, d, p, q, r, s);\r
 317 \r
 318     f_fun(a, b, c, d, l_key);\r
 319     f_fun(c, d, a, b, l_key +  4);\r
 320     f_fun(a, b, c, d, l_key +  8);\r
 321     f_fun(c, d, a, b, l_key + 12);\r
 322     f_fun(a, b, c, d, l_key + 16);\r
 323     f_fun(c, d, a, b, l_key + 20);\r
 324     f_fun(a, b, c, d, l_key + 24);\r
 325     f_fun(c, d, a, b, l_key + 28);\r
 326     f_fun(a, b, c, d, l_key + 32);\r
 327     f_fun(c, d, a, b, l_key + 36);\r
 328     f_fun(a, b, c, d, l_key + 40);\r
 329     f_fun(c, d, a, b, l_key + 44);\r
 330 \r
 331     ibp_fun(p, q, r, s, a, b, c, d);        \r
 332     \r
 333     p *= l_key[68]; q *= l_key[69]; r *= l_key[70]; s *= l_key[71]; \r
 334     p ^= l_key[60]; q ^= l_key[61]; r ^= l_key[62]; s ^= l_key[63];\r
 335     \r
 336     out_blk[0] = io_swap(p); out_blk[1] = io_swap(q);\r
 337     out_blk[2] = io_swap(r); out_blk[3] = io_swap(s);\r
 338 };\r
 339 \r
 340 void e2_decrypt(E2Context *ctx, const u4byte in_blk[4], u4byte out_blk[4])\r
 341 {   \r
 342     u4byte      a,b,c,d,p,q,r,s,u,v;\r
 343     u4byte *l_key = ctx->l_key;\r
 344 \r
 345     p = io_swap(in_blk[0]); q = io_swap(in_blk[1]); \r
 346     r = io_swap(in_blk[2]); s = io_swap(in_blk[3]);\r
 347 \r
 348     p ^= l_key[60]; q ^= l_key[61]; r ^= l_key[62]; s ^= l_key[63];\r
 349     p *= l_key[56]; q *= l_key[57]; r *= l_key[58]; s *= l_key[59];\r
 350 \r
 351     bp_fun(a, b, c, d, p, q, r, s);\r
 352 \r
 353     f_fun(a, b, c, d, l_key + 44);\r
 354     f_fun(c, d, a, b, l_key + 40);\r
 355 \r
 356     f_fun(a, b, c, d, l_key + 36);\r
 357     f_fun(c, d, a, b, l_key + 32);\r
 358 \r
 359     f_fun(a, b, c, d, l_key + 28);\r
 360     f_fun(c, d, a, b, l_key + 24);\r
 361     \r
 362     f_fun(a, b, c, d, l_key + 20);\r
 363     f_fun(c, d, a, b, l_key + 16);\r
 364 \r
 365     f_fun(a, b, c, d, l_key + 12);\r
 366     f_fun(c, d, a, b, l_key +  8);\r
 367     \r
 368     f_fun(a, b, c, d, l_key +  4);\r
 369     f_fun(c, d, a, b, l_key);\r
 370 \r
 371     ibp_fun(p, q, r, s, a, b, c, d);        \r
 372     \r
 373     p *= l_key[64]; q *= l_key[65]; r *= l_key[66]; s *= l_key[67]; \r
 374     p ^= l_key[48]; q ^= l_key[49]; r ^= l_key[50]; s ^= l_key[51];\r
 375 \r
 376     out_blk[0] = io_swap(p); out_blk[1] = io_swap(q); \r
 377     out_blk[2] = io_swap(r); out_blk[3] = io_swap(s);\r
 378 };\r