cryptlib  3.4.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros
aeskey.c
Go to the documentation of this file.
1 /*
2  ---------------------------------------------------------------------------
3  Copyright (c) 1998-2006, Brian Gladman, Worcester, UK. All rights reserved.
4 
5  LICENSE TERMS
6 
7  The free distribution and use of this software in both source and binary
8  form is allowed (with or without changes) provided that:
9 
10  1. distributions of this source code include the above copyright
11  notice, this list of conditions and the following disclaimer;
12 
13  2. distributions in binary form include the above copyright
14  notice, this list of conditions and the following disclaimer
15  in the documentation and/or other associated materials;
16 
17  3. the copyright holder's name is not used to endorse products
18  built using this software without specific written permission.
19 
20  ALTERNATIVELY, provided that this notice is retained in full, this product
21  may be distributed under the terms of the GNU General Public License (GPL),
22  in which case the provisions of the GPL apply INSTEAD OF those given above.
23 
24  DISCLAIMER
25 
26  This software is provided 'as is' with no explicit or implied warranties
27  in respect of its properties, including, but not limited to, correctness
28  and/or fitness for purpose.
29  ---------------------------------------------------------------------------
30  Issue 09/09/2006
31 */
32 
33 #if defined( INC_ALL ) /* pcg */
34  #include "aesopt.h"
35  #include "aestab.h"
36  #ifdef USE_VIA_ACE_IF_PRESENT
37  #include "aes_via_ace.h"
38  #endif
39 #else
40  #include "crypt/aesopt.h"
41  #include "crypt/aestab.h"
42  #ifdef USE_VIA_ACE_IF_PRESENT
43  #include "crypt/aes_via_ace.h"
44  #endif
45 #endif /* Compiler-specific includes */
46 
47 #if defined(__cplusplus)
48 extern "C"
49 {
50 #endif
51 
52 /* Initialise the key schedule from the user supplied key. The key
53  length can be specified in bytes, with legal values of 16, 24
54  and 32, or in bits, with legal values of 128, 192 and 256. These
55  values correspond with Nk values of 4, 6 and 8 respectively.
56 
57  The following macros implement a single cycle in the key
58  schedule generation process. The number of cycles needed
59  for each cx->n_col and nk value is:
60 
61  nk = 4 5 6 7 8
62  ------------------------------
63  cx->n_col = 4 10 9 8 7 7
64  cx->n_col = 5 14 11 10 9 9
65  cx->n_col = 6 19 15 12 11 11
66  cx->n_col = 7 21 19 16 13 14
67  cx->n_col = 8 29 23 19 17 14
68 */
69 
70 #if (FUNCS_IN_C & ENC_KEYING_IN_C)
71 
72 #if defined(AES_128) || defined(AES_VAR)
73 
74 #define ke4(k,i) \
75 { k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \
76  k[4*(i)+5] = ss[1] ^= ss[0]; \
77  k[4*(i)+6] = ss[2] ^= ss[1]; \
78  k[4*(i)+7] = ss[3] ^= ss[2]; \
79 }
80 
81 AES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1])
82 { uint_32t ss[4];
83 
84  cx->ks[0] = ss[0] = word_in(key, 0);
85  cx->ks[1] = ss[1] = word_in(key, 1);
86  cx->ks[2] = ss[2] = word_in(key, 2);
87  cx->ks[3] = ss[3] = word_in(key, 3);
88 
89 #if ENC_UNROLL == NONE
90  { uint_32t i;
91  for(i = 0; i < 9; ++i)
92  ke4(cx->ks, i);
93  }
94 #else
95  ke4(cx->ks, 0);
96  ke4(cx->ks, 1);
97  ke4(cx->ks, 2); ke4(cx->ks, 3);
98  ke4(cx->ks, 4); ke4(cx->ks, 5);
99  ke4(cx->ks, 6); ke4(cx->ks, 7);
100  ke4(cx->ks, 8);
101 #endif
102  ke4(cx->ks, 9);
103  cx->inf.l = 0;
104  cx->inf.b[0] = 10 * 16;
105 
106 #ifdef USE_VIA_ACE_IF_PRESENT
107  if(VIA_ACE_AVAILABLE)
108  cx->inf.b[1] = 0xff;
109 #endif
110 
111 #if defined( AES_ERR_CHK )
112  return EXIT_SUCCESS;
113 #endif
114 }
115 
116 #endif
117 
118 #if defined(AES_192) || defined(AES_VAR)
119 
120 #define kef6(k,i) \
121 { k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \
122  k[6*(i)+ 7] = ss[1] ^= ss[0]; \
123  k[6*(i)+ 8] = ss[2] ^= ss[1]; \
124  k[6*(i)+ 9] = ss[3] ^= ss[2]; \
125 }
126 
127 #define ke6(k,i) \
128 { kef6(k,i); \
129  k[6*(i)+10] = ss[4] ^= ss[3]; \
130  k[6*(i)+11] = ss[5] ^= ss[4]; \
131 }
132 
133 AES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1])
134 { uint_32t ss[6];
135 
136  cx->ks[0] = ss[0] = word_in(key, 0);
137  cx->ks[1] = ss[1] = word_in(key, 1);
138  cx->ks[2] = ss[2] = word_in(key, 2);
139  cx->ks[3] = ss[3] = word_in(key, 3);
140  cx->ks[4] = ss[4] = word_in(key, 4);
141  cx->ks[5] = ss[5] = word_in(key, 5);
142 
143 #if ENC_UNROLL == NONE
144  { uint_32t i;
145  for(i = 0; i < 7; ++i)
146  ke6(cx->ks, i);
147  }
148 #else
149  ke6(cx->ks, 0); ke6(cx->ks, 1);
150  ke6(cx->ks, 2); ke6(cx->ks, 3);
151  ke6(cx->ks, 4); ke6(cx->ks, 5);
152  ke6(cx->ks, 6);
153 #endif
154  kef6(cx->ks, 7);
155  cx->inf.l = 0;
156  cx->inf.b[0] = 12 * 16;
157 
158 #ifdef USE_VIA_ACE_IF_PRESENT
159  if(VIA_ACE_AVAILABLE)
160  cx->inf.b[1] = 0xff;
161 #endif
162 
163 #if defined( AES_ERR_CHK )
164  return EXIT_SUCCESS;
165 #endif
166 }
167 
168 #endif
169 
170 #if defined(AES_256) || defined(AES_VAR)
171 
172 #define kef8(k,i) \
173 { k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \
174  k[8*(i)+ 9] = ss[1] ^= ss[0]; \
175  k[8*(i)+10] = ss[2] ^= ss[1]; \
176  k[8*(i)+11] = ss[3] ^= ss[2]; \
177 }
178 
179 #define ke8(k,i) \
180 { kef8(k,i); \
181  k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); \
182  k[8*(i)+13] = ss[5] ^= ss[4]; \
183  k[8*(i)+14] = ss[6] ^= ss[5]; \
184  k[8*(i)+15] = ss[7] ^= ss[6]; \
185 }
186 
187 AES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1])
188 { uint_32t ss[8];
189 
190  cx->ks[0] = ss[0] = word_in(key, 0);
191  cx->ks[1] = ss[1] = word_in(key, 1);
192  cx->ks[2] = ss[2] = word_in(key, 2);
193  cx->ks[3] = ss[3] = word_in(key, 3);
194  cx->ks[4] = ss[4] = word_in(key, 4);
195  cx->ks[5] = ss[5] = word_in(key, 5);
196  cx->ks[6] = ss[6] = word_in(key, 6);
197  cx->ks[7] = ss[7] = word_in(key, 7);
198 
199 #if ENC_UNROLL == NONE
200  { uint_32t i;
201  for(i = 0; i < 6; ++i)
202  ke8(cx->ks, i);
203  }
204 #else
205  ke8(cx->ks, 0); ke8(cx->ks, 1);
206  ke8(cx->ks, 2); ke8(cx->ks, 3);
207  ke8(cx->ks, 4); ke8(cx->ks, 5);
208 #endif
209  kef8(cx->ks, 6);
210  cx->inf.l = 0;
211  cx->inf.b[0] = 14 * 16;
212 
213 #ifdef USE_VIA_ACE_IF_PRESENT
214  if(VIA_ACE_AVAILABLE)
215  cx->inf.b[1] = 0xff;
216 #endif
217 
218 #if defined( AES_ERR_CHK )
219  return EXIT_SUCCESS;
220 #endif
221 }
222 
223 #endif
224 
225 #if defined(AES_VAR)
226 
227 AES_RETURN aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1])
228 {
229  switch(key_len)
230  {
231 #if defined( AES_ERR_CHK )
232  case 16: case 128: return aes_encrypt_key128(key, cx);
233  case 24: case 192: return aes_encrypt_key192(key, cx);
234  case 32: case 256: return aes_encrypt_key256(key, cx);
235  default: return EXIT_FAILURE;
236 #else
237  case 16: case 128: aes_encrypt_key128(key, cx); return;
238  case 24: case 192: aes_encrypt_key192(key, cx); return;
239  case 32: case 256: aes_encrypt_key256(key, cx); return;
240 #endif
241  }
242 }
243 
244 #endif
245 
246 #endif
247 
248 #if (FUNCS_IN_C & DEC_KEYING_IN_C)
249 
250 /* this is used to store the decryption round keys */
251 /* in forward or reverse order */
252 
253 #ifdef AES_REV_DKS
254 #define v(n,i) ((n) - (i) + 2 * ((i) & 3))
255 #else
256 #define v(n,i) (i)
257 #endif
258 
259 #if DEC_ROUND == NO_TABLES
260 #define ff(x) (x)
261 #else
262 #define ff(x) inv_mcol(x)
263 #if defined( dec_imvars )
264 #define d_vars dec_imvars
265 #endif
266 #endif
267 
268 #if defined(AES_128) || defined(AES_VAR)
269 
270 #define k4e(k,i) \
271 { k[v(40,(4*(i))+4)] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \
272  k[v(40,(4*(i))+5)] = ss[1] ^= ss[0]; \
273  k[v(40,(4*(i))+6)] = ss[2] ^= ss[1]; \
274  k[v(40,(4*(i))+7)] = ss[3] ^= ss[2]; \
275 }
276 
277 #if 1
278 
279 #define kdf4(k,i) \
280 { ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; \
281  ss[1] = ss[1] ^ ss[3]; \
282  ss[2] = ss[2] ^ ss[3]; \
283  ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \
284  ss[i % 4] ^= ss[4]; \
285  ss[4] ^= k[v(40,(4*(i)))]; k[v(40,(4*(i))+4)] = ff(ss[4]); \
286  ss[4] ^= k[v(40,(4*(i))+1)]; k[v(40,(4*(i))+5)] = ff(ss[4]); \
287  ss[4] ^= k[v(40,(4*(i))+2)]; k[v(40,(4*(i))+6)] = ff(ss[4]); \
288  ss[4] ^= k[v(40,(4*(i))+3)]; k[v(40,(4*(i))+7)] = ff(ss[4]); \
289 }
290 
291 #define kd4(k,i) \
292 { ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \
293  ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \
294  k[v(40,(4*(i))+4)] = ss[4] ^= k[v(40,(4*(i)))]; \
295  k[v(40,(4*(i))+5)] = ss[4] ^= k[v(40,(4*(i))+1)]; \
296  k[v(40,(4*(i))+6)] = ss[4] ^= k[v(40,(4*(i))+2)]; \
297  k[v(40,(4*(i))+7)] = ss[4] ^= k[v(40,(4*(i))+3)]; \
298 }
299 
300 #define kdl4(k,i) \
301 { ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \
302  k[v(40,(4*(i))+4)] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; \
303  k[v(40,(4*(i))+5)] = ss[1] ^ ss[3]; \
304  k[v(40,(4*(i))+6)] = ss[0]; \
305  k[v(40,(4*(i))+7)] = ss[1]; \
306 }
307 
308 #else
309 
310 #define kdf4(k,i) \
311 { ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ff(ss[0]); \
312  ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ff(ss[1]); \
313  ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ff(ss[2]); \
314  ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ff(ss[3]); \
315 }
316 
317 #define kd4(k,i) \
318 { ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \
319  ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[v(40,(4*(i))+ 4)] = ss[4] ^= k[v(40,(4*(i)))]; \
320  ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[4] ^= k[v(40,(4*(i))+ 1)]; \
321  ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[4] ^= k[v(40,(4*(i))+ 2)]; \
322  ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[4] ^= k[v(40,(4*(i))+ 3)]; \
323 }
324 
325 #define kdl4(k,i) \
326 { ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ss[0]; \
327  ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[1]; \
328  ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[2]; \
329  ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[3]; \
330 }
331 
332 #endif
333 
334 AES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1])
335 { uint_32t ss[5];
336 #if defined( d_vars )
337  d_vars;
338 #endif
339  cx->ks[v(40,(0))] = ss[0] = word_in(key, 0);
340  cx->ks[v(40,(1))] = ss[1] = word_in(key, 1);
341  cx->ks[v(40,(2))] = ss[2] = word_in(key, 2);
342  cx->ks[v(40,(3))] = ss[3] = word_in(key, 3);
343 
344 #if DEC_UNROLL == NONE
345  { uint_32t i;
346  for(i = 0; i < 10; ++i)
347  k4e(cx->ks, i);
348 #if !(DEC_ROUND == NO_TABLES)
349  for(i = N_COLS; i < 10 * N_COLS; ++i)
350  cx->ks[i] = inv_mcol(cx->ks[i]);
351 #endif
352  }
353 #else
354  kdf4(cx->ks, 0);
355  kd4(cx->ks, 1);
356  kd4(cx->ks, 2); kd4(cx->ks, 3);
357  kd4(cx->ks, 4); kd4(cx->ks, 5);
358  kd4(cx->ks, 6); kd4(cx->ks, 7);
359  kd4(cx->ks, 8); kdl4(cx->ks, 9);
360 #endif
361  cx->inf.l = 0;
362  cx->inf.b[0] = 10 * 16;
363 
364 #ifdef USE_VIA_ACE_IF_PRESENT
365  if(VIA_ACE_AVAILABLE)
366  cx->inf.b[1] = 0xff;
367 #endif
368 
369 #if defined( AES_ERR_CHK )
370  return EXIT_SUCCESS;
371 #endif
372 }
373 
374 #endif
375 
376 #if defined(AES_192) || defined(AES_VAR)
377 
378 #define k6ef(k,i) \
379 { k[v(48,(6*(i))+ 6)] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \
380  k[v(48,(6*(i))+ 7)] = ss[1] ^= ss[0]; \
381  k[v(48,(6*(i))+ 8)] = ss[2] ^= ss[1]; \
382  k[v(48,(6*(i))+ 9)] = ss[3] ^= ss[2]; \
383 }
384 
385 #define k6e(k,i) \
386 { k6ef(k,i); \
387  k[v(48,(6*(i))+10)] = ss[4] ^= ss[3]; \
388  k[v(48,(6*(i))+11)] = ss[5] ^= ss[4]; \
389 }
390 
391 #define kdf6(k,i) \
392 { ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ff(ss[0]); \
393  ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ff(ss[1]); \
394  ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ff(ss[2]); \
395  ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ff(ss[3]); \
396  ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ff(ss[4]); \
397  ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ff(ss[5]); \
398 }
399 
400 #define kd6(k,i) \
401 { ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \
402  ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[v(48,(6*(i))+ 6)] = ss[6] ^= k[v(48,(6*(i)))]; \
403  ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[6] ^= k[v(48,(6*(i))+ 1)]; \
404  ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[6] ^= k[v(48,(6*(i))+ 2)]; \
405  ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[6] ^= k[v(48,(6*(i))+ 3)]; \
406  ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ss[6] ^= k[v(48,(6*(i))+ 4)]; \
407  ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ss[6] ^= k[v(48,(6*(i))+ 5)]; \
408 }
409 
410 #define kdl6(k,i) \
411 { ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ss[0]; \
412  ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[1]; \
413  ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[2]; \
414  ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[3]; \
415 }
416 
417 AES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1])
418 { uint_32t ss[7];
419 #if defined( d_vars )
420  d_vars;
421 #endif
422  cx->ks[v(48,(0))] = ss[0] = word_in(key, 0);
423  cx->ks[v(48,(1))] = ss[1] = word_in(key, 1);
424  cx->ks[v(48,(2))] = ss[2] = word_in(key, 2);
425  cx->ks[v(48,(3))] = ss[3] = word_in(key, 3);
426 
427 #if DEC_UNROLL == NONE
428  cx->ks[v(48,(4))] = ss[4] = word_in(key, 4);
429  cx->ks[v(48,(5))] = ss[5] = word_in(key, 5);
430  { uint_32t i;
431 
432  for(i = 0; i < 7; ++i)
433  k6e(cx->ks, i);
434  k6ef(cx->ks, 7);
435 #if !(DEC_ROUND == NO_TABLES)
436  for(i = N_COLS; i < 12 * N_COLS; ++i)
437  cx->ks[i] = inv_mcol(cx->ks[i]);
438 #endif
439  }
440 #else
441  cx->ks[v(48,(4))] = ff(ss[4] = word_in(key, 4));
442  cx->ks[v(48,(5))] = ff(ss[5] = word_in(key, 5));
443  kdf6(cx->ks, 0); kd6(cx->ks, 1);
444  kd6(cx->ks, 2); kd6(cx->ks, 3);
445  kd6(cx->ks, 4); kd6(cx->ks, 5);
446  kd6(cx->ks, 6); kdl6(cx->ks, 7);
447 #endif
448  cx->inf.l = 0;
449  cx->inf.b[0] = 12 * 16;
450 
451 #ifdef USE_VIA_ACE_IF_PRESENT
452  if(VIA_ACE_AVAILABLE)
453  cx->inf.b[1] = 0xff;
454 #endif
455 
456 #if defined( AES_ERR_CHK )
457  return EXIT_SUCCESS;
458 #endif
459 }
460 
461 #endif
462 
463 #if defined(AES_256) || defined(AES_VAR)
464 
465 #define k8ef(k,i) \
466 { k[v(56,(8*(i))+ 8)] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \
467  k[v(56,(8*(i))+ 9)] = ss[1] ^= ss[0]; \
468  k[v(56,(8*(i))+10)] = ss[2] ^= ss[1]; \
469  k[v(56,(8*(i))+11)] = ss[3] ^= ss[2]; \
470 }
471 
472 #define k8e(k,i) \
473 { k8ef(k,i); \
474  k[v(56,(8*(i))+12)] = ss[4] ^= ls_box(ss[3],0); \
475  k[v(56,(8*(i))+13)] = ss[5] ^= ss[4]; \
476  k[v(56,(8*(i))+14)] = ss[6] ^= ss[5]; \
477  k[v(56,(8*(i))+15)] = ss[7] ^= ss[6]; \
478 }
479 
480 #define kdf8(k,i) \
481 { ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ff(ss[0]); \
482  ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ff(ss[1]); \
483  ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ff(ss[2]); \
484  ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ff(ss[3]); \
485  ss[4] ^= ls_box(ss[3],0); k[v(56,(8*(i))+12)] = ff(ss[4]); \
486  ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ff(ss[5]); \
487  ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ff(ss[6]); \
488  ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ff(ss[7]); \
489 }
490 
491 #define kd8(k,i) \
492 { ss[8] = ls_box(ss[7],3) ^ t_use(r,c)[i]; \
493  ss[0] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+ 8)] = ss[8] ^= k[v(56,(8*(i)))]; \
494  ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[8] ^= k[v(56,(8*(i))+ 1)]; \
495  ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[8] ^= k[v(56,(8*(i))+ 2)]; \
496  ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[8] ^= k[v(56,(8*(i))+ 3)]; \
497  ss[8] = ls_box(ss[3],0); \
498  ss[4] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+12)] = ss[8] ^= k[v(56,(8*(i))+ 4)]; \
499  ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ss[8] ^= k[v(56,(8*(i))+ 5)]; \
500  ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ss[8] ^= k[v(56,(8*(i))+ 6)]; \
501  ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ss[8] ^= k[v(56,(8*(i))+ 7)]; \
502 }
503 
504 #define kdl8(k,i) \
505 { ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ss[0]; \
506  ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[1]; \
507  ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[2]; \
508  ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[3]; \
509 }
510 
511 AES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1])
512 { uint_32t ss[9];
513 #if defined( d_vars )
514  d_vars;
515 #endif
516  cx->ks[v(56,(0))] = ss[0] = word_in(key, 0);
517  cx->ks[v(56,(1))] = ss[1] = word_in(key, 1);
518  cx->ks[v(56,(2))] = ss[2] = word_in(key, 2);
519  cx->ks[v(56,(3))] = ss[3] = word_in(key, 3);
520 
521 #if DEC_UNROLL == NONE
522  cx->ks[v(56,(4))] = ss[4] = word_in(key, 4);
523  cx->ks[v(56,(5))] = ss[5] = word_in(key, 5);
524  cx->ks[v(56,(6))] = ss[6] = word_in(key, 6);
525  cx->ks[v(56,(7))] = ss[7] = word_in(key, 7);
526  { uint_32t i;
527 
528  for(i = 0; i < 6; ++i)
529  k8e(cx->ks, i);
530  k8ef(cx->ks, 6);
531 #if !(DEC_ROUND == NO_TABLES)
532  for(i = N_COLS; i < 14 * N_COLS; ++i)
533  cx->ks[i] = inv_mcol(cx->ks[i]);
534 
535 #endif
536  }
537 #else
538  cx->ks[v(56,(4))] = ff(ss[4] = word_in(key, 4));
539  cx->ks[v(56,(5))] = ff(ss[5] = word_in(key, 5));
540  cx->ks[v(56,(6))] = ff(ss[6] = word_in(key, 6));
541  cx->ks[v(56,(7))] = ff(ss[7] = word_in(key, 7));
542  kdf8(cx->ks, 0); kd8(cx->ks, 1);
543  kd8(cx->ks, 2); kd8(cx->ks, 3);
544  kd8(cx->ks, 4); kd8(cx->ks, 5);
545  kdl8(cx->ks, 6);
546 #endif
547  cx->inf.l = 0;
548  cx->inf.b[0] = 14 * 16;
549 
550 #ifdef USE_VIA_ACE_IF_PRESENT
551  if(VIA_ACE_AVAILABLE)
552  cx->inf.b[1] = 0xff;
553 #endif
554 
555 #if defined( AES_ERR_CHK )
556  return EXIT_SUCCESS;
557 #endif
558 }
559 
560 #endif
561 
562 #if defined(AES_VAR)
563 
564 AES_RETURN aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1])
565 {
566  switch(key_len)
567  {
568 #if defined( AES_ERR_CHK )
569  case 16: case 128: return aes_decrypt_key128(key, cx);
570  case 24: case 192: return aes_decrypt_key192(key, cx);
571  case 32: case 256: return aes_decrypt_key256(key, cx);
572  default: return EXIT_FAILURE;
573 #else
574  case 16: case 128: aes_decrypt_key128(key, cx); return;
575  case 24: case 192: aes_decrypt_key192(key, cx); return;
576  case 32: case 256: aes_decrypt_key256(key, cx); return;
577 #endif
578  }
579 }
580 
581 #endif
582 
583 #endif
584 
585 #if defined(__cplusplus)
586 }
587 #endif
Generated on Thu Jan 10 2013 10:00:45 for cryptlib by   doxygen 1.8.2