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