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