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