Main Page Modules Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

# aesopt.h

Go to the documentation of this file.

    00001 /*
    00002  ---------------------------------------------------------------------------
    00003  Copyright (c) 2003, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
    00004  All rights reserved.
    00005
    00006  LICENSE TERMS
    00007
    00008  The free distribution and use of this software in both source and binary
    00009  form is allowed (with or without changes) provided that:
    00010
    00011    1. distributions of this source code include the above copyright
    00012       notice, this list of conditions and the following disclaimer;
    00013
    00014    2. distributions in binary form include the above copyright
    00015       notice, this list of conditions and the following disclaimer
    00016       in the documentation and/or other associated materials;
    00017
    00018    3. the copyright holder's name is not used to endorse products
    00019       built using this software without specific written permission.
    00020
    00021  ALTERNATIVELY, provided that this notice is retained in full, this product
    00022  may be distributed under the terms of the GNU General Public License (GPL),
    00023  in which case the provisions of the GPL apply INSTEAD OF those given above.
    00024
    00025  DISCLAIMER
    00026
    00027  This software is provided 'as is' with no explicit or implied warranties
    00028  in respect of its properties, including, but not limited to, correctness
    00029  and/or fitness for purpose.
    00030  ---------------------------------------------------------------------------
    00031  Issue Date: 1/06/2003
    00032
    00033  My thanks go to Dag Arne Osvik for devising the schemes used here for key
    00034  length derivation from the form of the key schedule
    00035
    00036  This file contains the compilation options for AES (Rijndael) and code
    00037  that is common across encryption, key scheduling and table generation.
    00038
    00039     OPERATION
    00040
    00041     These source code files implement the AES algorithm Rijndael designed by
    00042     Joan Daemen and Vincent Rijmen. This version is designed for the standard
    00043     block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24
    00044     and 32 bytes).
    00045
    00046     This version is designed for flexibility and speed using operations on
    00047     32-bit words rather than operations on bytes.  It can be compiled with
    00048     either big or little endian internal byte order but is faster when the
    00049     native byte order for the processor is used.
    00050
    00051     THE CIPHER INTERFACE
    00052
    00053     The cipher interface is implemented as an array of bytes in which lower
    00054     AES bit sequence indexes map to higher numeric significance within bytes.
    00055
    00056     aes_08t                 (an unsigned  8-bit type)
    00057     aes_32t                 (an unsigned 32-bit type)
    00058     struct aes_encrypt_ctx  (structure for the cipher encryption context)
    00059     struct aes_decrypt_ctx  (structure for the cipher decryption context)
    00060     aes_rval                the function return type
    00061
    00062     C subroutine calls:
    00063
    00064       aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1]);
    00065       aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1]);
    00066       aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1]);
    00067       aes_rval aes_encrypt(const void *in_blk,
    00068                                  void *out_blk, const aes_encrypt_ctx cx[1]);
    00069
    00070       aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1]);
    00071       aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1]);
    00072       aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1]);
    00073       aes_rval aes_decrypt(const void *in_blk,
    00074                                  void *out_blk, const aes_decrypt_ctx cx[1]);
    00075
    00076     IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that
    00077     you call genTabs() before AES is used so that the tables are initialised.
    00078
    00079     C++ aes class subroutines:
    00080
    00081         Class AESencrypt  for encryption
    00082
    00083         Construtors:
    00084             AESencrypt(void)
    00085             AESencrypt(const void *in_key) - 128 bit key
    00086         Members:
    00087             void key128(const void *in_key)
    00088             void key192(const void *in_key)
    00089             void key256(const void *in_key)
    00090             void encrypt(const void *in_blk, void *out_blk) const
    00091
    00092         Class AESdecrypt  for encryption
    00093         Construtors:
    00094             AESdecrypt(void)
    00095             AESdecrypt(const void *in_key) - 128 bit key
    00096         Members:
    00097             void key128(const void *in_key)
    00098             void key192(const void *in_key)
    00099             void key256(const void *in_key)
    00100             void decrypt(const void *in_blk, void *out_blk) const
    00101
    00102     COMPILATION
    00103
    00104     The files used to provide AES (Rijndael) are
    00105
    00106     a. aes.h for the definitions needed for use in C.
    00107     b. aescpp.h for the definitions needed for use in C++.
    00108     c. aesopt.h for setting compilation options (also includes common code).
    00109     d. aescrypt.c for encryption and decrytpion, or
    00110     e. aeskey.c for key scheduling.
    00111     f. aestab.c for table loading or generation.
    00112     g. aescrypt.asm for encryption and decryption using assembler code.
    00113     h. aescrypt.mmx.asm for encryption and decryption using MMX assembler.
    00114
    00115     To compile AES (Rijndael) for use in C code use aes.h and set the
    00116     defines here for the facilities you need (key lengths, encryption
    00117     and/or decryption). Do not define AES_DLL or AES_CPP.  Set the options
    00118     for optimisations and table sizes here.
    00119
    00120     To compile AES (Rijndael) for use in in C++ code use aescpp.h but do
    00121     not define AES_DLL
    00122
    00123     To compile AES (Rijndael) in C as a Dynamic Link Library DLL) use
    00124     aes.h and include the AES_DLL define.
    00125
    00126     CONFIGURATION OPTIONS (here and in aes.h)
    00127
    00128     a. set AES_DLL in aes.h if AES (Rijndael) is to be compiled as a DLL
    00129     b. You may need to set PLATFORM_BYTE_ORDER to define the byte order.
    00130     c. If you want the code to run in a specific internal byte order, then
    00131        INTERNAL_BYTE_ORDER must be set accordingly.
    00132     d. set other configuration options decribed below.
    00133 */
    00134
    00135 #ifndef _AESOPT_H
    00136 #define _AESOPT_H
    00137
    00138 #if defined(__cplusplus)
    00139 extern "C"
    00140 {
    00141 #endif
    00142
    00143 /*  START OF CONFIGURATION OPTIONS
    00144
    00145     USE OF DEFINES
    00146
    00147     Later in this section there are a number of defines that control the
    00148     operation of the code.  In each section, the purpose of each define is
    00149     explained so that the relevant form can be included or excluded by
    00150     setting either 1's or 0's respectively on the branches of the related
    00151     #if clauses.
    00152 */
    00153
    00154 /*  DO NOT CHANGE THE FOLLOWING EIGHT DEFINES   */
    00155
    00156 #define NO_TABLES              0
    00157 #define ONE_TABLE              1
    00158 #define FOUR_TABLES            4
    00159 #define NONE                   0
    00160 #define PARTIAL                1
    00161 #define FULL                   2
    00162 #define AES_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
    00163 #define AES_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
    00164
    00165 /*  1. PLATFORM SPECIFIC INCLUDES */
    00166
    00167 #if defined( __CRYPTLIB__ ) && !defined( INC_ALL ) && !defined( INC_CHILD )
    00168 #include "crypt/aes.h"
    00169 #else
    00170   #include "aes.h"
    00171 #endif
    00172
    00173 #if defined(__GNUC__) || defined(__GNU_LIBRARY__)
    00174 #  if defined( __FreeBSD__ ) || defined( __OpenBSD__ )
    00175 #    include <sys/endian.h>
    00176 #  elif defined( __APPLE__ )
    00177 #    if defined( __BIG_ENDIAN__ ) && !defined( BIG_ENDIAN )
    00178 #      define BIG_ENDIAN
    00179 #    elif defined( __LITTLE_ENDIAN__ ) && !defined( LITTLE_ENDIAN )
    00180 #      define LITTLE_ENDIAN
    00181 #    else
    00182 #      error Need to define CPU endianness for OS X
    00183 #    endif
    00184 #  elif defined(_WIN32)
    00185 #   include <stdlib.h>
    00186 #  else
    00187 #    include <endian.h>
    00188 #    include <byteswap.h>
    00189 #  endif /* *BSDs don't use standard Gnu setup */
    00190 #elif defined(__CRYPTLIB__)
    00191 #  if defined( INC_ALL )
    00192 #    include "crypt.h"
    00193 #  elif defined( INC_CHILD )
    00194 #    include "../crypt.h"
    00195 #  else
    00196 #    include "crypt.h"
    00197 #  endif
    00198 #  if defined(DATA_LITTLEENDIAN)
    00199 #    define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00200 #  else
    00201 #    define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00202 #  endif
    00203 #elif defined(_MSC_VER)
    00204 #  include <stdlib.h>
    00205 #elif !defined(WIN32)
    00206 #  include <stdlib.h>
    00207 #  if !defined (_ENDIAN_H)
    00208 #    include <sys/param.h>
    00209 #  else
    00210 #    include _ENDIAN_H
    00211 #  endif
    00212 #endif
    00213
    00214 #if defined(bswap32)
    00215 #define aes_sw32   bswap32
    00216 #elif defined(bswap_32)
    00217 #define aes_sw32   bswap_32
    00218 #endif
    00219
    00220 /*  2. BYTE ORDER IN 32-BIT WORDS
    00221
    00222     To obtain the highest speed on processors with 32-bit words, this code
    00223     needs to determine the order in which bytes are packed into such words.
    00224     The following block of code is an attempt to capture the most obvious
    00225     ways in which various environemnts define byte order. It may well fail,
    00226     in which case the definitions will need to be set by editing at the
    00227     points marked **** EDIT HERE IF NECESSARY **** below.
    00228 */
    00229 #if !defined(PLATFORM_BYTE_ORDER)
    00230 #if defined(LITTLE_ENDIAN) || defined(BIG_ENDIAN)
    00231 #  if defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
    00232 #    if defined(BYTE_ORDER)
    00233 #      if   (BYTE_ORDER == LITTLE_ENDIAN)
    00234 #        define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00235 #      elif (BYTE_ORDER == BIG_ENDIAN)
    00236 #        define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00237 #      endif
    00238 #    endif
    00239 #  elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
    00240 #    define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00241 #  elif !defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
    00242 #    define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00243 #  endif
    00244 #elif defined(_LITTLE_ENDIAN) || defined(_BIG_ENDIAN)
    00245 #  if defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
    00246 #    if defined(_BYTE_ORDER)
    00247 #      if   (_BYTE_ORDER == _LITTLE_ENDIAN)
    00248 #        define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00249 #      elif (_BYTE_ORDER == _BIG_ENDIAN)
    00250 #        define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00251 #      endif
    00252 #    endif
    00253 #  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
    00254 #    define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00255 #  elif !defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
    00256 #    define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00257 #  endif
    00258 #elif 0     /* **** EDIT HERE IF NECESSARY **** */
    00259 #define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00260 #elif 0     /* **** EDIT HERE IF NECESSARY **** */
    00261 #define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00262 #elif (('1234' >> 24) == '1')
    00263 #  define PLATFORM_BYTE_ORDER AES_LITTLE_ENDIAN
    00264 #elif (('4321' >> 24) == '1')
    00265 #  define PLATFORM_BYTE_ORDER AES_BIG_ENDIAN
    00266 #endif
    00267 #endif
    00268
    00269 #if !defined(PLATFORM_BYTE_ORDER)
    00270 #  error Please set undetermined byte order (lines 241 or 243 of aesopt.h).
    00271 #endif
    00272
    00273 /*  3. FUNCTIONS REQUIRED
    00274
    00275     This implementation provides subroutines for encryption, decryption
    00276     and for setting the three key lengths (separately) for encryption
    00277     and decryption. When the assembler code is not being used the following
    00278     definition blocks allow the selection of the routines that are to be
    00279     included in the compilation.
    00280 */
    00281 #ifdef AES_ENCRYPT
    00282 #define ENCRYPTION
    00283 #define ENCRYPTION_KEY_SCHEDULE
    00284 #endif
    00285
    00286 #ifdef AES_DECRYPT
    00287 #define DECRYPTION
    00288 #define DECRYPTION_KEY_SCHEDULE
    00289 #endif
    00290
    00291 /*  4. ASSEMBLER SUPPORT
    00292
    00293     This define (which can be on the command line) enables the use of the
    00294     assembler code routines for encryption and decryption with the C code
    00295     only providing key scheduling
    00296 */
    00297 #if 0
    00298 #define AES_ASM
    00299 #endif
    00300
    00301 /*  5. BYTE ORDER WITHIN 32 BIT WORDS
    00302
    00303     The fundamental data processing units in Rijndael are 8-bit bytes. The
    00304     input, output and key input are all enumerated arrays of bytes in which
    00305     bytes are numbered starting at zero and increasing to one less than the
    00306     number of bytes in the array in question. This enumeration is only used
    00307     for naming bytes and does not imply any adjacency or order relationship
    00308     from one byte to another. When these inputs and outputs are considered
    00309     as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to
    00310     byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte.
    00311     In this implementation bits are numbered from 0 to 7 starting at the
    00312     numerically least significant end of each byte (bit n represents 2^n).
    00313
    00314     However, Rijndael can be implemented more efficiently using 32-bit
    00315     words by packing bytes into words so that bytes 4*n to 4*n+3 are placed
    00316     into word[n]. While in principle these bytes can be assembled into words
    00317     in any positions, this implementation only supports the two formats in
    00318     which bytes in adjacent positions within words also have adjacent byte
    00319     numbers. This order is called big-endian if the lowest numbered bytes
    00320     in words have the highest numeric significance and little-endian if the
    00321     opposite applies.
    00322
    00323     This code can work in either order irrespective of the order used by the
    00324     machine on which it runs. Normally the internal byte order will be set
    00325     to the order of the processor on which the code is to be run but this
    00326     define can be used to reverse this in special situations
    00327
    00328     NOTE: Assembler code versions rely on PLATFORM_BYTE_ORDER being set
    00329 */
    00330 #if 1 || defined(AES_ASM)
    00331 #define INTERNAL_BYTE_ORDER PLATFORM_BYTE_ORDER
    00332 #elif 0
    00333 #define INTERNAL_BYTE_ORDER AES_LITTLE_ENDIAN
    00334 #elif 0
    00335 #define INTERNAL_BYTE_ORDER AES_BIG_ENDIAN
    00336 #else
    00337 #error The internal byte order is not defined
    00338 #endif
    00339
    00340 /*  6. FAST INPUT/OUTPUT OPERATIONS.
    00341
    00342     On some machines it is possible to improve speed by transferring the
    00343     bytes in the input and output arrays to and from the internal 32-bit
    00344     variables by addressing these arrays as if they are arrays of 32-bit
    00345     words.  On some machines this will always be possible but there may
    00346     be a large performance penalty if the byte arrays are not aligned on
    00347     the normal word boundaries. On other machines this technique will
    00348     lead to memory access errors when such 32-bit word accesses are not
    00349     properly aligned. The option SAFE_IO avoids such problems but will
    00350     often be slower on those machines that support misaligned access
    00351     (especially so if care is taken to align the input  and output byte
    00352     arrays on 32-bit word boundaries). If SAFE_IO is not defined it is
    00353     assumed that access to byte arrays as if they are arrays of 32-bit
    00354     words will not cause problems when such accesses are misaligned.
    00355 */
    00356 #if 1 && !defined(_MSC_VER)
    00357 #define SAFE_IO
    00358 #endif
    00359
    00360 /*  7. LOOP UNROLLING
    00361
    00362     The code for encryption and decrytpion cycles through a number of rounds
    00363     that can be implemented either in a loop or by expanding the code into a
    00364     long sequence of instructions, the latter producing a larger program but
    00365     one that will often be much faster. The latter is called loop unrolling.
    00366     There are also potential speed advantages in expanding two iterations in
    00367     a loop with half the number of iterations, which is called partial loop
    00368     unrolling.  The following options allow partial or full loop unrolling
    00369     to be set independently for encryption and decryption
    00370 */
    00371 #if 1
    00372 #define ENC_UNROLL  FULL
    00373 #elif 0
    00374 #define ENC_UNROLL  PARTIAL
    00375 #else
    00376 #define ENC_UNROLL  NONE
    00377 #endif
    00378
    00379 #if 1
    00380 #define DEC_UNROLL  FULL
    00381 #elif 0
    00382 #define DEC_UNROLL  PARTIAL
    00383 #else
    00384 #define DEC_UNROLL  NONE
    00385 #endif
    00386
    00387 /*  8. FAST FINITE FIELD OPERATIONS
    00388
    00389     If this section is included, tables are used to provide faster finite
    00390     field arithmetic (this has no effect if FIXED_TABLES is defined).
    00391 */
    00392 #if 1
    00393 #define FF_TABLES
    00394 #endif
    00395
    00396 /*  9. INTERNAL STATE VARIABLE FORMAT
    00397
    00398     The internal state of Rijndael is stored in a number of local 32-bit
    00399     word varaibles which can be defined either as an array or as individual
    00400     names variables. Include this section if you want to store these local
    00401     varaibles in arrays. Otherwise individual local variables will be used.
    00402 */
    00403 #if 1
    00404 #define ARRAYS
    00405 #endif
    00406
    00407 /* In this implementation the columns of the state array are each held in
    00408    32-bit words. The state array can be held in various ways: in an array
    00409    of words, in a number of individual word variables or in a number of
    00410    processor registers. The following define maps a variable name x and
    00411    a column number c to the way the state array variable is to be held.
    00412    The first define below maps the state into an array x[c] whereas the
    00413    second form maps the state into a number of individual variables x0,
    00414    x1, etc.  Another form could map individual state colums to machine
    00415    register names.
    00416 */
    00417
    00418 #if defined(ARRAYS)
    00419 #define s(x,c) x[c]
    00420 #else
    00421 #define s(x,c) x##c
    00422 #endif
    00423
    00424 /*  10. FIXED OR DYNAMIC TABLES
    00425
    00426     When this section is included the tables used by the code are compiled
    00427     statically into the binary file.  Otherwise the subroutine gen_tabs()
    00428     must be called to compute them before the code is first used.
    00429 */
    00430 #if 1
    00431 #define FIXED_TABLES
    00432 #endif
    00433
    00434 /*  11. TABLE ALIGNMENT
    00435
    00436     On some sytsems speed will be improved by aligning the AES large lookup
    00437     tables on particular boundaries. This define should be set to a power of
    00438     two giving the desired alignment. It can be left undefined if alignment
    00439     is not needed.  This option is specific to the Microsft VC++ compiler.
    00440 */
    00441
    00442 #define TABLE_ALIGN 64
    00443
    00444 /*  12. INTERNAL TABLE CONFIGURATION
    00445
    00446     This cipher proceeds by repeating in a number of cycles known as 'rounds'
    00447     which are implemented by a round function which can optionally be speeded
    00448     up using tables.  The basic tables are each 256 32-bit words, with either
    00449     one or four tables being required for each round function depending on
    00450     how much speed is required. The encryption and decryption round functions
    00451     are different and the last encryption and decrytpion round functions are
    00452     different again making four different round functions in all.
    00453
    00454     This means that:
    00455       1. Normal encryption and decryption rounds can each use either 0, 1
    00456          or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
    00457       2. The last encryption and decryption rounds can also use either 0, 1
    00458          or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
    00459
    00460     Include or exclude the appropriate definitions below to set the number
    00461     of tables used by this implementation.
    00462 */
    00463
    00464 #if 1   /* set tables for the normal encryption round */
    00465 #define ENC_ROUND   FOUR_TABLES
    00466 #elif 0
    00467 #define ENC_ROUND   ONE_TABLE
    00468 #else
    00469 #define ENC_ROUND   NO_TABLES
    00470 #endif
    00471
    00472 #if 1   /* set tables for the last encryption round */
    00473 #define LAST_ENC_ROUND  FOUR_TABLES
    00474 #elif 0
    00475 #define LAST_ENC_ROUND  ONE_TABLE
    00476 #else
    00477 #define LAST_ENC_ROUND  NO_TABLES
    00478 #endif
    00479
    00480 #if 1   /* set tables for the normal decryption round */
    00481 #define DEC_ROUND   FOUR_TABLES
    00482 #elif 0
    00483 #define DEC_ROUND   ONE_TABLE
    00484 #else
    00485 #define DEC_ROUND   NO_TABLES
    00486 #endif
    00487
    00488 #if 1   /* set tables for the last decryption round */
    00489 #define LAST_DEC_ROUND  FOUR_TABLES
    00490 #elif 0
    00491 #define LAST_DEC_ROUND  ONE_TABLE
    00492 #else
    00493 #define LAST_DEC_ROUND  NO_TABLES
    00494 #endif
    00495
    00496 /*  The decryption key schedule can be speeded up with tables in the same
    00497     way that the round functions can.  Include or exclude the following
    00498     defines to set this requirement.
    00499 */
    00500 #if 1
    00501 #define KEY_SCHED   FOUR_TABLES
    00502 #elif 0
    00503 #define KEY_SCHED   ONE_TABLE
    00504 #else
    00505 #define KEY_SCHED   NO_TABLES
    00506 #endif
    00507
    00508 /* END OF CONFIGURATION OPTIONS */
    00509
    00510 #define RC_LENGTH   (5 * (AES_BLOCK_SIZE / 4 - 2))
    00511
    00512 /* Disable at least some poor combinations of options */
    00513
    00514 #if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES
    00515 #undef  LAST_ENC_ROUND
    00516 #define LAST_ENC_ROUND  NO_TABLES
    00517 #elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES
    00518 #undef  LAST_ENC_ROUND
    00519 #define LAST_ENC_ROUND  ONE_TABLE
    00520 #endif
    00521
    00522 #if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE
    00523 #undef  ENC_UNROLL
    00524 #define ENC_UNROLL  NONE
    00525 #endif
    00526
    00527 #if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES
    00528 #undef  LAST_DEC_ROUND
    00529 #define LAST_DEC_ROUND  NO_TABLES
    00530 #elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES
    00531 #undef  LAST_DEC_ROUND
    00532 #define LAST_DEC_ROUND  ONE_TABLE
    00533 #endif
    00534
    00535 #if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE
    00536 #undef  DEC_UNROLL
    00537 #define DEC_UNROLL  NONE
    00538 #endif
    00539
    00540 /*  upr(x,n):  rotates bytes within words by n positions, moving bytes to
    00541                higher index positions with wrap around into low positions
    00542     ups(x,n):  moves bytes by n positions to higher index positions in
    00543                words but without wrap around
    00544     bval(x,n): extracts a byte from a word
    00545
    00546     NOTE:      The definitions given here are intended only for use with
    00547                unsigned variables and with shift counts that are compile
    00548                time constants
    00549 */
    00550
    00551 #if (INTERNAL_BYTE_ORDER == AES_LITTLE_ENDIAN)
    00552 #define upr(x,n)        (((aes_32t)(x) << (8 * (n))) | ((aes_32t)(x) >> (32 - 8 * (n))))
    00553 #define ups(x,n)        ((aes_32t) (x) << (8 * (n)))
    00554 #define bval(x,n)       ((aes_08t)((x) >> (8 * (n))))
    00555 #define bytes2word(b0, b1, b2, b3)  \
    00556         (((aes_32t)(b3) << 24) | ((aes_32t)(b2) << 16) | ((aes_32t)(b1) << 8) | (b0))
    00557 #endif
    00558
    00559 #if (INTERNAL_BYTE_ORDER == AES_BIG_ENDIAN)
    00560 #define upr(x,n)        (((aes_32t)(x) >> (8 * (n))) | ((aes_32t)(x) << (32 - 8 * (n))))
    00561 #define ups(x,n)        ((aes_32t) (x) >> (8 * (n))))
    00562 #define bval(x,n)       ((aes_08t)((x) >> (24 - 8 * (n))))
    00563 #define bytes2word(b0, b1, b2, b3)  \
    00564         (((aes_32t)(b0) << 24) | ((aes_32t)(b1) << 16) | ((aes_32t)(b2) << 8) | (b3))
    00565 #endif
    00566
    00567 #if defined(SAFE_IO)
    00568
    00569 #define word_in(x,c)    bytes2word(((aes_08t*)(x)+4*c)[0], ((aes_08t*)(x)+4*c)[1], \
    00570                                    ((aes_08t*)(x)+4*c)[2], ((aes_08t*)(x)+4*c)[3])
    00571 #define word_out(x,c,v) { ((aes_08t*)(x)+4*c)[0] = bval(v,0); ((aes_08t*)(x)+4*c)[1] = bval(v,1); \
    00572                           ((aes_08t*)(x)+4*c)[2] = bval(v,2); ((aes_08t*)(x)+4*c)[3] = bval(v,3); }
    00573
    00574 #elif (INTERNAL_BYTE_ORDER == PLATFORM_BYTE_ORDER)
    00575
    00576 #define word_in(x,c)    (*((aes_32t*)(x)+(c)))
    00577 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = (v))
    00578
    00579 #else
    00580
    00581 #ifndef aes_sw32
    00582 #define brot(x,n)   (((aes_32t)(x) <<  n) | ((aes_32t)(x) >> (32 - n)))
    00583 #define aes_sw32(x)   ((brot((x),8) & 0x00ff00ff) | (brot((x),24) & 0xff00ff00))
    00584 #endif
    00585
    00586 #define word_in(x,c)    aes_sw32(*((aes_32t*)(x)+(c)))
    00587 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = aes_sw32(v))
    00588
    00589 #endif
    00590
    00591 /* the finite field modular polynomial and elements */
    00592
    00593 #define WPOLY   0x011b
    00594 #define BPOLY     0x1b
    00595
    00596 /* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
    00597
    00598 #define m1  0x80808080
    00599 #define m2  0x7f7f7f7f
    00600 #define gf_mulx(x)  ((((x) & m2) << 1) ^ ((((x) & m1) >> 7) * BPOLY))
    00601
    00602 /* The following defines provide alternative definitions of gf_mulx that might
    00603    give improved performance if a fast 32-bit multiply is not available. Note
    00604    that a temporary variable u needs to be defined where gf_mulx is used.
    00605
    00606 #define gf_mulx(x) (u = (x) & m1, u |= (u >> 1), ((x) & m2) << 1) ^ ((u >> 3) | (u >> 6))
    00607 #define m4  (0x01010101 * BPOLY)
    00608 #define gf_mulx(x) (u = (x) & m1, ((x) & m2) << 1) ^ ((u - (u >> 7)) & m4)
    00609 */
    00610
    00611 /* Work out which tables are needed for the different options   */
    00612
    00613 #ifdef  AES_ASM
    00614 #ifdef  ENC_ROUND
    00615 #undef  ENC_ROUND
    00616 #endif
    00617 #define ENC_ROUND   FOUR_TABLES
    00618 #ifdef  LAST_ENC_ROUND
    00619 #undef  LAST_ENC_ROUND
    00620 #endif
    00621 #define LAST_ENC_ROUND  FOUR_TABLES
    00622 #ifdef  DEC_ROUND
    00623 #undef  DEC_ROUND
    00624 #endif
    00625 #define DEC_ROUND   FOUR_TABLES
    00626 #ifdef  LAST_DEC_ROUND
    00627 #undef  LAST_DEC_ROUND
    00628 #endif
    00629 #define LAST_DEC_ROUND  FOUR_TABLES
    00630 #ifdef  KEY_SCHED
    00631 #undef  KEY_SCHED
    00632 #define KEY_SCHED   FOUR_TABLES
    00633 #endif
    00634 #endif
    00635
    00636 #if defined(ENCRYPTION) || defined(AES_ASM)
    00637 #if ENC_ROUND == ONE_TABLE
    00638 #define FT1_SET
    00639 #elif ENC_ROUND == FOUR_TABLES
    00640 #define FT4_SET
    00641 #else
    00642 #define SBX_SET
    00643 #endif
    00644 #if LAST_ENC_ROUND == ONE_TABLE
    00645 #define FL1_SET
    00646 #elif LAST_ENC_ROUND == FOUR_TABLES
    00647 #define FL4_SET
    00648 #elif !defined(SBX_SET)
    00649 #define SBX_SET
    00650 #endif
    00651 #endif
    00652
    00653 #if defined(DECRYPTION) || defined(AES_ASM)
    00654 #if DEC_ROUND == ONE_TABLE
    00655 #define IT1_SET
    00656 #elif DEC_ROUND == FOUR_TABLES
    00657 #define IT4_SET
    00658 #else
    00659 #define ISB_SET
    00660 #endif
    00661 #if LAST_DEC_ROUND == ONE_TABLE
    00662 #define IL1_SET
    00663 #elif LAST_DEC_ROUND == FOUR_TABLES
    00664 #define IL4_SET
    00665 #elif !defined(ISB_SET)
    00666 #define ISB_SET
    00667 #endif
    00668 #endif
    00669
    00670 #if defined(ENCRYPTION_KEY_SCHEDULE) || defined(DECRYPTION_KEY_SCHEDULE)
    00671 #if KEY_SCHED == ONE_TABLE
    00672 #define LS1_SET
    00673 #define IM1_SET
    00674 #elif KEY_SCHED == FOUR_TABLES
    00675 #define LS4_SET
    00676 #define IM4_SET
    00677 #elif !defined(SBX_SET)
    00678 #define SBX_SET
    00679 #endif
    00680 #endif
    00681
    00682 /*  If there are no global variables, the AES tables are placed in
    00683     a structure and a pointer is added to the AES context. If this
    00684     facility is used, the calling program has to ensure that this
    00685     pointer is managed appropriately. In particular, the value of
    00686     the t_dec(in,it) item in the table structure must be set to zero
    00687     in order to ensure that the tables are initialised. In practice
    00688     the three code sequences in aeskey.c that control the calls to
    00689     gen_tabs() and the gen_tabs() routine itself will require some
    00690     changes for a specific implementation. If global variables are
    00691     available it will generally be preferable to use them with the
    00692     precomputed FIXED_TABLES option that uses static global tables.
    00693
    00694     The following defines can be used to control the way the tables
    00695     are defined, initialised and used in embedded environments that
    00696     require special features for these purposes
    00697
    00698     the 't_dec' construction is used to declare fixed table arrays
    00699     the 't_set' construction is used to set fixed table values
    00700     the 't_use' construction is used to access fixed table values
    00701
    00702     256 byte tables:
    00703
    00704         t_xxx(s,box)    => forward S box
    00705         t_xxx(i,box)    => inverse S box
    00706
    00707     256 32-bit word OR 4 x 256 32-bit word tables:
    00708
    00709         t_xxx(f,n)      => forward normal round
    00710         t_xxx(f,l)      => forward last round
    00711         t_xxx(i,n)      => inverse normal round
    00712         t_xxx(i,l)      => inverse last round
    00713         t_xxx(l,s)      => key schedule table
    00714         t_xxx(i,m)      => key schedule table
    00715
    00716     Other variables and tables:
    00717
    00718         t_xxx(r,c)      => the rcon table
    00719 */
    00720
    00721 #define t_dec(m,n) t_##m##n
    00722 #define t_set(m,n) t_##m##n
    00723 #define t_use(m,n) t_##m##n
    00724
    00725 #if defined(DO_TABLES)  /* declare and instantiate tables   */
    00726
    00727 /*  finite field arithmetic operations for table generation */
    00728
    00729 #if defined(FIXED_TABLES) || !defined(FF_TABLES)
    00730
    00731 #define f2(x)   ((x<<1) ^ (((x>>7) & 1) * WPOLY))
    00732 #define f4(x)   ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY))
    00733 #define f8(x)   ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) \
    00734                         ^ (((x>>5) & 4) * WPOLY))
    00735 #define f3(x)   (f2(x) ^ x)
    00736 #define f9(x)   (f8(x) ^ x)
    00737 #define fb(x)   (f8(x) ^ f2(x) ^ x)
    00738 #define fd(x)   (f8(x) ^ f4(x) ^ x)
    00739 #define fe(x)   (f8(x) ^ f4(x) ^ f2(x))
    00740
    00741 #else
    00742
    00743 #define f2(x) ((x) ? pow[log[x] + 0x19] : 0)
    00744 #define f3(x) ((x) ? pow[log[x] + 0x01] : 0)
    00745 #define f9(x) ((x) ? pow[log[x] + 0xc7] : 0)
    00746 #define fb(x) ((x) ? pow[log[x] + 0x68] : 0)
    00747 #define fd(x) ((x) ? pow[log[x] + 0xee] : 0)
    00748 #define fe(x) ((x) ? pow[log[x] + 0xdf] : 0)
    00749 #define fi(x) ((x) ? pow[ 255 - log[x]] : 0)
    00750
    00751 #endif
    00752
    00753 #if defined(FIXED_TABLES)   /* declare and set values for static tables */
    00754
    00755 #define sb_data(w) \
    00756     w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\
    00757     w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\
    00758     w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\
    00759     w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\
    00760     w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\
    00761     w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\
    00762     w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\
    00763     w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\
    00764     w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\
    00765     w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\
    00766     w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\
    00767     w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\
    00768     w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\
    00769     w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\
    00770     w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\
    00771     w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\
    00772     w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\
    00773     w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\
    00774     w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\
    00775     w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\
    00776     w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\
    00777     w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\
    00778     w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\
    00779     w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\
    00780     w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\
    00781     w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\
    00782     w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\
    00783     w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\
    00784     w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\
    00785     w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\
    00786     w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\
    00787     w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16)
    00788
    00789 #define isb_data(w) \
    00790     w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),\
    00791     w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),\
    00792     w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),\
    00793     w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),\
    00794     w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),\
    00795     w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),\
    00796     w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),\
    00797     w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),\
    00798     w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),\
    00799     w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),\
    00800     w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),\
    00801     w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),\
    00802     w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),\
    00803     w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),\
    00804     w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),\
    00805     w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),\
    00806     w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),\
    00807     w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),\
    00808     w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),\
    00809     w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),\
    00810     w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),\
    00811     w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),\
    00812     w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),\
    00813     w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),\
    00814     w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),\
    00815     w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),\
    00816     w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),\
    00817     w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),\
    00818     w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),\
    00819     w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),\
    00820     w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),\
    00821     w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d),
    00822
    00823 #define mm_data(w) \
    00824     w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),\
    00825     w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),\
    00826     w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),\
    00827     w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),\
    00828     w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),\
    00829     w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),\
    00830     w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),\
    00831     w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),\
    00832     w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),\
    00833     w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),\
    00834     w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),\
    00835     w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),\
    00836     w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),\
    00837     w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),\
    00838     w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),\
    00839     w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),\
    00840     w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),\
    00841     w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),\
    00842     w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),\
    00843     w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),\
    00844     w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),\
    00845     w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),\
    00846     w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),\
    00847     w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),\
    00848     w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),\
    00849     w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),\
    00850     w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),\
    00851     w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),\
    00852     w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),\
    00853     w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),\
    00854     w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),\
    00855     w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff)
    00856
    00857 #define h0(x)   (x)
    00858
    00859 /*  These defines are used to ensure tables are generated in the
    00860     right format depending on the internal byte order required
    00861 */
    00862
    00863 #define w0(p)   bytes2word(p, 0, 0, 0)
    00864 #define w1(p)   bytes2word(0, p, 0, 0)
    00865 #define w2(p)   bytes2word(0, 0, p, 0)
    00866 #define w3(p)   bytes2word(0, 0, 0, p)
    00867
    00868 #define u0(p)   bytes2word(f2(p), p, p, f3(p))
    00869 #define u1(p)   bytes2word(f3(p), f2(p), p, p)
    00870 #define u2(p)   bytes2word(p, f3(p), f2(p), p)
    00871 #define u3(p)   bytes2word(p, p, f3(p), f2(p))
    00872
    00873 #define v0(p)   bytes2word(fe(p), f9(p), fd(p), fb(p))
    00874 #define v1(p)   bytes2word(fb(p), fe(p), f9(p), fd(p))
    00875 #define v2(p)   bytes2word(fd(p), fb(p), fe(p), f9(p))
    00876 #define v3(p)   bytes2word(f9(p), fd(p), fb(p), fe(p))
    00877
    00878 const aes_32t t_dec(r,c)[RC_LENGTH] =
    00879 {
    00880     w0(0x01), w0(0x02), w0(0x04), w0(0x08), w0(0x10),
    00881     w0(0x20), w0(0x40), w0(0x80), w0(0x1b), w0(0x36)
    00882 };
    00883
    00884 #define d_1(t,n,b,v) const t n[256]    =   { b(v##0) }
    00885 #define d_4(t,n,b,v) const t n[4][256] = { { b(v##0) }, { b(v##1) }, { b(v##2) }, { b(v##3) } }
    00886
    00887 #else   /* declare and instantiate tables for dynamic value generation in in tab.c  */
    00888
    00889 aes_32t t_dec(r,c)[RC_LENGTH];
    00890
    00891 #define d_1(t,n,b,v) t  n[256]
    00892 #define d_4(t,n,b,v) t  n[4][256]
    00893
    00894 #endif
    00895
    00896 #else   /* declare tables without instantiation */
    00897
    00898 #if defined(FIXED_TABLES)
    00899
    00900 extern const aes_32t t_dec(r,c)[RC_LENGTH];
    00901
    00902 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
    00903 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t  n[256]
    00904 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t  n[4][256]
    00905 #else
    00906 #define d_1(t,n,b,v) extern const t  n[256]
    00907 #define d_4(t,n,b,v) extern const t  n[4][256]
    00908 #endif
    00909 #else
    00910
    00911 extern aes_32t t_dec(r,c)[RC_LENGTH];
    00912
    00913 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
    00914 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t  n[256]
    00915 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t  n[4][256]
    00916 #else
    00917 #define d_1(t,n,b,v) extern t  n[256]
    00918 #define d_4(t,n,b,v) extern t  n[4][256]
    00919 #endif
    00920 #endif
    00921
    00922 #endif
    00923
    00924 #ifdef  SBX_SET
    00925     d_1(aes_08t, t_dec(s,box), sb_data, h);
    00926 #endif
    00927 #ifdef  ISB_SET
    00928     d_1(aes_08t, t_dec(i,box), isb_data, h);
    00929 #endif
    00930
    00931 #ifdef  FT1_SET
    00932     d_1(aes_32t, t_dec(f,n), sb_data, u);
    00933 #endif
    00934 #ifdef  FT4_SET
    00935     d_4(aes_32t, t_dec(f,n), sb_data, u);
    00936 #endif
    00937
    00938 #ifdef  FL1_SET
    00939     d_1(aes_32t, t_dec(f,l), sb_data, w);
    00940 #endif
    00941 #ifdef  FL4_SET
    00942     d_4(aes_32t, t_dec(f,l), sb_data, w);
    00943 #endif
    00944
    00945 #ifdef  IT1_SET
    00946     d_1(aes_32t, t_dec(i,n), isb_data, v);
    00947 #endif
    00948 #ifdef  IT4_SET
    00949     d_4(aes_32t, t_dec(i,n), isb_data, v);
    00950 #endif
    00951
    00952 #ifdef  IL1_SET
    00953     d_1(aes_32t, t_dec(i,l), isb_data, w);
    00954 #endif
    00955 #ifdef  IL4_SET
    00956     d_4(aes_32t, t_dec(i,l), isb_data, w);
    00957 #endif
    00958
    00959 #ifdef  LS1_SET
    00960 #ifdef  FL1_SET
    00961 #undef  LS1_SET
    00962 #else
    00963     d_1(aes_32t, t_dec(l,s), sb_data, w);
    00964 #endif
    00965 #endif
    00966
    00967 #ifdef  LS4_SET
    00968 #ifdef  FL4_SET
    00969 #undef  LS4_SET
    00970 #else
    00971     d_4(aes_32t, t_dec(l,s), sb_data, w);
    00972 #endif
    00973 #endif
    00974
    00975 #ifdef  IM1_SET
    00976     d_1(aes_32t, t_dec(i,m), mm_data, v);
    00977 #endif
    00978 #ifdef  IM4_SET
    00979     d_4(aes_32t, t_dec(i,m), mm_data, v);
    00980 #endif
    00981
    00982 /* generic definitions of Rijndael macros that use tables    */
    00983
    00984 #define no_table(x,box,vf,rf,c) bytes2word( \
    00985     box[bval(vf(x,0,c),rf(0,c))], \
    00986     box[bval(vf(x,1,c),rf(1,c))], \
    00987     box[bval(vf(x,2,c),rf(2,c))], \
    00988     box[bval(vf(x,3,c),rf(3,c))])
    00989
    00990 #define one_table(x,op,tab,vf,rf,c) \
    00991  (     tab[bval(vf(x,0,c),rf(0,c))] \
    00992   ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \
    00993   ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \
    00994   ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))
    00995
    00996 #define four_tables(x,tab,vf,rf,c) \
    00997  (  tab[0][bval(vf(x,0,c),rf(0,c))] \
    00998   ^ tab[1][bval(vf(x,1,c),rf(1,c))] \
    00999   ^ tab[2][bval(vf(x,2,c),rf(2,c))] \
    01000   ^ tab[3][bval(vf(x,3,c),rf(3,c))])
    01001
    01002 #define vf1(x,r,c)  (x)
    01003 #define rf1(r,c)    (r)
    01004 #define rf2(r,c)    ((8+r-c)&3)
    01005
    01006 /* perform forward and inverse column mix operation on four bytes in long word x in */
    01007 /* parallel. NOTE: x must be a simple variable, NOT an expression in these macros.  */
    01008
    01009 #if defined(FM4_SET)    /* not currently used */
    01010 #define fwd_mcol(x)     four_tables(x,t_use(f,m),vf1,rf1,0)
    01011 #elif defined(FM1_SET)  /* not currently used */
    01012 #define fwd_mcol(x)     one_table(x,upr,t_use(f,m),vf1,rf1,0)
    01013 #else
    01014 #define dec_fmvars      aes_32t g2
    01015 #define fwd_mcol(x)     (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1))
    01016 #endif
    01017
    01018 #if defined(IM4_SET)
    01019 #define inv_mcol(x)     four_tables(x,t_use(i,m),vf1,rf1,0)
    01020 #elif defined(IM1_SET)
    01021 #define inv_mcol(x)     one_table(x,upr,t_use(i,m),vf1,rf1,0)
    01022 #else
    01023 #define dec_imvars      aes_32t g2, g4, g9
    01024 #define inv_mcol(x)     (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \
    01025                         (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1))
    01026 #endif
    01027
    01028 #if defined(FL4_SET)
    01029 #define ls_box(x,c)     four_tables(x,t_use(f,l),vf1,rf2,c)
    01030 #elif   defined(LS4_SET)
    01031 #define ls_box(x,c)     four_tables(x,t_use(l,s),vf1,rf2,c)
    01032 #elif defined(FL1_SET)
    01033 #define ls_box(x,c)     one_table(x,upr,t_use(f,l),vf1,rf2,c)
    01034 #elif defined(LS1_SET)
    01035 #define ls_box(x,c)     one_table(x,upr,t_use(l,s),vf1,rf2,c)
    01036 #else
    01037 #define ls_box(x,c)     no_table(x,t_use(s,box),vf1,rf2,c)
    01038 #endif
    01039
    01040 #if defined(__cplusplus)
    01041 }
    01042 #endif
    01043
    01044 #endif