issue #5638
[asterisk/asterisk.git] / aescrypt.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 /*! \file
35 \brief  This file contains the code for implementing encryption and decryption
36  for AES (Rijndael) for block and key sizes of 16, 24 and 32 bytes. It
37  can optionally be replaced by code written in assembler using NASM. For
38  further details see the file aesopt.h
39 */
40
41 #include "aesopt.h"
42
43 #if defined(__cplusplus)
44 extern "C"
45 {
46 #endif
47
48 #define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c])
49 #define so(y,x,c)   word_out(y, c, s(x,c))
50
51 #if defined(ARRAYS)
52 #define locals(y,x)     x[4],y[4]
53 #else
54 #define locals(y,x)     x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3
55 #endif
56
57 #define l_copy(y, x)    s(y,0) = s(x,0); s(y,1) = s(x,1); \
58                         s(y,2) = s(x,2); s(y,3) = s(x,3);
59 #define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)
60 #define state_out(y,x)  so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)
61 #define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)
62
63 #if defined(ENCRYPTION) && !defined(AES_ASM)
64
65 /* Visual C++ .Net v7.1 provides the fastest encryption code when using
66    Pentium optimiation with small code but this is poor for decryption
67    so we need to control this with the following VC++ pragmas
68 */
69
70 #if defined(_MSC_VER)
71 #pragma optimize( "s", on )
72 #endif
73
74 /* Given the column (c) of the output state variable, the following
75    macros give the input state variables which are needed in its
76    computation for each row (r) of the state. All the alternative
77    macros give the same end values but expand into different ways
78    of calculating these values.  In particular the complex macro
79    used for dynamically variable block sizes is designed to expand
80    to a compile time constant whenever possible but will expand to
81    conditional clauses on some branches (I am grateful to Frank
82    Yellin for this construction)
83 */
84
85 #define fwd_var(x,r,c)\
86  ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
87  : r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\
88  : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
89  :          ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2)))
90
91 #if defined(FT4_SET)
92 #undef  dec_fmvars
93 #define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))
94 #elif defined(FT1_SET)
95 #undef  dec_fmvars
96 #define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(f,n),fwd_var,rf1,c))
97 #else
98 #define fwd_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ fwd_mcol(no_table(x,t_use(s,box),fwd_var,rf1,c)))
99 #endif
100
101 #if defined(FL4_SET)
102 #define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,l),fwd_var,rf1,c))
103 #elif defined(FL1_SET)
104 #define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(f,l),fwd_var,rf1,c))
105 #else
106 #define fwd_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ no_table(x,t_use(s,box),fwd_var,rf1,c))
107 #endif
108
109 aes_rval aes_encrypt(const void *in_blk, void *out_blk, const aes_encrypt_ctx cx[1])
110 {   aes_32t         locals(b0, b1);
111     const aes_32t   *kp = cx->ks;
112 #ifdef dec_fmvars
113     dec_fmvars; /* declare variables for fwd_mcol() if needed */
114 #endif
115
116     aes_32t nr = (kp[45] ^ kp[52] ^ kp[53] ? kp[52] : 14);
117
118 #ifdef AES_ERR_CHK
119     if(   (nr != 10 || !(kp[0] | kp[3] | kp[4])) 
120        && (nr != 12 || !(kp[0] | kp[5] | kp[6]))
121        && (nr != 14 || !(kp[0] | kp[7] | kp[8])) )
122         return aes_error;
123 #endif
124
125     state_in(b0, in_blk, kp);
126
127 #if (ENC_UNROLL == FULL)
128
129     switch(nr)
130     {
131     case 14:
132         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
133         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
134         kp += 2 * N_COLS;
135     case 12:
136         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
137         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
138         kp += 2 * N_COLS;
139     case 10:
140         round(fwd_rnd,  b1, b0, kp + 1 * N_COLS);
141         round(fwd_rnd,  b0, b1, kp + 2 * N_COLS);
142         round(fwd_rnd,  b1, b0, kp + 3 * N_COLS);
143         round(fwd_rnd,  b0, b1, kp + 4 * N_COLS);
144         round(fwd_rnd,  b1, b0, kp + 5 * N_COLS);
145         round(fwd_rnd,  b0, b1, kp + 6 * N_COLS);
146         round(fwd_rnd,  b1, b0, kp + 7 * N_COLS);
147         round(fwd_rnd,  b0, b1, kp + 8 * N_COLS);
148         round(fwd_rnd,  b1, b0, kp + 9 * N_COLS);
149         round(fwd_lrnd, b0, b1, kp +10 * N_COLS);
150     }
151
152 #else
153
154 #if (ENC_UNROLL == PARTIAL)
155     {   aes_32t    rnd;
156         for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
157         {
158             kp += N_COLS;
159             round(fwd_rnd, b1, b0, kp);
160             kp += N_COLS;
161             round(fwd_rnd, b0, b1, kp);
162         }
163         kp += N_COLS;
164         round(fwd_rnd,  b1, b0, kp);
165 #else
166     {   aes_32t    rnd;
167         for(rnd = 0; rnd < nr - 1; ++rnd)
168         {
169             kp += N_COLS;
170             round(fwd_rnd, b1, b0, kp);
171             l_copy(b0, b1);
172         }
173 #endif
174         kp += N_COLS;
175         round(fwd_lrnd, b0, b1, kp);
176     }
177 #endif
178
179     state_out(out_blk, b0);
180 #ifdef AES_ERR_CHK
181     return aes_good;
182 #endif
183 }
184
185 #endif
186
187 #if defined(DECRYPTION) && !defined(AES_ASM)
188
189 /* Visual C++ .Net v7.1 provides the fastest encryption code when using
190    Pentium optimiation with small code but this is poor for decryption
191    so we need to control this with the following VC++ pragmas
192 */
193
194 #if defined(_MSC_VER)
195 #pragma optimize( "t", on )
196 #endif
197
198 /* Given the column (c) of the output state variable, the following
199    macros give the input state variables which are needed in its
200    computation for each row (r) of the state. All the alternative
201    macros give the same end values but expand into different ways
202    of calculating these values.  In particular the complex macro
203    used for dynamically variable block sizes is designed to expand
204    to a compile time constant whenever possible but will expand to
205    conditional clauses on some branches (I am grateful to Frank
206    Yellin for this construction)
207 */
208
209 #define inv_var(x,r,c)\
210  ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\
211  : r == 1 ? ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))\
212  : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\
213  :          ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0)))
214
215 #if defined(IT4_SET)
216 #undef  dec_imvars
217 #define inv_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,n),inv_var,rf1,c))
218 #elif defined(IT1_SET)
219 #undef  dec_imvars
220 #define inv_rnd(y,x,k,c)    (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(i,n),inv_var,rf1,c))
221 #else
222 #define inv_rnd(y,x,k,c)    (s(y,c) = inv_mcol((k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c)))
223 #endif
224
225 #if defined(IL4_SET)
226 #define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,l),inv_var,rf1,c))
227 #elif defined(IL1_SET)
228 #define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(i,l),inv_var,rf1,c))
229 #else
230 #define inv_lrnd(y,x,k,c)   (s(y,c) = (k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c))
231 #endif
232
233 aes_rval aes_decrypt(const void *in_blk, void *out_blk, const aes_decrypt_ctx cx[1])
234 {   aes_32t        locals(b0, b1);
235 #ifdef dec_imvars
236     dec_imvars; /* declare variables for inv_mcol() if needed */
237 #endif
238
239     aes_32t nr = (cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] ? cx->ks[52] : 14);
240     const aes_32t *kp = cx->ks + nr * N_COLS;
241
242 #ifdef AES_ERR_CHK
243     if(   (nr != 10 || !(cx->ks[0] | cx->ks[3] | cx->ks[4])) 
244        && (nr != 12 || !(cx->ks[0] | cx->ks[5] | cx->ks[6]))
245        && (nr != 14 || !(cx->ks[0] | cx->ks[7] | cx->ks[8])) )
246         return aes_error;
247 #endif
248
249     state_in(b0, in_blk, kp);
250
251 #if (DEC_UNROLL == FULL)
252
253     switch(nr)
254     {
255     case 14:
256         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
257         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
258         kp -= 2 * N_COLS;
259     case 12:
260         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
261         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
262         kp -= 2 * N_COLS;
263     case 10:
264         round(inv_rnd,  b1, b0, kp -  1 * N_COLS);
265         round(inv_rnd,  b0, b1, kp -  2 * N_COLS);
266         round(inv_rnd,  b1, b0, kp -  3 * N_COLS);
267         round(inv_rnd,  b0, b1, kp -  4 * N_COLS);
268         round(inv_rnd,  b1, b0, kp -  5 * N_COLS);
269         round(inv_rnd,  b0, b1, kp -  6 * N_COLS);
270         round(inv_rnd,  b1, b0, kp -  7 * N_COLS);
271         round(inv_rnd,  b0, b1, kp -  8 * N_COLS);
272         round(inv_rnd,  b1, b0, kp -  9 * N_COLS);
273         round(inv_lrnd, b0, b1, kp - 10 * N_COLS);
274     }
275
276 #else
277
278 #if (DEC_UNROLL == PARTIAL)
279     {   aes_32t    rnd;
280         for(rnd = 0; rnd < (nr >> 1) - 1; ++rnd)
281         {
282             kp -= N_COLS;
283             round(inv_rnd, b1, b0, kp);
284             kp -= N_COLS;
285             round(inv_rnd, b0, b1, kp);
286         }
287         kp -= N_COLS;
288         round(inv_rnd, b1, b0, kp);
289 #else
290     {   aes_32t    rnd;
291         for(rnd = 0; rnd < nr - 1; ++rnd)
292         {
293             kp -= N_COLS;
294             round(inv_rnd, b1, b0, kp);
295             l_copy(b0, b1);
296         }
297 #endif
298         kp -= N_COLS;
299         round(inv_lrnd, b0, b1, kp);
300     }
301 #endif
302
303     state_out(out_blk, b0);
304 #ifdef AES_ERR_CHK
305     return aes_good;
306 #endif
307 }
308
309 #endif
310
311 #if defined(__cplusplus)
312 }
313 #endif