Merged revisions 111125 via svnmerge from
[asterisk-bristuff.git] / main / aesopt.h
blobbb4f05a0b89a0065cd9a803a9d4259a49b21879c
1 /*
2 ---------------------------------------------------------------------------
3 Copyright (c) 2003, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
4 All rights reserved.
6 LICENSE TERMS
8 The free distribution and use of this software in both source and binary
9 form is allowed (with or without changes) provided that:
11 1. distributions of this source code include the above copyright
12 notice, this list of conditions and the following disclaimer;
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;
18 3. the copyright holder's name is not used to endorse products
19 built using this software without specific written permission.
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.
25 DISCLAIMER
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
33 My thanks go to Dag Arne Osvik for devising the schemes used here for key
34 length derivation from the form of the key schedule
36 This file contains the compilation options for AES (Rijndael) and code
37 that is common across encryption, key scheduling and table generation.
39 OPERATION
41 These source code files implement the AES algorithm Rijndael designed by
42 Joan Daemen and Vincent Rijmen. This version is designed for the standard
43 block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24
44 and 32 bytes).
46 This version is designed for flexibility and speed using operations on
47 32-bit words rather than operations on bytes. It can be compiled with
48 either big or little endian internal byte order but is faster when the
49 native byte order for the processor is used.
51 THE CIPHER INTERFACE
53 The cipher interface is implemented as an array of bytes in which lower
54 AES bit sequence indexes map to higher numeric significance within bytes.
56 aes_08t (an unsigned 8-bit type)
57 aes_32t (an unsigned 32-bit type)
58 struct aes_encrypt_ctx (structure for the cipher encryption context)
59 struct aes_decrypt_ctx (structure for the cipher decryption context)
60 aes_rval the function return type
62 C subroutine calls:
64 aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1]);
65 aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1]);
66 aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1]);
67 aes_rval aes_encrypt(const void *in_blk,
68 void *out_blk, const aes_encrypt_ctx cx[1]);
70 aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1]);
71 aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1]);
72 aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1]);
73 aes_rval aes_decrypt(const void *in_blk,
74 void *out_blk, const aes_decrypt_ctx cx[1]);
76 IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that
77 you call genTabs() before AES is used so that the tables are initialised.
79 C++ aes class subroutines:
81 Class AESencrypt for encryption
83 Construtors:
84 AESencrypt(void)
85 AESencrypt(const void *in_key) - 128 bit key
86 Members:
87 void key128(const void *in_key)
88 void key192(const void *in_key)
89 void key256(const void *in_key)
90 void encrypt(const void *in_blk, void *out_blk) const
92 Class AESdecrypt for encryption
93 Construtors:
94 AESdecrypt(void)
95 AESdecrypt(const void *in_key) - 128 bit key
96 Members:
97 void key128(const void *in_key)
98 void key192(const void *in_key)
99 void key256(const void *in_key)
100 void decrypt(const void *in_blk, void *out_blk) const
102 COMPILATION
104 The files used to provide AES (Rijndael) are
106 a. aes.h for the definitions needed for use in C.
107 b. aescpp.h for the definitions needed for use in C++.
108 c. aesopt.h for setting compilation options (also includes common code).
109 d. aescrypt.c for encryption and decrytpion, or
110 e. aeskey.c for key scheduling.
111 f. aestab.c for table loading or generation.
112 g. aescrypt.asm for encryption and decryption using assembler code.
113 h. aescrypt.mmx.asm for encryption and decryption using MMX assembler.
115 To compile AES (Rijndael) for use in C code use aes.h and set the
116 defines here for the facilities you need (key lengths, encryption
117 and/or decryption). Do not define AES_DLL or AES_CPP. Set the options
118 for optimisations and table sizes here.
120 To compile AES (Rijndael) for use in in C++ code use aescpp.h but do
121 not define AES_DLL
123 To compile AES (Rijndael) in C as a Dynamic Link Library DLL) use
124 aes.h and include the AES_DLL define.
126 CONFIGURATION OPTIONS (here and in aes.h)
128 a. set AES_DLL in aes.h if AES (Rijndael) is to be compiled as a DLL
129 b. You may need to set PLATFORM_BYTE_ORDER to define the byte order.
130 c. If you want the code to run in a specific internal byte order, then
131 ALGORITHM_BYTE_ORDER must be set accordingly.
132 d. set other configuration options decribed below.
135 #ifndef _AESOPT_H
136 #define _AESOPT_H
138 #include "asterisk/aes.h"
139 #include "asterisk/endian.h"
141 /* CONFIGURATION - USE OF DEFINES
143 Later in this section there are a number of defines that control the
144 operation of the code. In each section, the purpose of each define is
145 explained so that the relevant form can be included or excluded by
146 setting either 1's or 0's respectively on the branches of the related
147 #if clauses.
150 /* BYTE ORDER IN 32-BIT WORDS
152 To obtain the highest speed on processors with 32-bit words, this code
153 needs to determine the byte order of the target machine. The following
154 block of code is an attempt to capture the most obvious ways in which
155 various environemnts define byte order. It may well fail, in which case
156 the definitions will need to be set by editing at the points marked
157 **** EDIT HERE IF NECESSARY **** below. My thanks to Peter Gutmann for
158 some of these defines (from cryptlib).
161 #define BRG_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */
162 #define BRG_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */
164 #if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \
165 defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \
166 defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \
167 defined( vax ) || defined( vms ) || defined( VMS ) || \
168 defined( __VMS )
170 #define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
172 #endif
174 #if defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \
175 defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \
176 defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \
177 defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \
178 defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \
179 defined( __TANDEM ) || defined( THINK_C ) || defined( __VMCMS__ )
181 #define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
183 #endif
185 /* if the platform is still not known, try to find its byte order */
186 /* from commonly used definitions in the headers included earlier */
188 #if !defined(PLATFORM_BYTE_ORDER)
190 #if defined(LITTLE_ENDIAN) || defined(BIG_ENDIAN)
191 # if defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
192 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
193 # elif !defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
194 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
195 # elif defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
196 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
197 # elif defined(BYTE_ORDER) && (BYTE_ORDER == BIG_ENDIAN)
198 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
199 # endif
201 #elif defined(_LITTLE_ENDIAN) || defined(_BIG_ENDIAN)
202 # if defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
203 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
204 # elif !defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
205 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
206 # elif defined(_BYTE_ORDER) && (_BYTE_ORDER == _LITTLE_ENDIAN)
207 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
208 # elif defined(_BYTE_ORDER) && (_BYTE_ORDER == _BIG_ENDIAN)
209 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
210 # endif
212 #elif defined(__LITTLE_ENDIAN__) || defined(__BIG_ENDIAN__)
213 # if defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
214 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
215 # elif !defined(__LITTLE_ENDIAN__) && defined(__BIG_ENDIAN__)
216 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
217 # elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __LITTLE_ENDIAN__)
218 # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
219 # elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __BIG_ENDIAN__)
220 # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
221 # endif
223 #elif 0 /* **** EDIT HERE IF NECESSARY **** */
224 #define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
226 #elif 0 /* **** EDIT HERE IF NECESSARY **** */
227 #define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
229 #else
230 #error Please edit aesopt.h (line 235 or 238) to set the platform byte order
231 #endif
233 #endif
235 /* SOME LOCAL DEFINITIONS */
237 #define NO_TABLES 0
238 #define ONE_TABLE 1
239 #define FOUR_TABLES 4
240 #define NONE 0
241 #define PARTIAL 1
242 #define FULL 2
244 #if defined(bswap32)
245 #define aes_sw32 bswap32
246 #elif defined(bswap_32)
247 #define aes_sw32 bswap_32
248 #else
249 #define brot(x,n) (((aes_32t)(x) << n) | ((aes_32t)(x) >> (32 - n)))
250 #define aes_sw32(x) ((brot((x),8) & 0x00ff00ff) | (brot((x),24) & 0xff00ff00))
251 #endif
253 /* 1. FUNCTIONS REQUIRED
255 This implementation provides subroutines for encryption, decryption
256 and for setting the three key lengths (separately) for encryption
257 and decryption. When the assembler code is not being used the following
258 definition blocks allow the selection of the routines that are to be
259 included in the compilation.
261 #ifdef AES_ENCRYPT
262 #define ENCRYPTION
263 #define ENCRYPTION_KEY_SCHEDULE
264 #endif
266 #ifdef AES_DECRYPT
267 #define DECRYPTION
268 #define DECRYPTION_KEY_SCHEDULE
269 #endif
271 /* 2. ASSEMBLER SUPPORT
273 This define (which can be on the command line) enables the use of the
274 assembler code routines for encryption and decryption with the C code
275 only providing key scheduling
277 #if 0
278 #define AES_ASM
279 #endif
281 /* 3. BYTE ORDER WITHIN 32 BIT WORDS
283 The fundamental data processing units in Rijndael are 8-bit bytes. The
284 input, output and key input are all enumerated arrays of bytes in which
285 bytes are numbered starting at zero and increasing to one less than the
286 number of bytes in the array in question. This enumeration is only used
287 for naming bytes and does not imply any adjacency or order relationship
288 from one byte to another. When these inputs and outputs are considered
289 as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to
290 byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte.
291 In this implementation bits are numbered from 0 to 7 starting at the
292 numerically least significant end of each byte (bit n represents 2^n).
294 However, Rijndael can be implemented more efficiently using 32-bit
295 words by packing bytes into words so that bytes 4*n to 4*n+3 are placed
296 into word[n]. While in principle these bytes can be assembled into words
297 in any positions, this implementation only supports the two formats in
298 which bytes in adjacent positions within words also have adjacent byte
299 numbers. This order is called big-endian if the lowest numbered bytes
300 in words have the highest numeric significance and little-endian if the
301 opposite applies.
303 This code can work in either order irrespective of the order used by the
304 machine on which it runs. Normally the internal byte order will be set
305 to the order of the processor on which the code is to be run but this
306 define can be used to reverse this in special situations
308 NOTE: Assembler code versions rely on PLATFORM_BYTE_ORDER being set
310 #if 1 || defined(AES_ASM)
311 #define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER
312 #elif 0
313 #define ALGORITHM_BYTE_ORDER BRG_LITTLE_ENDIAN
314 #elif 0
315 #define ALGORITHM_BYTE_ORDER BRG_BIG_ENDIAN
316 #else
317 #error The algorithm byte order is not defined
318 #endif
320 /* 4. FAST INPUT/OUTPUT OPERATIONS.
322 On some machines it is possible to improve speed by transferring the
323 bytes in the input and output arrays to and from the internal 32-bit
324 variables by addressing these arrays as if they are arrays of 32-bit
325 words. On some machines this will always be possible but there may
326 be a large performance penalty if the byte arrays are not aligned on
327 the normal word boundaries. On other machines this technique will
328 lead to memory access errors when such 32-bit word accesses are not
329 properly aligned. The option SAFE_IO avoids such problems but will
330 often be slower on those machines that support misaligned access
331 (especially so if care is taken to align the input and output byte
332 arrays on 32-bit word boundaries). If SAFE_IO is not defined it is
333 assumed that access to byte arrays as if they are arrays of 32-bit
334 words will not cause problems when such accesses are misaligned.
336 #if 1 && !defined(_MSC_VER)
337 #define SAFE_IO
338 #endif
340 /* 5. LOOP UNROLLING
342 The code for encryption and decrytpion cycles through a number of rounds
343 that can be implemented either in a loop or by expanding the code into a
344 long sequence of instructions, the latter producing a larger program but
345 one that will often be much faster. The latter is called loop unrolling.
346 There are also potential speed advantages in expanding two iterations in
347 a loop with half the number of iterations, which is called partial loop
348 unrolling. The following options allow partial or full loop unrolling
349 to be set independently for encryption and decryption
351 #if 1
352 #define ENC_UNROLL FULL
353 #elif 0
354 #define ENC_UNROLL PARTIAL
355 #else
356 #define ENC_UNROLL NONE
357 #endif
359 #if 1
360 #define DEC_UNROLL FULL
361 #elif 0
362 #define DEC_UNROLL PARTIAL
363 #else
364 #define DEC_UNROLL NONE
365 #endif
367 /* 6. FAST FINITE FIELD OPERATIONS
369 If this section is included, tables are used to provide faster finite
370 field arithmetic (this has no effect if FIXED_TABLES is defined).
372 #if 1
373 #define FF_TABLES
374 #endif
376 /* 7. INTERNAL STATE VARIABLE FORMAT
378 The internal state of Rijndael is stored in a number of local 32-bit
379 word varaibles which can be defined either as an array or as individual
380 names variables. Include this section if you want to store these local
381 varaibles in arrays. Otherwise individual local variables will be used.
383 #if 1
384 #define ARRAYS
385 #endif
387 /* In this implementation the columns of the state array are each held in
388 32-bit words. The state array can be held in various ways: in an array
389 of words, in a number of individual word variables or in a number of
390 processor registers. The following define maps a variable name x and
391 a column number c to the way the state array variable is to be held.
392 The first define below maps the state into an array x[c] whereas the
393 second form maps the state into a number of individual variables x0,
394 x1, etc. Another form could map individual state colums to machine
395 register names.
398 #if defined(ARRAYS)
399 #define s(x,c) x[c]
400 #else
401 #define s(x,c) x##c
402 #endif
404 /* 8. FIXED OR DYNAMIC TABLES
406 When this section is included the tables used by the code are compiled
407 statically into the binary file. Otherwise the subroutine gen_tabs()
408 must be called to compute them before the code is first used.
410 #if 1
411 #define FIXED_TABLES
412 #endif
414 /* 9. TABLE ALIGNMENT
416 On some sytsems speed will be improved by aligning the AES large lookup
417 tables on particular boundaries. This define should be set to a power of
418 two giving the desired alignment. It can be left undefined if alignment
419 is not needed. This option is specific to the Microsft VC++ compiler -
420 it seems to sometimes cause trouble for the VC++ version 6 compiler.
423 #if 0 && defined(_MSC_VER) && (_MSC_VER >= 1300)
424 #define TABLE_ALIGN 64
425 #endif
427 /* 10. INTERNAL TABLE CONFIGURATION
429 This cipher proceeds by repeating in a number of cycles known as 'rounds'
430 which are implemented by a round function which can optionally be speeded
431 up using tables. The basic tables are each 256 32-bit words, with either
432 one or four tables being required for each round function depending on
433 how much speed is required. The encryption and decryption round functions
434 are different and the last encryption and decrytpion round functions are
435 different again making four different round functions in all.
437 This means that:
438 1. Normal encryption and decryption rounds can each use either 0, 1
439 or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
440 2. The last encryption and decryption rounds can also use either 0, 1
441 or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
443 Include or exclude the appropriate definitions below to set the number
444 of tables used by this implementation.
447 #if 1 /* set tables for the normal encryption round */
448 #define ENC_ROUND FOUR_TABLES
449 #elif 0
450 #define ENC_ROUND ONE_TABLE
451 #else
452 #define ENC_ROUND NO_TABLES
453 #endif
455 #if 1 /* set tables for the last encryption round */
456 #define LAST_ENC_ROUND FOUR_TABLES
457 #elif 0
458 #define LAST_ENC_ROUND ONE_TABLE
459 #else
460 #define LAST_ENC_ROUND NO_TABLES
461 #endif
463 #if 1 /* set tables for the normal decryption round */
464 #define DEC_ROUND FOUR_TABLES
465 #elif 0
466 #define DEC_ROUND ONE_TABLE
467 #else
468 #define DEC_ROUND NO_TABLES
469 #endif
471 #if 1 /* set tables for the last decryption round */
472 #define LAST_DEC_ROUND FOUR_TABLES
473 #elif 0
474 #define LAST_DEC_ROUND ONE_TABLE
475 #else
476 #define LAST_DEC_ROUND NO_TABLES
477 #endif
479 /* The decryption key schedule can be speeded up with tables in the same
480 way that the round functions can. Include or exclude the following
481 defines to set this requirement.
483 #if 1
484 #define KEY_SCHED FOUR_TABLES
485 #elif 0
486 #define KEY_SCHED ONE_TABLE
487 #else
488 #define KEY_SCHED NO_TABLES
489 #endif
491 /* END OF CONFIGURATION OPTIONS */
493 #define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))
495 /* Disable or report errors on some combinations of options */
497 #if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES
498 #undef LAST_ENC_ROUND
499 #define LAST_ENC_ROUND NO_TABLES
500 #elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES
501 #undef LAST_ENC_ROUND
502 #define LAST_ENC_ROUND ONE_TABLE
503 #endif
505 #if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE
506 #undef ENC_UNROLL
507 #define ENC_UNROLL NONE
508 #endif
510 #if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES
511 #undef LAST_DEC_ROUND
512 #define LAST_DEC_ROUND NO_TABLES
513 #elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES
514 #undef LAST_DEC_ROUND
515 #define LAST_DEC_ROUND ONE_TABLE
516 #endif
518 #if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE
519 #undef DEC_UNROLL
520 #define DEC_UNROLL NONE
521 #endif
523 /* upr(x,n): rotates bytes within words by n positions, moving bytes to
524 higher index positions with wrap around into low positions
525 ups(x,n): moves bytes by n positions to higher index positions in
526 words but without wrap around
527 bval(x,n): extracts a byte from a word
529 NOTE: The definitions given here are intended only for use with
530 unsigned variables and with shift counts that are compile
531 time constants
534 #if (ALGORITHM_BYTE_ORDER == BRG_LITTLE_ENDIAN)
535 #define upr(x,n) (((aes_32t)(x) << (8 * (n))) | ((aes_32t)(x) >> (32 - 8 * (n))))
536 #define ups(x,n) ((aes_32t) (x) << (8 * (n)))
537 #define bval(x,n) ((aes_08t)((x) >> (8 * (n))))
538 #define bytes2word(b0, b1, b2, b3) \
539 (((aes_32t)(b3) << 24) | ((aes_32t)(b2) << 16) | ((aes_32t)(b1) << 8) | (b0))
540 #endif
542 #if (ALGORITHM_BYTE_ORDER == BRG_BIG_ENDIAN)
543 #define upr(x,n) (((aes_32t)(x) >> (8 * (n))) | ((aes_32t)(x) << (32 - 8 * (n))))
544 #define ups(x,n) ((aes_32t) (x) >> (8 * (n))))
545 #define bval(x,n) ((aes_08t)((x) >> (24 - 8 * (n))))
546 #define bytes2word(b0, b1, b2, b3) \
547 (((aes_32t)(b0) << 24) | ((aes_32t)(b1) << 16) | ((aes_32t)(b2) << 8) | (b3))
548 #endif
550 #if defined(SAFE_IO)
552 #define word_in(x,c) bytes2word(((aes_08t*)(x)+4*c)[0], ((aes_08t*)(x)+4*c)[1], \
553 ((aes_08t*)(x)+4*c)[2], ((aes_08t*)(x)+4*c)[3])
554 #define word_out(x,c,v) { ((aes_08t*)(x)+4*c)[0] = bval(v,0); ((aes_08t*)(x)+4*c)[1] = bval(v,1); \
555 ((aes_08t*)(x)+4*c)[2] = bval(v,2); ((aes_08t*)(x)+4*c)[3] = bval(v,3); }
557 #elif (ALGORITHM_BYTE_ORDER == PLATFORM_BYTE_ORDER)
559 #define word_in(x,c) (*((aes_32t*)(x)+(c)))
560 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = (v))
562 #else
564 #define word_in(x,c) aes_sw32(*((aes_32t*)(x)+(c)))
565 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = aes_sw32(v))
567 #endif
569 /* the finite field modular polynomial and elements */
571 #define WPOLY 0x011b
572 #define BPOLY 0x1b
574 /* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
576 #define m1 0x80808080
577 #define m2 0x7f7f7f7f
578 #define gf_mulx(x) ((((x) & m2) << 1) ^ ((((x) & m1) >> 7) * BPOLY))
580 /* The following defines provide alternative definitions of gf_mulx that might
581 give improved performance if a fast 32-bit multiply is not available. Note
582 that a temporary variable u needs to be defined where gf_mulx is used.
584 #define gf_mulx(x) (u = (x) & m1, u |= (u >> 1), ((x) & m2) << 1) ^ ((u >> 3) | (u >> 6))
585 #define m4 (0x01010101 * BPOLY)
586 #define gf_mulx(x) (u = (x) & m1, ((x) & m2) << 1) ^ ((u - (u >> 7)) & m4)
589 /* Work out which tables are needed for the different options */
591 #ifdef AES_ASM
592 #ifdef ENC_ROUND
593 #undef ENC_ROUND
594 #endif
595 #define ENC_ROUND FOUR_TABLES
596 #ifdef LAST_ENC_ROUND
597 #undef LAST_ENC_ROUND
598 #endif
599 #define LAST_ENC_ROUND FOUR_TABLES
600 #ifdef DEC_ROUND
601 #undef DEC_ROUND
602 #endif
603 #define DEC_ROUND FOUR_TABLES
604 #ifdef LAST_DEC_ROUND
605 #undef LAST_DEC_ROUND
606 #endif
607 #define LAST_DEC_ROUND FOUR_TABLES
608 #ifdef KEY_SCHED
609 #undef KEY_SCHED
610 #define KEY_SCHED FOUR_TABLES
611 #endif
612 #endif
614 #if defined(ENCRYPTION) || defined(AES_ASM)
615 #if ENC_ROUND == ONE_TABLE
616 #define FT1_SET
617 #elif ENC_ROUND == FOUR_TABLES
618 #define FT4_SET
619 #else
620 #define SBX_SET
621 #endif
622 #if LAST_ENC_ROUND == ONE_TABLE
623 #define FL1_SET
624 #elif LAST_ENC_ROUND == FOUR_TABLES
625 #define FL4_SET
626 #elif !defined(SBX_SET)
627 #define SBX_SET
628 #endif
629 #endif
631 #if defined(DECRYPTION) || defined(AES_ASM)
632 #if DEC_ROUND == ONE_TABLE
633 #define IT1_SET
634 #elif DEC_ROUND == FOUR_TABLES
635 #define IT4_SET
636 #else
637 #define ISB_SET
638 #endif
639 #if LAST_DEC_ROUND == ONE_TABLE
640 #define IL1_SET
641 #elif LAST_DEC_ROUND == FOUR_TABLES
642 #define IL4_SET
643 #elif !defined(ISB_SET)
644 #define ISB_SET
645 #endif
646 #endif
648 #if defined(ENCRYPTION_KEY_SCHEDULE) || defined(DECRYPTION_KEY_SCHEDULE)
649 #if KEY_SCHED == ONE_TABLE
650 #define LS1_SET
651 #define IM1_SET
652 #elif KEY_SCHED == FOUR_TABLES
653 #define LS4_SET
654 #define IM4_SET
655 #elif !defined(SBX_SET)
656 #define SBX_SET
657 #endif
658 #endif
660 /* generic definitions of Rijndael macros that use tables */
662 #define no_table(x,box,vf,rf,c) bytes2word( \
663 box[bval(vf(x,0,c),rf(0,c))], \
664 box[bval(vf(x,1,c),rf(1,c))], \
665 box[bval(vf(x,2,c),rf(2,c))], \
666 box[bval(vf(x,3,c),rf(3,c))])
668 #define one_table(x,op,tab,vf,rf,c) \
669 ( tab[bval(vf(x,0,c),rf(0,c))] \
670 ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \
671 ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \
672 ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))
674 #define four_tables(x,tab,vf,rf,c) \
675 ( tab[0][bval(vf(x,0,c),rf(0,c))] \
676 ^ tab[1][bval(vf(x,1,c),rf(1,c))] \
677 ^ tab[2][bval(vf(x,2,c),rf(2,c))] \
678 ^ tab[3][bval(vf(x,3,c),rf(3,c))])
680 #define vf1(x,r,c) (x)
681 #define rf1(r,c) (r)
682 #define rf2(r,c) ((8+r-c)&3)
684 /* perform forward and inverse column mix operation on four bytes in long word x in */
685 /* parallel. NOTE: x must be a simple variable, NOT an expression in these macros. */
687 #if defined(FM4_SET) /* not currently used */
688 #define fwd_mcol(x) four_tables(x,t_use(f,m),vf1,rf1,0)
689 #elif defined(FM1_SET) /* not currently used */
690 #define fwd_mcol(x) one_table(x,upr,t_use(f,m),vf1,rf1,0)
691 #else
692 #define dec_fmvars aes_32t g2
693 #define fwd_mcol(x) (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1))
694 #endif
696 #if defined(IM4_SET)
697 #define inv_mcol(x) four_tables(x,t_use(i,m),vf1,rf1,0)
698 #elif defined(IM1_SET)
699 #define inv_mcol(x) one_table(x,upr,t_use(i,m),vf1,rf1,0)
700 #else
701 #define dec_imvars aes_32t g2, g4, g9
702 #define inv_mcol(x) (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \
703 (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1))
704 #endif
706 #if defined(FL4_SET)
707 #define ls_box(x,c) four_tables(x,t_use(f,l),vf1,rf2,c)
708 #elif defined(LS4_SET)
709 #define ls_box(x,c) four_tables(x,t_use(l,s),vf1,rf2,c)
710 #elif defined(FL1_SET)
711 #define ls_box(x,c) one_table(x,upr,t_use(f,l),vf1,rf2,c)
712 #elif defined(LS1_SET)
713 #define ls_box(x,c) one_table(x,upr,t_use(l,s),vf1,rf2,c)
714 #else
715 #define ls_box(x,c) no_table(x,t_use(s,box),vf1,rf2,c)
716 #endif
718 #if defined(__cplusplus)
719 extern "C"
721 #endif
723 /* If there are no global variables, the definitions here can be
724 used to put the AES tables in a structure so that a pointer
725 can then be added to the AES context to pass them to the AES
726 routines that need them. If this facility is used, the calling
727 program has to ensure that this pointer is managed appropriately.
728 In particular, the value of the t_dec(in,it) item in the table
729 structure must be set to zero in order to ensure that the tables
730 are initialised. In practice the three code sequences in aeskey.c
731 that control the calls to gen_tabs() and the gen_tabs() routine
732 itself will have to be changed for a specific implementation. If
733 global variables are available it will generally be preferable to
734 use them with the precomputed FIXED_TABLES option that uses static
735 global tables.
737 The following defines can be used to control the way the tables
738 are defined, initialised and used in embedded environments that
739 require special features for these purposes
741 the 't_dec' construction is used to declare fixed table arrays
742 the 't_set' construction is used to set fixed table values
743 the 't_use' construction is used to access fixed table values
745 256 byte tables:
747 t_xxx(s,box) => forward S box
748 t_xxx(i,box) => inverse S box
750 256 32-bit word OR 4 x 256 32-bit word tables:
752 t_xxx(f,n) => forward normal round
753 t_xxx(f,l) => forward last round
754 t_xxx(i,n) => inverse normal round
755 t_xxx(i,l) => inverse last round
756 t_xxx(l,s) => key schedule table
757 t_xxx(i,m) => key schedule table
759 Other variables and tables:
761 t_xxx(r,c) => the rcon table
764 #define t_dec(m,n) t_##m##n
765 #define t_set(m,n) t_##m##n
766 #define t_use(m,n) t_##m##n
768 #if defined(DO_TABLES) /* declare and instantiate tables */
770 /* finite field arithmetic operations for table generation */
772 #if defined(FIXED_TABLES) || !defined(FF_TABLES)
774 #define f2(x) ((x<<1) ^ (((x>>7) & 1) * WPOLY))
775 #define f4(x) ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY))
776 #define f8(x) ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) \
777 ^ (((x>>5) & 4) * WPOLY))
778 #define f3(x) (f2(x) ^ x)
779 #define f9(x) (f8(x) ^ x)
780 #define fb(x) (f8(x) ^ f2(x) ^ x)
781 #define fd(x) (f8(x) ^ f4(x) ^ x)
782 #define fe(x) (f8(x) ^ f4(x) ^ f2(x))
784 #else
786 #define f2(x) ((x) ? pow[log[x] + 0x19] : 0)
787 #define f3(x) ((x) ? pow[log[x] + 0x01] : 0)
788 #define f9(x) ((x) ? pow[log[x] + 0xc7] : 0)
789 #define fb(x) ((x) ? pow[log[x] + 0x68] : 0)
790 #define fd(x) ((x) ? pow[log[x] + 0xee] : 0)
791 #define fe(x) ((x) ? pow[log[x] + 0xdf] : 0)
792 #define fi(x) ((x) ? pow[ 255 - log[x]] : 0)
794 #endif
796 #if defined(FIXED_TABLES) /* declare and set values for static tables */
798 #define sb_data(w) \
799 w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\
800 w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\
801 w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\
802 w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\
803 w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\
804 w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\
805 w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\
806 w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\
807 w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\
808 w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\
809 w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\
810 w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\
811 w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\
812 w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\
813 w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\
814 w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\
815 w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\
816 w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\
817 w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\
818 w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\
819 w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\
820 w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\
821 w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\
822 w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\
823 w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\
824 w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\
825 w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\
826 w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\
827 w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\
828 w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\
829 w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\
830 w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16)
832 #define isb_data(w) \
833 w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),\
834 w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),\
835 w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),\
836 w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),\
837 w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),\
838 w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),\
839 w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),\
840 w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),\
841 w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),\
842 w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),\
843 w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),\
844 w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),\
845 w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),\
846 w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),\
847 w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),\
848 w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),\
849 w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),\
850 w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),\
851 w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),\
852 w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),\
853 w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),\
854 w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),\
855 w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),\
856 w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),\
857 w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),\
858 w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),\
859 w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),\
860 w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),\
861 w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),\
862 w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),\
863 w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),\
864 w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d),
866 #define mm_data(w) \
867 w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),\
868 w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),\
869 w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),\
870 w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),\
871 w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),\
872 w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),\
873 w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),\
874 w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),\
875 w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),\
876 w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),\
877 w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),\
878 w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),\
879 w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),\
880 w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),\
881 w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),\
882 w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),\
883 w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),\
884 w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),\
885 w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),\
886 w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),\
887 w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),\
888 w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),\
889 w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),\
890 w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),\
891 w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),\
892 w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),\
893 w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),\
894 w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),\
895 w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),\
896 w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),\
897 w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),\
898 w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff)
900 #define h0(x) (x)
902 /* These defines are used to ensure tables are generated in the
903 right format depending on the internal byte order required
906 #define w0(p) bytes2word(p, 0, 0, 0)
907 #define w1(p) bytes2word(0, p, 0, 0)
908 #define w2(p) bytes2word(0, 0, p, 0)
909 #define w3(p) bytes2word(0, 0, 0, p)
911 #define u0(p) bytes2word(f2(p), p, p, f3(p))
912 #define u1(p) bytes2word(f3(p), f2(p), p, p)
913 #define u2(p) bytes2word(p, f3(p), f2(p), p)
914 #define u3(p) bytes2word(p, p, f3(p), f2(p))
916 #define v0(p) bytes2word(fe(p), f9(p), fd(p), fb(p))
917 #define v1(p) bytes2word(fb(p), fe(p), f9(p), fd(p))
918 #define v2(p) bytes2word(fd(p), fb(p), fe(p), f9(p))
919 #define v3(p) bytes2word(f9(p), fd(p), fb(p), fe(p))
921 const aes_32t t_dec(r,c)[RC_LENGTH] =
923 w0(0x01), w0(0x02), w0(0x04), w0(0x08), w0(0x10),
924 w0(0x20), w0(0x40), w0(0x80), w0(0x1b), w0(0x36)
927 #define d_1(t,n,b,v) const t n[256] = { b(v##0) }
928 #define d_4(t,n,b,v) const t n[4][256] = { { b(v##0) }, { b(v##1) }, { b(v##2) }, { b(v##3) } }
930 #else /* declare and instantiate tables for dynamic value generation in in tab.c */
932 aes_32t t_dec(r,c)[RC_LENGTH];
934 #define d_1(t,n,b,v) t n[256]
935 #define d_4(t,n,b,v) t n[4][256]
937 #endif
939 #else /* declare tables without instantiation */
941 #if defined(FIXED_TABLES)
943 extern const aes_32t t_dec(r,c)[RC_LENGTH];
945 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
946 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t n[256]
947 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t n[4][256]
948 #else
949 #define d_1(t,n,b,v) extern const t n[256]
950 #define d_4(t,n,b,v) extern const t n[4][256]
951 #endif
952 #else
954 extern aes_32t t_dec(r,c)[RC_LENGTH];
956 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
957 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t n[256]
958 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t n[4][256]
959 #else
960 #define d_1(t,n,b,v) extern t n[256]
961 #define d_4(t,n,b,v) extern t n[4][256]
962 #endif
963 #endif
965 #endif
967 #ifdef SBX_SET
968 d_1(aes_08t, t_dec(s,box), sb_data, h);
969 #endif
970 #ifdef ISB_SET
971 d_1(aes_08t, t_dec(i,box), isb_data, h);
972 #endif
974 #ifdef FT1_SET
975 d_1(aes_32t, t_dec(f,n), sb_data, u);
976 #endif
977 #ifdef FT4_SET
978 d_4(aes_32t, t_dec(f,n), sb_data, u);
979 #endif
981 #ifdef FL1_SET
982 d_1(aes_32t, t_dec(f,l), sb_data, w);
983 #endif
984 #ifdef FL4_SET
985 d_4(aes_32t, t_dec(f,l), sb_data, w);
986 #endif
988 #ifdef IT1_SET
989 d_1(aes_32t, t_dec(i,n), isb_data, v);
990 #endif
991 #ifdef IT4_SET
992 d_4(aes_32t, t_dec(i,n), isb_data, v);
993 #endif
995 #ifdef IL1_SET
996 d_1(aes_32t, t_dec(i,l), isb_data, w);
997 #endif
998 #ifdef IL4_SET
999 d_4(aes_32t, t_dec(i,l), isb_data, w);
1000 #endif
1002 #ifdef LS1_SET
1003 #ifdef FL1_SET
1004 #undef LS1_SET
1005 #else
1006 d_1(aes_32t, t_dec(l,s), sb_data, w);
1007 #endif
1008 #endif
1010 #ifdef LS4_SET
1011 #ifdef FL4_SET
1012 #undef LS4_SET
1013 #else
1014 d_4(aes_32t, t_dec(l,s), sb_data, w);
1015 #endif
1016 #endif
1018 #ifdef IM1_SET
1019 d_1(aes_32t, t_dec(i,m), mm_data, v);
1020 #endif
1021 #ifdef IM4_SET
1022 d_4(aes_32t, t_dec(i,m), mm_data, v);
1023 #endif
1025 #if defined(__cplusplus)
1027 #endif
1029 #endif