Add a massive set of changes for converting to use the ast_debug() macro.
[asterisk/asterisk.git] / main / aeskey.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 /*! \file
36  *
37  *  \brief  This file contains the code for implementing the key schedule for AES
38  *  (Rijndael) for block and key sizes of 16, 24, and 32 bytes. See aesopt.h
39  *  for further details including optimisation.
40  *
41  * \author Dr Brian Gladman <brg@gladman.me.uk>
42  */
43
44 #if defined(__cplusplus)
45 extern "C"
46 {
47 #endif
48
49 #ifndef HAVE_CRYPTO
50
51 #include "aesopt.h"
52
53 /* Initialise the key schedule from the user supplied key. The key
54    length can be specified in bytes, with legal values of 16, 24
55    and 32, or in bits, with legal values of 128, 192 and 256. These
56    values correspond with Nk values of 4, 6 and 8 respectively.
57
58    The following macros implement a single cycle in the key
59    schedule generation process. The number of cycles needed
60    for each cx->n_col and nk value is:
61
62     nk =             4  5  6  7  8
63     ------------------------------
64     cx->n_col = 4   10  9  8  7  7
65     cx->n_col = 5   14 11 10  9  9
66     cx->n_col = 6   19 15 12 11 11
67     cx->n_col = 7   21 19 16 13 14
68     cx->n_col = 8   29 23 19 17 14
69 */
70
71 #define ke4(k,i) \
72 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
73     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
74 }
75 #define kel4(k,i) \
76 {   k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+5] = ss[1] ^= ss[0]; \
77     k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \
78 }
79
80 #define ke6(k,i) \
81 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
82     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
83     k[6*(i)+10] = ss[4] ^= ss[3]; k[6*(i)+11] = ss[5] ^= ss[4]; \
84 }
85 #define kel6(k,i) \
86 {   k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 7] = ss[1] ^= ss[0]; \
87     k[6*(i)+ 8] = ss[2] ^= ss[1]; k[6*(i)+ 9] = ss[3] ^= ss[2]; \
88 }
89
90 #define ke8(k,i) \
91 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
92     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
93     k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); k[8*(i)+13] = ss[5] ^= ss[4]; \
94     k[8*(i)+14] = ss[6] ^= ss[5]; k[8*(i)+15] = ss[7] ^= ss[6]; \
95 }
96 #define kel8(k,i) \
97 {   k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 9] = ss[1] ^= ss[0]; \
98     k[8*(i)+10] = ss[2] ^= ss[1]; k[8*(i)+11] = ss[3] ^= ss[2]; \
99 }
100
101 #if defined(ENCRYPTION_KEY_SCHEDULE)
102
103 #if defined(AES_128) || defined(AES_VAR)
104
105 aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1])
106 {   aes_32t    ss[4];
107
108     cx->ks[0] = ss[0] = word_in(in_key, 0);
109     cx->ks[1] = ss[1] = word_in(in_key, 1);
110     cx->ks[2] = ss[2] = word_in(in_key, 2);
111     cx->ks[3] = ss[3] = word_in(in_key, 3);
112
113 #if ENC_UNROLL == NONE
114     {   aes_32t i;
115
116         for(i = 0; i < ((11 * N_COLS - 1) / 4); ++i)
117             ke4(cx->ks, i);
118     }
119 #else
120     ke4(cx->ks, 0);  ke4(cx->ks, 1);
121     ke4(cx->ks, 2);  ke4(cx->ks, 3);
122     ke4(cx->ks, 4);  ke4(cx->ks, 5);
123     ke4(cx->ks, 6);  ke4(cx->ks, 7);
124     ke4(cx->ks, 8); kel4(cx->ks, 9);
125 #endif
126
127     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
128     /* key and must be non-zero for 128 and 192 bits keys   */
129     cx->ks[53] = cx->ks[45] = 0;
130     cx->ks[52] = 10;
131 #ifdef AES_ERR_CHK
132     return aes_good;
133 #endif
134 }
135
136 #endif
137
138 #if defined(AES_192) || defined(AES_VAR)
139
140 aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1])
141 {   aes_32t    ss[6];
142
143     cx->ks[0] = ss[0] = word_in(in_key, 0);
144     cx->ks[1] = ss[1] = word_in(in_key, 1);
145     cx->ks[2] = ss[2] = word_in(in_key, 2);
146     cx->ks[3] = ss[3] = word_in(in_key, 3);
147     cx->ks[4] = ss[4] = word_in(in_key, 4);
148     cx->ks[5] = ss[5] = word_in(in_key, 5);
149
150 #if ENC_UNROLL == NONE
151     {   aes_32t i;
152
153         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
154             ke6(cx->ks, i);
155     }
156 #else
157     ke6(cx->ks, 0);  ke6(cx->ks, 1);
158     ke6(cx->ks, 2);  ke6(cx->ks, 3);
159     ke6(cx->ks, 4);  ke6(cx->ks, 5);
160     ke6(cx->ks, 6); kel6(cx->ks, 7);
161 #endif
162
163     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
164     /* key and must be non-zero for 128 and 192 bits keys   */
165     cx->ks[53] = cx->ks[45];
166     cx->ks[52] = 12;
167 #ifdef AES_ERR_CHK
168     return aes_good;
169 #endif
170 }
171
172 #endif
173
174 #if defined(AES_256) || defined(AES_VAR)
175
176 aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1])
177 {   aes_32t    ss[8];
178
179     cx->ks[0] = ss[0] = word_in(in_key, 0);
180     cx->ks[1] = ss[1] = word_in(in_key, 1);
181     cx->ks[2] = ss[2] = word_in(in_key, 2);
182     cx->ks[3] = ss[3] = word_in(in_key, 3);
183     cx->ks[4] = ss[4] = word_in(in_key, 4);
184     cx->ks[5] = ss[5] = word_in(in_key, 5);
185     cx->ks[6] = ss[6] = word_in(in_key, 6);
186     cx->ks[7] = ss[7] = word_in(in_key, 7);
187
188 #if ENC_UNROLL == NONE
189     {   aes_32t i;
190
191         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
192             ke8(cx->ks,  i);
193     }
194 #else
195     ke8(cx->ks, 0); ke8(cx->ks, 1);
196     ke8(cx->ks, 2); ke8(cx->ks, 3);
197     ke8(cx->ks, 4); ke8(cx->ks, 5);
198     kel8(cx->ks, 6);
199 #endif
200 #ifdef AES_ERR_CHK
201     return aes_good;
202 #endif
203 }
204
205 #endif
206
207 #if defined(AES_VAR)
208
209 aes_rval aes_encrypt_key(const void *in_key, int key_len, aes_encrypt_ctx cx[1])
210 {
211     switch(key_len)
212     {
213 #ifdef AES_ERR_CHK
214     case 16: case 128: return aes_encrypt_key128(in_key, cx);
215     case 24: case 192: return aes_encrypt_key192(in_key, cx);
216     case 32: case 256: return aes_encrypt_key256(in_key, cx);
217     default: return aes_error;
218 #else
219     case 16: case 128: aes_encrypt_key128(in_key, cx); return;
220     case 24: case 192: aes_encrypt_key192(in_key, cx); return;
221     case 32: case 256: aes_encrypt_key256(in_key, cx); return;
222 #endif
223     }
224 }
225
226 #endif
227
228 #endif
229
230 #if defined(DECRYPTION_KEY_SCHEDULE)
231
232 #if DEC_ROUND == NO_TABLES
233 #define ff(x)   (x)
234 #else
235 #define ff(x)   inv_mcol(x)
236 #ifdef  dec_imvars
237 #define d_vars  dec_imvars
238 #endif
239 #endif
240
241 #if 1
242 #define kdf4(k,i) \
243 {   ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; ss[1] = ss[1] ^ ss[3]; ss[2] = ss[2] ^ ss[3]; ss[3] = ss[3]; \
244     ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
245     ss[4] ^= k[4*(i)];   k[4*(i)+4] = ff(ss[4]); ss[4] ^= k[4*(i)+1]; k[4*(i)+5] = ff(ss[4]); \
246     ss[4] ^= k[4*(i)+2]; k[4*(i)+6] = ff(ss[4]); ss[4] ^= k[4*(i)+3]; k[4*(i)+7] = ff(ss[4]); \
247 }
248 #define kd4(k,i) \
249 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \
250     k[4*(i)+4] = ss[4] ^= k[4*(i)]; k[4*(i)+5] = ss[4] ^= k[4*(i)+1]; \
251     k[4*(i)+6] = ss[4] ^= k[4*(i)+2]; k[4*(i)+7] = ss[4] ^= k[4*(i)+3]; \
252 }
253 #define kdl4(k,i) \
254 {   ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
255     k[4*(i)+4] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; k[4*(i)+5] = ss[1] ^ ss[3]; \
256     k[4*(i)+6] = ss[0]; k[4*(i)+7] = ss[1]; \
257 }
258 #else
259 #define kdf4(k,i) \
260 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ff(ss[0]); ss[1] ^= ss[0]; k[4*(i)+ 5] = ff(ss[1]); \
261     ss[2] ^= ss[1]; k[4*(i)+ 6] = ff(ss[2]); ss[3] ^= ss[2]; k[4*(i)+ 7] = ff(ss[3]); \
262 }
263 #define kd4(k,i) \
264 {   ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \
265     ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[4*(i)+ 4] = ss[4] ^= k[4*(i)]; \
266     ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[4] ^= k[4*(i)+ 1]; \
267     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[4] ^= k[4*(i)+ 2]; \
268     ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[4] ^= k[4*(i)+ 3]; \
269 }
270 #define kdl4(k,i) \
271 {   ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[4*(i)+ 4] = ss[0]; ss[1] ^= ss[0]; k[4*(i)+ 5] = ss[1]; \
272     ss[2] ^= ss[1]; k[4*(i)+ 6] = ss[2]; ss[3] ^= ss[2]; k[4*(i)+ 7] = ss[3]; \
273 }
274 #endif
275
276 #define kdf6(k,i) \
277 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ff(ss[0]); ss[1] ^= ss[0]; k[6*(i)+ 7] = ff(ss[1]); \
278     ss[2] ^= ss[1]; k[6*(i)+ 8] = ff(ss[2]); ss[3] ^= ss[2]; k[6*(i)+ 9] = ff(ss[3]); \
279     ss[4] ^= ss[3]; k[6*(i)+10] = ff(ss[4]); ss[5] ^= ss[4]; k[6*(i)+11] = ff(ss[5]); \
280 }
281 #define kd6(k,i) \
282 {   ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \
283     ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[6*(i)+ 6] = ss[6] ^= k[6*(i)]; \
284     ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[6] ^= k[6*(i)+ 1]; \
285     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[6] ^= k[6*(i)+ 2]; \
286     ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[6] ^= k[6*(i)+ 3]; \
287     ss[4] ^= ss[3]; k[6*(i)+10] = ss[6] ^= k[6*(i)+ 4]; \
288     ss[5] ^= ss[4]; k[6*(i)+11] = ss[6] ^= k[6*(i)+ 5]; \
289 }
290 #define kdl6(k,i) \
291 {   ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[6*(i)+ 6] = ss[0]; ss[1] ^= ss[0]; k[6*(i)+ 7] = ss[1]; \
292     ss[2] ^= ss[1]; k[6*(i)+ 8] = ss[2]; ss[3] ^= ss[2]; k[6*(i)+ 9] = ss[3]; \
293 }
294
295 #define kdf8(k,i) \
296 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ff(ss[0]); ss[1] ^= ss[0]; k[8*(i)+ 9] = ff(ss[1]); \
297     ss[2] ^= ss[1]; k[8*(i)+10] = ff(ss[2]); ss[3] ^= ss[2]; k[8*(i)+11] = ff(ss[3]); \
298     ss[4] ^= ls_box(ss[3],0); k[8*(i)+12] = ff(ss[4]); ss[5] ^= ss[4]; k[8*(i)+13] = ff(ss[5]); \
299     ss[6] ^= ss[5]; k[8*(i)+14] = ff(ss[6]); ss[7] ^= ss[6]; k[8*(i)+15] = ff(ss[7]); \
300 }
301 #define kd8(k,i) \
302 {   aes_32t g = ls_box(ss[7],3) ^ t_use(r,c)[i]; \
303     ss[0] ^= g; g = ff(g); k[8*(i)+ 8] = g ^= k[8*(i)]; \
304     ss[1] ^= ss[0]; k[8*(i)+ 9] = g ^= k[8*(i)+ 1]; \
305     ss[2] ^= ss[1]; k[8*(i)+10] = g ^= k[8*(i)+ 2]; \
306     ss[3] ^= ss[2]; k[8*(i)+11] = g ^= k[8*(i)+ 3]; \
307     g = ls_box(ss[3],0); \
308     ss[4] ^= g; g = ff(g); k[8*(i)+12] = g ^= k[8*(i)+ 4]; \
309     ss[5] ^= ss[4]; k[8*(i)+13] = g ^= k[8*(i)+ 5]; \
310     ss[6] ^= ss[5]; k[8*(i)+14] = g ^= k[8*(i)+ 6]; \
311     ss[7] ^= ss[6]; k[8*(i)+15] = g ^= k[8*(i)+ 7]; \
312 }
313 #define kdl8(k,i) \
314 {   ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[8*(i)+ 8] = ss[0]; ss[1] ^= ss[0]; k[8*(i)+ 9] = ss[1]; \
315     ss[2] ^= ss[1]; k[8*(i)+10] = ss[2]; ss[3] ^= ss[2]; k[8*(i)+11] = ss[3]; \
316 }
317
318 #if defined(AES_128) || defined(AES_VAR)
319
320 aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1])
321 {   aes_32t    ss[5];
322 #ifdef  d_vars
323         d_vars;
324 #endif
325     cx->ks[0] = ss[0] = word_in(in_key, 0);
326     cx->ks[1] = ss[1] = word_in(in_key, 1);
327     cx->ks[2] = ss[2] = word_in(in_key, 2);
328     cx->ks[3] = ss[3] = word_in(in_key, 3);
329
330 #if DEC_UNROLL == NONE
331     {   aes_32t i;
332
333         for(i = 0; i < (11 * N_COLS - 1) / 4; ++i)
334             ke4(cx->ks, i);
335 #if !(DEC_ROUND == NO_TABLES)
336         for(i = N_COLS; i < 10 * N_COLS; ++i)
337             cx->ks[i] = inv_mcol(cx->ks[i]);
338 #endif
339     }
340 #else
341     kdf4(cx->ks, 0);  kd4(cx->ks, 1);
342      kd4(cx->ks, 2);  kd4(cx->ks, 3);
343      kd4(cx->ks, 4);  kd4(cx->ks, 5);
344      kd4(cx->ks, 6);  kd4(cx->ks, 7);
345      kd4(cx->ks, 8); kdl4(cx->ks, 9);
346 #endif
347
348     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
349     /* key and must be non-zero for 128 and 192 bits keys   */
350     cx->ks[53] = cx->ks[45] = 0;
351     cx->ks[52] = 10;
352 #ifdef AES_ERR_CHK
353     return aes_good;
354 #endif
355 }
356
357 #endif
358
359 #if defined(AES_192) || defined(AES_VAR)
360
361 aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1])
362 {   aes_32t    ss[7];
363 #ifdef  d_vars
364         d_vars;
365 #endif
366     cx->ks[0] = ss[0] = word_in(in_key, 0);
367     cx->ks[1] = ss[1] = word_in(in_key, 1);
368     cx->ks[2] = ss[2] = word_in(in_key, 2);
369     cx->ks[3] = ss[3] = word_in(in_key, 3);
370
371 #if DEC_UNROLL == NONE
372     cx->ks[4] = ss[4] = word_in(in_key, 4);
373     cx->ks[5] = ss[5] = word_in(in_key, 5);
374     {   aes_32t i;
375
376         for(i = 0; i < (13 * N_COLS - 1) / 6; ++i)
377             ke6(cx->ks, i);
378 #if !(DEC_ROUND == NO_TABLES)
379         for(i = N_COLS; i < 12 * N_COLS; ++i)
380             cx->ks[i] = inv_mcol(cx->ks[i]);
381 #endif
382     }
383 #else
384     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
385     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
386     kdf6(cx->ks, 0); kd6(cx->ks, 1);
387     kd6(cx->ks, 2);  kd6(cx->ks, 3);
388     kd6(cx->ks, 4);  kd6(cx->ks, 5);
389     kd6(cx->ks, 6); kdl6(cx->ks, 7);
390 #endif
391
392     /* cx->ks[45] ^ cx->ks[52] ^ cx->ks[53] is zero for a 256 bit       */
393     /* key and must be non-zero for 128 and 192 bits keys   */
394     cx->ks[53] = cx->ks[45];
395     cx->ks[52] = 12;
396 #ifdef AES_ERR_CHK
397     return aes_good;
398 #endif
399 }
400
401 #endif
402
403 #if defined(AES_256) || defined(AES_VAR)
404
405 aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1])
406 {   aes_32t    ss[8];
407 #ifdef  d_vars
408         d_vars;
409 #endif
410     cx->ks[0] = ss[0] = word_in(in_key, 0);
411     cx->ks[1] = ss[1] = word_in(in_key, 1);
412     cx->ks[2] = ss[2] = word_in(in_key, 2);
413     cx->ks[3] = ss[3] = word_in(in_key, 3);
414
415 #if DEC_UNROLL == NONE
416     cx->ks[4] = ss[4] = word_in(in_key, 4);
417     cx->ks[5] = ss[5] = word_in(in_key, 5);
418     cx->ks[6] = ss[6] = word_in(in_key, 6);
419     cx->ks[7] = ss[7] = word_in(in_key, 7);
420     {   aes_32t i;
421
422         for(i = 0; i < (15 * N_COLS - 1) / 8; ++i)
423             ke8(cx->ks,  i);
424 #if !(DEC_ROUND == NO_TABLES)
425         for(i = N_COLS; i < 14 * N_COLS; ++i)
426             cx->ks[i] = inv_mcol(cx->ks[i]);
427 #endif
428     }
429 #else
430     cx->ks[4] = ff(ss[4] = word_in(in_key, 4));
431     cx->ks[5] = ff(ss[5] = word_in(in_key, 5));
432     cx->ks[6] = ff(ss[6] = word_in(in_key, 6));
433     cx->ks[7] = ff(ss[7] = word_in(in_key, 7));
434     kdf8(cx->ks, 0); kd8(cx->ks, 1);
435     kd8(cx->ks, 2);  kd8(cx->ks, 3);
436     kd8(cx->ks, 4);  kd8(cx->ks, 5);
437     kdl8(cx->ks, 6);
438 #endif
439 #ifdef AES_ERR_CHK
440     return aes_good;
441 #endif
442 }
443
444 #endif
445
446 #if defined(AES_VAR)
447
448 aes_rval aes_decrypt_key(const void *in_key, int key_len, aes_decrypt_ctx cx[1])
449 {
450     switch(key_len)
451     {
452 #ifdef AES_ERR_CHK
453     case 16: case 128: return aes_decrypt_key128(in_key, cx);
454     case 24: case 192: return aes_decrypt_key192(in_key, cx);
455     case 32: case 256: return aes_decrypt_key256(in_key, cx);
456     default: return aes_error;
457 #else
458     case 16: case 128: aes_decrypt_key128(in_key, cx); return;
459     case 24: case 192: aes_decrypt_key192(in_key, cx); return;
460     case 32: case 256: aes_decrypt_key256(in_key, cx); return;
461 #endif
462     }
463 }
464
465 #endif
466
467 #endif
468
469 #endif /* !HAVE_CRYPTO */
470
471 #if defined(__cplusplus)
472 }
473 #endif