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