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