Remove status_response callbacks where they are not needed.
[asterisk/asterisk.git] / 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 #ifndef HAVE_CRYPTO
41
42 #define DO_TABLES
43
44 #include "aesopt.h"
45
46 #if defined(FIXED_TABLES)
47
48 /* implemented in case of wrong call for fixed tables */
49
50 void gen_tabs(void)
51 {
52 }
53
54 #else   /* dynamic table generation */
55
56 #if !defined(FF_TABLES)
57
58 /*  Generate the tables for the dynamic table option
59
60     It will generally be sensible to use tables to compute finite
61     field multiplies and inverses but where memory is scarse this
62     code might sometimes be better. But it only has effect during
63     initialisation so its pretty unimportant in overall terms.
64 */
65
66 /*  return 2 ^ (n - 1) where n is the bit number of the highest bit
67     set in x with x in the range 1 < x < 0x00000200.   This form is
68     used so that locals within fi can be bytes rather than words
69 */
70
71 static aes_08t hibit(const aes_32t x)
72 {   aes_08t r = (aes_08t)((x >> 1) | (x >> 2));
73
74     r |= (r >> 2);
75     r |= (r >> 4);
76     return (r + 1) >> 1;
77 }
78
79 /* return the inverse of the finite field element x */
80
81 static aes_08t fi(const aes_08t x)
82 {   aes_08t p1 = x, p2 = BPOLY, n1 = hibit(x), n2 = 0x80, v1 = 1, v2 = 0;
83
84     if(x < 2) return x;
85
86     for(;;)
87     {
88         if(!n1) return v1;
89
90         while(n2 >= n1)
91         {
92             n2 /= n1; p2 ^= p1 * n2; v2 ^= v1 * n2; n2 = hibit(p2);
93         }
94
95         if(!n2) return v2;
96
97         while(n1 >= n2)
98         {
99             n1 /= n2; p1 ^= p2 * n1; v1 ^= v2 * n1; n1 = hibit(p1);
100         }
101     }
102 }
103
104 #endif
105
106 /* The forward and inverse affine transformations used in the S-box */
107
108 #define fwd_affine(x) \
109     (w = (aes_32t)x, w ^= (w<<1)^(w<<2)^(w<<3)^(w<<4), 0x63^(aes_08t)(w^(w>>8)))
110
111 #define inv_affine(x) \
112     (w = (aes_32t)x, w = (w<<1)^(w<<3)^(w<<6), 0x05^(aes_08t)(w^(w>>8)))
113
114 static int init = 0;
115
116 void gen_tabs(void)
117 {   aes_32t  i, w;
118
119 #if defined(FF_TABLES)
120
121     aes_08t  pow[512], log[256];
122
123     if(init) return;
124     /*  log and power tables for GF(2^8) finite field with
125         WPOLY as modular polynomial - the simplest primitive
126         root is 0x03, used here to generate the tables
127     */
128
129     i = 0; w = 1;
130     do
131     {
132         pow[i] = (aes_08t)w;
133         pow[i + 255] = (aes_08t)w;
134         log[w] = (aes_08t)i++;
135         w ^=  (w << 1) ^ (w & 0x80 ? WPOLY : 0);
136     }
137     while (w != 1);
138
139 #else
140     if(init) return;
141 #endif
142
143     for(i = 0, w = 1; i < RC_LENGTH; ++i)
144     {
145         t_set(r,c)[i] = bytes2word(w, 0, 0, 0);
146         w = f2(w);
147     }
148
149     for(i = 0; i < 256; ++i)
150     {   aes_08t    b;
151
152         b = fwd_affine(fi((aes_08t)i));
153         w = bytes2word(f2(b), b, b, f3(b));
154
155 #ifdef  SBX_SET
156         t_set(s,box)[i] = b;
157 #endif
158
159 #ifdef  FT1_SET                 /* tables for a normal encryption round */
160         t_set(f,n)[i] = w;
161 #endif
162 #ifdef  FT4_SET
163         t_set(f,n)[0][i] = w;
164         t_set(f,n)[1][i] = upr(w,1);
165         t_set(f,n)[2][i] = upr(w,2);
166         t_set(f,n)[3][i] = upr(w,3);
167 #endif
168         w = bytes2word(b, 0, 0, 0);
169
170 #ifdef  FL1_SET                 /* tables for last encryption round (may also   */
171         t_set(f,l)[i] = w;        /* be used in the key schedule)                 */
172 #endif
173 #ifdef  FL4_SET
174         t_set(f,l)[0][i] = w;
175         t_set(f,l)[1][i] = upr(w,1);
176         t_set(f,l)[2][i] = upr(w,2);
177         t_set(f,l)[3][i] = upr(w,3);
178 #endif
179
180 #ifdef  LS1_SET                 /* table for key schedule if t_set(f,l) above is    */
181         t_set(l,s)[i] = w;      /* not of the required form                     */
182 #endif
183 #ifdef  LS4_SET
184         t_set(l,s)[0][i] = w;
185         t_set(l,s)[1][i] = upr(w,1);
186         t_set(l,s)[2][i] = upr(w,2);
187         t_set(l,s)[3][i] = upr(w,3);
188 #endif
189
190         b = fi(inv_affine((aes_08t)i));
191         w = bytes2word(fe(b), f9(b), fd(b), fb(b));
192
193 #ifdef  IM1_SET                 /* tables for the inverse mix column operation  */
194         t_set(i,m)[b] = w;
195 #endif
196 #ifdef  IM4_SET
197         t_set(i,m)[0][b] = w;
198         t_set(i,m)[1][b] = upr(w,1);
199         t_set(i,m)[2][b] = upr(w,2);
200         t_set(i,m)[3][b] = upr(w,3);
201 #endif
202
203 #ifdef  ISB_SET
204         t_set(i,box)[i] = b;
205 #endif
206 #ifdef  IT1_SET                 /* tables for a normal decryption round */
207         t_set(i,n)[i] = w;
208 #endif
209 #ifdef  IT4_SET
210         t_set(i,n)[0][i] = w;
211         t_set(i,n)[1][i] = upr(w,1);
212         t_set(i,n)[2][i] = upr(w,2);
213         t_set(i,n)[3][i] = upr(w,3);
214 #endif
215         w = bytes2word(b, 0, 0, 0);
216 #ifdef  IL1_SET                 /* tables for last decryption round */
217         t_set(i,l)[i] = w;
218 #endif
219 #ifdef  IL4_SET
220         t_set(i,l)[0][i] = w;
221         t_set(i,l)[1][i] = upr(w,1);
222         t_set(i,l)[2][i] = upr(w,2);
223         t_set(i,l)[3][i] = upr(w,3);
224 #endif
225     }
226     init = 1;
227 }
228
229 #endif
230
231 #endif /* !HAVE_CRYPTO */
232
233 #if defined(__cplusplus)
234 }
235 #endif
236