main/aestab.c

   1 /*
   2  ---------------------------------------------------------------------------
   3  Copyright (c) 2003, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
   4  All rights reserved.
   5
   6  LICENSE TERMS
   7
   8  The free distribution and use of this software in both source and binary
   9  form is allowed (with or without changes) provided that:
  10
  11    1. distributions of this source code include the above copyright
  12       notice, this list of conditions and the following disclaimer;
  13
  14    2. distributions in binary form include the above copyright
  15       notice, this list of conditions and the following disclaimer
  16       in the documentation and/or other associated materials;
  17
  18    3. the copyright holder's name is not used to endorse products
  19       built using this software without specific written permission.
  20
  21  ALTERNATIVELY, provided that this notice is retained in full, this product
  22  may be distributed under the terms of the GNU General Public License (GPL),
  23  in which case the provisions of the GPL apply INSTEAD OF those given above.
  24
  25  DISCLAIMER
  26
  27  This software is provided 'as is' with no explicit or implied warranties
  28  in respect of its properties, including, but not limited to, correctness
  29  and/or fitness for purpose.
  30  ---------------------------------------------------------------------------
  31  Issue Date: 26/08/2003
  32
  33 */
  34
  35 #if defined(__cplusplus)
  36 extern "C"
  37 {
  38 #endif
  39
  40 #define DO_TABLES
  41
  42 #include "aesopt.h"
  43
  44 #if defined(FIXED_TABLES)
  45
  46 /* implemented in case of wrong call for fixed tables */
  47
  48 void gen_tabs(void)
  49 {
  50 }
  51
  52 #else   /* dynamic table generation */
  53
  54 #if !defined(FF_TABLES)
  55
  56 /*  Generate the tables for the dynamic table option
  57
  58     It will generally be sensible to use tables to compute finite
  59     field multiplies and inverses but where memory is scarse this
  60     code might sometimes be better. But it only has effect during
  61     initialisation so its pretty unimportant in overall terms.
  62 */
  63
  64 /*  return 2 ^ (n - 1) where n is the bit number of the highest bit
  65     set in x with x in the range 1 < x < 0x00000200.   This form is
  66     used so that locals within fi can be bytes rather than words
  67 */
  68
  69 static aes_08t hibit(const aes_32t x)
  70 {   aes_08t r = (aes_08t)((x >> 1) | (x >> 2));
  71
  72     r |= (r >> 2);
  73     r |= (r >> 4);
  74     return (r + 1) >> 1;
  75 }
  76
  77 /* return the inverse of the finite field element x */
  78
  79 static aes_08t fi(const aes_08t x)
  80 {   aes_08t p1 = x, p2 = BPOLY, n1 = hibit(x), n2 = 0x80, v1 = 1, v2 = 0;
  81
  82     if(x < 2) return x;
  83
  84     for(;;)
  85     {
  86         if(!n1) return v1;
  87
  88         while(n2 >= n1)
  89         {
  90             n2 /= n1; p2 ^= p1 * n2; v2 ^= v1 * n2; n2 = hibit(p2);
  91         }
  92
  93         if(!n2) return v2;
  94
  95         while(n1 >= n2)
  96         {
  97             n1 /= n2; p1 ^= p2 * n1; v1 ^= v2 * n1; n1 = hibit(p1);
  98         }
  99     }
 100 }
 101
 102 #endif
 103
 104 /* The forward and inverse affine transformations used in the S-box */
 105
 106 #define fwd_affine(x) \
 107     (w = (aes_32t)x, w ^= (w<<1)^(w<<2)^(w<<3)^(w<<4), 0x63^(aes_08t)(w^(w>>8)))
 108
 109 #define inv_affine(x) \
 110     (w = (aes_32t)x, w = (w<<1)^(w<<3)^(w<<6), 0x05^(aes_08t)(w^(w>>8)))
 111
 112 static int init = 0;
 113
 114 void gen_tabs(void)
 115 {   aes_32t  i, w;
 116
 117 #if defined(FF_TABLES)
 118
 119     aes_08t  pow[512], log[256];
 120
 121     if(init) return;
 122     /*  log and power tables for GF(2^8) finite field with
 123         WPOLY as modular polynomial - the simplest primitive
 124         root is 0x03, used here to generate the tables
 125     */
 126
 127     i = 0; w = 1;
 128     do
 129     {
 130         pow[i] = (aes_08t)w;
 131         pow[i + 255] = (aes_08t)w;
 132         log[w] = (aes_08t)i++;
 133         w ^=  (w << 1) ^ (w & 0x80 ? WPOLY : 0);
 134     }
 135     while (w != 1);
 136
 137 #else
 138     if(init) return;
 139 #endif
 140
 141     for(i = 0, w = 1; i < RC_LENGTH; ++i)
 142     {
 143         t_set(r,c)[i] = bytes2word(w, 0, 0, 0);
 144         w = f2(w);
 145     }
 146
 147     for(i = 0; i < 256; ++i)
 148     {   aes_08t    b;
 149
 150         b = fwd_affine(fi((aes_08t)i));
 151         w = bytes2word(f2(b), b, b, f3(b));
 152
 153 #ifdef  SBX_SET
 154         t_set(s,box)[i] = b;
 155 #endif
 156
 157 #ifdef  FT1_SET                 /* tables for a normal encryption round */
 158         t_set(f,n)[i] = w;
 159 #endif
 160 #ifdef  FT4_SET
 161         t_set(f,n)[0][i] = w;
 162         t_set(f,n)[1][i] = upr(w,1);
 163         t_set(f,n)[2][i] = upr(w,2);
 164         t_set(f,n)[3][i] = upr(w,3);
 165 #endif
 166         w = bytes2word(b, 0, 0, 0);
 167
 168 #ifdef  FL1_SET                 /* tables for last encryption round (may also   */
 169         t_set(f,l)[i] = w;        /* be used in the key schedule)                 */
 170 #endif
 171 #ifdef  FL4_SET
 172         t_set(f,l)[0][i] = w;
 173         t_set(f,l)[1][i] = upr(w,1);
 174         t_set(f,l)[2][i] = upr(w,2);
 175         t_set(f,l)[3][i] = upr(w,3);
 176 #endif
 177
 178 #ifdef  LS1_SET                 /* table for key schedule if t_set(f,l) above is    */
 179         t_set(l,s)[i] = w;      /* not of the required form                     */
 180 #endif
 181 #ifdef  LS4_SET
 182         t_set(l,s)[0][i] = w;
 183         t_set(l,s)[1][i] = upr(w,1);
 184         t_set(l,s)[2][i] = upr(w,2);
 185         t_set(l,s)[3][i] = upr(w,3);
 186 #endif
 187
 188         b = fi(inv_affine((aes_08t)i));
 189         w = bytes2word(fe(b), f9(b), fd(b), fb(b));
 190
 191 #ifdef  IM1_SET                 /* tables for the inverse mix column operation  */
 192         t_set(i,m)[b] = w;
 193 #endif
 194 #ifdef  IM4_SET
 195         t_set(i,m)[0][b] = w;
 196         t_set(i,m)[1][b] = upr(w,1);
 197         t_set(i,m)[2][b] = upr(w,2);
 198         t_set(i,m)[3][b] = upr(w,3);
 199 #endif
 200
 201 #ifdef  ISB_SET
 202         t_set(i,box)[i] = b;
 203 #endif
 204 #ifdef  IT1_SET                 /* tables for a normal decryption round */
 205         t_set(i,n)[i] = w;
 206 #endif
 207 #ifdef  IT4_SET
 208         t_set(i,n)[0][i] = w;
 209         t_set(i,n)[1][i] = upr(w,1);
 210         t_set(i,n)[2][i] = upr(w,2);
 211         t_set(i,n)[3][i] = upr(w,3);
 212 #endif
 213         w = bytes2word(b, 0, 0, 0);
 214 #ifdef  IL1_SET                 /* tables for last decryption round */
 215         t_set(i,l)[i] = w;
 216 #endif
 217 #ifdef  IL4_SET
 218         t_set(i,l)[0][i] = w;
 219         t_set(i,l)[1][i] = upr(w,1);
 220         t_set(i,l)[2][i] = upr(w,2);
 221         t_set(i,l)[3][i] = upr(w,3);
 222 #endif
 223     }
 224     init = 1;
 225 }
 226
 227 #endif
 228
 229 #if defined(__cplusplus)
 230 }
 231 #endif
 232