start sorting out the duplicated code in the privacy handler
[asterisk/asterisk.git] / 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