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