2 ---------------------------------------------------------------------------
\r
3 Copyright (c) 2003, Dr Brian Gladman < >, Worcester, UK.
\r
8 The free distribution and use of this software in both source and binary
\r
9 form is allowed (with or without changes) provided that:
\r
11 1. distributions of this source code include the above copyright
\r
12 notice, this list of conditions and the following disclaimer;
\r
14 2. distributions in binary form include the above copyright
\r
15 notice, this list of conditions and the following disclaimer
\r
16 in the documentation and/or other associated materials;
\r
18 3. the copyright holder's name is not used to endorse products
\r
19 built using this software without specific written permission.
\r
21 ALTERNATIVELY, provided that this notice is retained in full, this product
\r
22 may be distributed under the terms of the GNU General Public License (GPL),
\r
23 in which case the provisions of the GPL apply INSTEAD OF those given above.
\r
27 This software is provided 'as is' with no explicit or implied warranties
\r
28 in respect of its properties, including, but not limited to, correctness
\r
29 and/or fitness for purpose.
\r
30 ---------------------------------------------------------------------------
\r
31 Issue Date: 26/08/2003
\r
33 My thanks go to Dag Arne Osvik for devising the schemes used here for key
\r
34 length derivation from the form of the key schedule
\r
36 This file contains the compilation options for AES (Rijndael) and code
\r
37 that is common across encryption, key scheduling and table generation.
\r
41 These source code files implement the AES algorithm Rijndael designed by
\r
42 Joan Daemen and Vincent Rijmen. This version is designed for the standard
\r
43 block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24
\r
46 This version is designed for flexibility and speed using operations on
\r
47 32-bit words rather than operations on bytes. It can be compiled with
\r
48 either big or little endian internal byte order but is faster when the
\r
49 native byte order for the processor is used.
\r
51 THE CIPHER INTERFACE
\r
53 The cipher interface is implemented as an array of bytes in which lower
\r
54 AES bit sequence indexes map to higher numeric significance within bytes.
\r
56 aes_08t (an unsigned 8-bit type)
\r
57 aes_32t (an unsigned 32-bit type)
\r
58 struct aes_encrypt_ctx (structure for the cipher encryption context)
\r
59 struct aes_decrypt_ctx (structure for the cipher decryption context)
\r
60 aes_rval the function return type
\r
64 aes_rval aes_encrypt_key128(const void *in_key, aes_encrypt_ctx cx[1]);
\r
65 aes_rval aes_encrypt_key192(const void *in_key, aes_encrypt_ctx cx[1]);
\r
66 aes_rval aes_encrypt_key256(const void *in_key, aes_encrypt_ctx cx[1]);
\r
67 aes_rval aes_encrypt(const void *in_blk,
\r
68 void *out_blk, const aes_encrypt_ctx cx[1]);
\r
70 aes_rval aes_decrypt_key128(const void *in_key, aes_decrypt_ctx cx[1]);
\r
71 aes_rval aes_decrypt_key192(const void *in_key, aes_decrypt_ctx cx[1]);
\r
72 aes_rval aes_decrypt_key256(const void *in_key, aes_decrypt_ctx cx[1]);
\r
73 aes_rval aes_decrypt(const void *in_blk,
\r
74 void *out_blk, const aes_decrypt_ctx cx[1]);
\r
76 IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that
\r
77 you call genTabs() before AES is used so that the tables are initialised.
\r
79 C++ aes class subroutines:
\r
81 Class AESencrypt for encryption
\r
85 AESencrypt(const void *in_key) - 128 bit key
\r
87 void key128(const void *in_key)
\r
88 void key192(const void *in_key)
\r
89 void key256(const void *in_key)
\r
90 void encrypt(const void *in_blk, void *out_blk) const
\r
92 Class AESdecrypt for encryption
\r
95 AESdecrypt(const void *in_key) - 128 bit key
\r
97 void key128(const void *in_key)
\r
98 void key192(const void *in_key)
\r
99 void key256(const void *in_key)
\r
100 void decrypt(const void *in_blk, void *out_blk) const
\r
104 The files used to provide AES (Rijndael) are
\r
106 a. aes.h for the definitions needed for use in C.
\r
107 b. aescpp.h for the definitions needed for use in C++.
\r
108 c. aesopt.h for setting compilation options (also includes common code).
\r
109 d. aescrypt.c for encryption and decrytpion, or
\r
110 e. aeskey.c for key scheduling.
\r
111 f. aestab.c for table loading or generation.
\r
112 g. aescrypt.asm for encryption and decryption using assembler code.
\r
113 h. aescrypt.mmx.asm for encryption and decryption using MMX assembler.
\r
115 To compile AES (Rijndael) for use in C code use aes.h and set the
\r
116 defines here for the facilities you need (key lengths, encryption
\r
117 and/or decryption). Do not define AES_DLL or AES_CPP. Set the options
\r
118 for optimisations and table sizes here.
\r
120 To compile AES (Rijndael) for use in in C++ code use aescpp.h but do
\r
123 To compile AES (Rijndael) in C as a Dynamic Link Library DLL) use
\r
124 aes.h and include the AES_DLL define.
\r
126 CONFIGURATION OPTIONS (here and in aes.h)
\r
128 a. set AES_DLL in aes.h if AES (Rijndael) is to be compiled as a DLL
\r
129 b. You may need to set PLATFORM_BYTE_ORDER to define the byte order.
\r
130 c. If you want the code to run in a specific internal byte order, then
\r
131 ALGORITHM_BYTE_ORDER must be set accordingly.
\r
132 d. set other configuration options decribed below.
\r
140 /* CONFIGURATION - USE OF DEFINES
\r
142 Later in this section there are a number of defines that control the
\r
143 operation of the code. In each section, the purpose of each define is
\r
144 explained so that the relevant form can be included or excluded by
\r
145 setting either 1's or 0's respectively on the branches of the related
\r
149 /* BYTE ORDER IN 32-BIT WORDS
\r
151 To obtain the highest speed on processors with 32-bit words, this code
\r
152 needs to determine the byte order of the target machine. The following
\r
153 block of code is an attempt to capture the most obvious ways in which
\r
154 various environemnts define byte order. It may well fail, in which case
\r
155 the definitions will need to be set by editing at the points marked
\r
156 **** EDIT HERE IF NECESSARY **** below. My thanks to Peter Gutmann for
\r
157 some of these defines (from cryptlib).
\r
160 #define BRG_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */
\r
161 #define BRG_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */
\r
163 #ifdef __BIG_ENDIAN__
\r
164 #define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
\r
166 #define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
\r
169 /* SOME LOCAL DEFINITIONS */
\r
171 #define NO_TABLES 0
\r
172 #define ONE_TABLE 1
\r
173 #define FOUR_TABLES 4
\r
178 #define aes_sw32 Byteswap::byteswap
\r
180 /* 1. FUNCTIONS REQUIRED
\r
182 This implementation provides subroutines for encryption, decryption
\r
183 and for setting the three key lengths (separately) for encryption
\r
184 and decryption. When the assembler code is not being used the following
\r
185 definition blocks allow the selection of the routines that are to be
\r
186 included in the compilation.
\r
190 #define ENCRYPTION_KEY_SCHEDULE
\r
195 #define DECRYPTION_KEY_SCHEDULE
\r
198 /* 2. ASSEMBLER SUPPORT
\r
200 This define (which can be on the command line) enables the use of the
\r
201 assembler code routines for encryption and decryption with the C code
\r
202 only providing key scheduling
\r
208 /* 3. BYTE ORDER WITHIN 32 BIT WORDS
\r
210 The fundamental data processing units in Rijndael are 8-bit bytes. The
\r
211 input, output and key input are all enumerated arrays of bytes in which
\r
212 bytes are numbered starting at zero and increasing to one less than the
\r
213 number of bytes in the array in question. This enumeration is only used
\r
214 for naming bytes and does not imply any adjacency or order relationship
\r
215 from one byte to another. When these inputs and outputs are considered
\r
216 as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to
\r
217 byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte.
\r
218 In this implementation bits are numbered from 0 to 7 starting at the
\r
219 numerically least significant end of each byte (bit n represents 2^n).
\r
221 However, Rijndael can be implemented more efficiently using 32-bit
\r
222 words by packing bytes into words so that bytes 4*n to 4*n+3 are placed
\r
223 into word[n]. While in principle these bytes can be assembled into words
\r
224 in any positions, this implementation only supports the two formats in
\r
225 which bytes in adjacent positions within words also have adjacent byte
\r
226 numbers. This order is called big-endian if the lowest numbered bytes
\r
227 in words have the highest numeric significance and little-endian if the
\r
230 This code can work in either order irrespective of the order used by the
\r
231 machine on which it runs. Normally the internal byte order will be set
\r
232 to the order of the processor on which the code is to be run but this
\r
233 define can be used to reverse this in special situations
\r
235 NOTE: Assembler code versions rely on PLATFORM_BYTE_ORDER being set
\r
237 #if 1 || defined(AES_ASM)
\r
238 #define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER
\r
240 #define ALGORITHM_BYTE_ORDER BRG_LITTLE_ENDIAN
\r
242 #define ALGORITHM_BYTE_ORDER BRG_BIG_ENDIAN
\r
244 #error The algorithm byte order is not defined
\r
247 /* 4. FAST INPUT/OUTPUT OPERATIONS.
\r
249 On some machines it is possible to improve speed by transferring the
\r
250 bytes in the input and output arrays to and from the internal 32-bit
\r
251 variables by addressing these arrays as if they are arrays of 32-bit
\r
252 words. On some machines this will always be possible but there may
\r
253 be a large performance penalty if the byte arrays are not aligned on
\r
254 the normal word boundaries. On other machines this technique will
\r
255 lead to memory access errors when such 32-bit word accesses are not
\r
256 properly aligned. The option SAFE_IO avoids such problems but will
\r
257 often be slower on those machines that support misaligned access
\r
258 (especially so if care is taken to align the input and output byte
\r
259 arrays on 32-bit word boundaries). If SAFE_IO is not defined it is
\r
260 assumed that access to byte arrays as if they are arrays of 32-bit
\r
261 words will not cause problems when such accesses are misaligned.
\r
263 #if 1 && !defined(_MSC_VER)
\r
267 /* 5. LOOP UNROLLING
\r
269 The code for encryption and decrytpion cycles through a number of rounds
\r
270 that can be implemented either in a loop or by expanding the code into a
\r
271 long sequence of instructions, the latter producing a larger program but
\r
272 one that will often be much faster. The latter is called loop unrolling.
\r
273 There are also potential speed advantages in expanding two iterations in
\r
274 a loop with half the number of iterations, which is called partial loop
\r
275 unrolling. The following options allow partial or full loop unrolling
\r
276 to be set independently for encryption and decryption
\r
279 #define ENC_UNROLL FULL
\r
281 #define ENC_UNROLL PARTIAL
\r
283 #define ENC_UNROLL NONE
\r
287 #define DEC_UNROLL FULL
\r
289 #define DEC_UNROLL PARTIAL
\r
291 #define DEC_UNROLL NONE
\r
294 /* 6. FAST FINITE FIELD OPERATIONS
\r
296 If this section is included, tables are used to provide faster finite
\r
297 field arithmetic (this has no effect if FIXED_TABLES is defined).
\r
303 /* 7. INTERNAL STATE VARIABLE FORMAT
\r
305 The internal state of Rijndael is stored in a number of local 32-bit
\r
306 word varaibles which can be defined either as an array or as individual
\r
307 names variables. Include this section if you want to store these local
\r
308 varaibles in arrays. Otherwise individual local variables will be used.
\r
314 /* In this implementation the columns of the state array are each held in
\r
315 32-bit words. The state array can be held in various ways: in an array
\r
316 of words, in a number of individual word variables or in a number of
\r
317 processor registers. The following define maps a variable name x and
\r
318 a column number c to the way the state array variable is to be held.
\r
319 The first define below maps the state into an array x[c] whereas the
\r
320 second form maps the state into a number of individual variables x0,
\r
321 x1, etc. Another form could map individual state colums to machine
\r
325 #if defined(ARRAYS)
\r
326 #define s(x,c) x[c]
\r
328 #define s(x,c) x##c
\r
331 /* 8. FIXED OR DYNAMIC TABLES
\r
333 When this section is included the tables used by the code are compiled
\r
334 statically into the binary file. Otherwise the subroutine gen_tabs()
\r
335 must be called to compute them before the code is first used.
\r
338 #define FIXED_TABLES
\r
342 /* 9. TABLE ALIGNMENT
\r
344 On some systems speed will be improved by aligning the AES large lookup
\r
345 tables on particular boundaries. This define should be set to a power of
\r
346 two giving the desired alignment. It can be left undefined if alignment
\r
347 is not needed. This option is specific to the Microsft VC++ compiler -
\r
348 it seems to sometimes cause trouble for the VC++ version 6 compiler.
\r
351 #if 0 && defined(_MSC_VER) && (_MSC_VER >= 1300)
\r
352 #define TABLE_ALIGN 64
\r
355 /* 10. INTERNAL TABLE CONFIGURATION
\r
357 This cipher proceeds by repeating in a number of cycles known as 'rounds'
\r
358 which are implemented by a round function which can optionally be speeded
\r
359 up using tables. The basic tables are each 256 32-bit words, with either
\r
360 one or four tables being required for each round function depending on
\r
361 how much speed is required. The encryption and decryption round functions
\r
362 are different and the last encryption and decrytpion round functions are
\r
363 different again making four different round functions in all.
\r
366 1. Normal encryption and decryption rounds can each use either 0, 1
\r
367 or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
\r
368 2. The last encryption and decryption rounds can also use either 0, 1
\r
369 or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
\r
371 Include or exclude the appropriate definitions below to set the number
\r
372 of tables used by this implementation.
\r
375 #if 1 /* set tables for the normal encryption round */
\r
376 #define ENC_ROUND FOUR_TABLES
\r
378 #define ENC_ROUND ONE_TABLE
\r
380 #define ENC_ROUND NO_TABLES
\r
383 #if 1 /* set tables for the last encryption round */
\r
384 #define LAST_ENC_ROUND FOUR_TABLES
\r
386 #define LAST_ENC_ROUND ONE_TABLE
\r
388 #define LAST_ENC_ROUND NO_TABLES
\r
391 #if 1 /* set tables for the normal decryption round */
\r
392 #define DEC_ROUND FOUR_TABLES
\r
394 #define DEC_ROUND ONE_TABLE
\r
396 #define DEC_ROUND NO_TABLES
\r
399 #if 1 /* set tables for the last decryption round */
\r
400 #define LAST_DEC_ROUND FOUR_TABLES
\r
402 #define LAST_DEC_ROUND ONE_TABLE
\r
404 #define LAST_DEC_ROUND NO_TABLES
\r
407 /* The decryption key schedule can be speeded up with tables in the same
\r
408 way that the round functions can. Include or exclude the following
\r
409 defines to set this requirement.
\r
412 #define KEY_SCHED FOUR_TABLES
\r
414 #define KEY_SCHED ONE_TABLE
\r
416 #define KEY_SCHED NO_TABLES
\r
419 /* END OF CONFIGURATION OPTIONS */
\r
421 #define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))
\r
423 /* Disable or report errors on some combinations of options */
\r
425 #if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES
\r
426 #undef LAST_ENC_ROUND
\r
427 #define LAST_ENC_ROUND NO_TABLES
\r
428 #elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES
\r
429 #undef LAST_ENC_ROUND
\r
430 #define LAST_ENC_ROUND ONE_TABLE
\r
433 #if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE
\r
435 #define ENC_UNROLL NONE
\r
438 #if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES
\r
439 #undef LAST_DEC_ROUND
\r
440 #define LAST_DEC_ROUND NO_TABLES
\r
441 #elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES
\r
442 #undef LAST_DEC_ROUND
\r
443 #define LAST_DEC_ROUND ONE_TABLE
\r
446 #if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE
\r
448 #define DEC_UNROLL NONE
\r
451 /* upr(x,n): rotates bytes within words by n positions, moving bytes to
\r
452 higher index positions with wrap around into low positions
\r
453 ups(x,n): moves bytes by n positions to higher index positions in
\r
454 words but without wrap around
\r
455 bval(x,n): extracts a byte from a word
\r
457 NOTE: The definitions given here are intended only for use with
\r
458 unsigned variables and with shift counts that are compile
\r
462 #if (ALGORITHM_BYTE_ORDER == BRG_LITTLE_ENDIAN)
\r
463 #define upr(x,n) (((aes_32t)(x) << (8 * (n))) | ((aes_32t)(x) >> (32 - 8 * (n))))
\r
464 #define ups(x,n) ((aes_32t) (x) << (8 * (n)))
\r
465 #define bval(x,n) ((aes_08t)((x) >> (8 * (n))))
\r
466 #define bytes2word(b0, b1, b2, b3) \
\r
467 (((aes_32t)(b3) << 24) | ((aes_32t)(b2) << 16) | ((aes_32t)(b1) << 8) | (b0))
\r
470 #if (ALGORITHM_BYTE_ORDER == BRG_BIG_ENDIAN)
\r
471 #define upr(x,n) (((aes_32t)(x) >> (8 * (n))) | ((aes_32t)(x) << (32 - 8 * (n))))
\r
472 #define ups(x,n) ((aes_32t) (x) >> (8 * (n))))
\r
473 #define bval(x,n) ((aes_08t)((x) >> (24 - 8 * (n))))
\r
474 #define bytes2word(b0, b1, b2, b3) \
\r
475 (((aes_32t)(b0) << 24) | ((aes_32t)(b1) << 16) | ((aes_32t)(b2) << 8) | (b3))
\r
478 #if defined(SAFE_IO)
\r
480 #define word_in(x,c) bytes2word(((aes_08t*)(x)+4*c)[0], ((aes_08t*)(x)+4*c)[1], \
\r
481 ((aes_08t*)(x)+4*c)[2], ((aes_08t*)(x)+4*c)[3])
\r
482 #define word_out(x,c,v) { ((aes_08t*)(x)+4*c)[0] = bval(v,0); ((aes_08t*)(x)+4*c)[1] = bval(v,1); \
\r
483 ((aes_08t*)(x)+4*c)[2] = bval(v,2); ((aes_08t*)(x)+4*c)[3] = bval(v,3); }
\r
485 #elif (ALGORITHM_BYTE_ORDER == PLATFORM_BYTE_ORDER)
\r
487 #define word_in(x,c) (*((aes_32t*)(x)+(c)))
\r
488 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = (v))
\r
492 #define word_in(x,c) aes_sw32(*((aes_32t*)(x)+(c)))
\r
493 #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = aes_sw32(v))
\r
497 /* the finite field modular polynomial and elements */
\r
499 #define WPOLY 0x011b
\r
502 /* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
\r
504 #define m1 0x80808080
\r
505 #define m2 0x7f7f7f7f
\r
506 #define gf_mulx(x) ((((x) & m2) << 1) ^ ((((x) & m1) >> 7) * BPOLY))
\r
508 /* The following defines provide alternative definitions of gf_mulx that might
\r
509 give improved performance if a fast 32-bit multiply is not available. Note
\r
510 that a temporary variable u needs to be defined where gf_mulx is used.
\r
512 #define gf_mulx(x) (u = (x) & m1, u |= (u >> 1), ((x) & m2) << 1) ^ ((u >> 3) | (u >> 6))
\r
513 #define m4 (0x01010101 * BPOLY)
\r
514 #define gf_mulx(x) (u = (x) & m1, ((x) & m2) << 1) ^ ((u - (u >> 7)) & m4)
\r
517 /* Work out which tables are needed for the different options */
\r
523 #define ENC_ROUND FOUR_TABLES
\r
524 #ifdef LAST_ENC_ROUND
\r
525 #undef LAST_ENC_ROUND
\r
527 #define LAST_ENC_ROUND FOUR_TABLES
\r
531 #define DEC_ROUND FOUR_TABLES
\r
532 #ifdef LAST_DEC_ROUND
\r
533 #undef LAST_DEC_ROUND
\r
535 #define LAST_DEC_ROUND FOUR_TABLES
\r
538 #define KEY_SCHED FOUR_TABLES
\r
542 #if defined(ENCRYPTION) || defined(AES_ASM)
\r
543 #if ENC_ROUND == ONE_TABLE
\r
545 #elif ENC_ROUND == FOUR_TABLES
\r
550 #if LAST_ENC_ROUND == ONE_TABLE
\r
552 #elif LAST_ENC_ROUND == FOUR_TABLES
\r
554 #elif !defined(SBX_SET)
\r
559 #if defined(DECRYPTION) || defined(AES_ASM)
\r
560 #if DEC_ROUND == ONE_TABLE
\r
562 #elif DEC_ROUND == FOUR_TABLES
\r
567 #if LAST_DEC_ROUND == ONE_TABLE
\r
569 #elif LAST_DEC_ROUND == FOUR_TABLES
\r
571 #elif !defined(ISB_SET)
\r
576 #if defined(ENCRYPTION_KEY_SCHEDULE) || defined(DECRYPTION_KEY_SCHEDULE)
\r
577 #if KEY_SCHED == ONE_TABLE
\r
580 #elif KEY_SCHED == FOUR_TABLES
\r
583 #elif !defined(SBX_SET)
\r
588 /* generic definitions of Rijndael macros that use tables */
\r
590 #define no_table(x,box,vf,rf,c) bytes2word( \
\r
591 box[bval(vf(x,0,c),rf(0,c))], \
\r
592 box[bval(vf(x,1,c),rf(1,c))], \
\r
593 box[bval(vf(x,2,c),rf(2,c))], \
\r
594 box[bval(vf(x,3,c),rf(3,c))])
\r
596 #define one_table(x,op,tab,vf,rf,c) \
\r
597 ( tab[bval(vf(x,0,c),rf(0,c))] \
\r
598 ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \
\r
599 ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \
\r
600 ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))
\r
602 #define four_tables(x,tab,vf,rf,c) \
\r
603 ( tab[0][bval(vf(x,0,c),rf(0,c))] \
\r
604 ^ tab[1][bval(vf(x,1,c),rf(1,c))] \
\r
605 ^ tab[2][bval(vf(x,2,c),rf(2,c))] \
\r
606 ^ tab[3][bval(vf(x,3,c),rf(3,c))])
\r
608 #define vf1(x,r,c) (x)
\r
609 #define rf1(r,c) (r)
\r
610 #define rf2(r,c) ((8+r-c)&3)
\r
612 /* perform forward and inverse column mix operation on four bytes in long word x in */
\r
613 /* parallel. NOTE: x must be a simple variable, NOT an expression in these macros. */
\r
615 #if defined(FM4_SET) /* not currently used */
\r
616 #define fwd_mcol(x) four_tables(x,t_use(f,m),vf1,rf1,0)
\r
617 #elif defined(FM1_SET) /* not currently used */
\r
618 #define fwd_mcol(x) one_table(x,upr,t_use(f,m),vf1,rf1,0)
\r
620 #define dec_fmvars aes_32t g2
\r
621 #define fwd_mcol(x) (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1))
\r
624 #if defined(IM4_SET)
\r
625 #define inv_mcol(x) four_tables(x,t_use(i,m),vf1,rf1,0)
\r
626 #elif defined(IM1_SET)
\r
627 #define inv_mcol(x) one_table(x,upr,t_use(i,m),vf1,rf1,0)
\r
629 #define dec_imvars aes_32t g2, g4, g9
\r
630 #define inv_mcol(x) (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \
\r
631 (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1))
\r
634 #if defined(FL4_SET)
\r
635 #define ls_box(x,c) four_tables(x,t_use(f,l),vf1,rf2,c)
\r
636 #elif defined(LS4_SET)
\r
637 #define ls_box(x,c) four_tables(x,t_use(l,s),vf1,rf2,c)
\r
638 #elif defined(FL1_SET)
\r
639 #define ls_box(x,c) one_table(x,upr,t_use(f,l),vf1,rf2,c)
\r
640 #elif defined(LS1_SET)
\r
641 #define ls_box(x,c) one_table(x,upr,t_use(l,s),vf1,rf2,c)
\r
643 #define ls_box(x,c) no_table(x,t_use(s,box),vf1,rf2,c)
\r
646 /* If there are no global variables, the definitions here can be
\r
647 used to put the AES tables in a structure so that a pointer
\r
648 can then be added to the AES context to pass them to the AES
\r
649 routines that need them. If this facility is used, the calling
\r
650 program has to ensure that this pointer is managed appropriately.
\r
651 In particular, the value of the t_dec(in,it) item in the table
\r
652 structure must be set to zero in order to ensure that the tables
\r
653 are initialised. In practice the three code sequences in aeskey.c
\r
654 that control the calls to gen_tabs() and the gen_tabs() routine
\r
655 itself will have to be changed for a specific implementation. If
\r
656 global variables are available it will generally be preferable to
\r
657 use them with the precomputed FIXED_TABLES option that uses static
\r
660 The following defines can be used to control the way the tables
\r
661 are defined, initialised and used in embedded environments that
\r
662 require special features for these purposes
\r
664 the 't_dec' construction is used to declare fixed table arrays
\r
665 the 't_set' construction is used to set fixed table values
\r
666 the 't_use' construction is used to access fixed table values
\r
670 t_xxx(s,box) => forward S box
\r
671 t_xxx(i,box) => inverse S box
\r
673 256 32-bit word OR 4 x 256 32-bit word tables:
\r
675 t_xxx(f,n) => forward normal round
\r
676 t_xxx(f,l) => forward last round
\r
677 t_xxx(i,n) => inverse normal round
\r
678 t_xxx(i,l) => inverse last round
\r
679 t_xxx(l,s) => key schedule table
\r
680 t_xxx(i,m) => key schedule table
\r
682 Other variables and tables:
\r
684 t_xxx(r,c) => the rcon table
\r
687 #define t_dec(m,n) t_##m##n
\r
688 #define t_set(m,n) t_##m##n
\r
689 #define t_use(m,n) t_##m##n
\r
691 #if defined(DO_TABLES) /* declare and instantiate tables */
\r
693 /* finite field arithmetic operations for table generation */
\r
695 #if defined(FIXED_TABLES) || !defined(FF_TABLES)
\r
697 #define f2(x) ((x<<1) ^ (((x>>7) & 1) * WPOLY))
\r
698 #define f4(x) ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY))
\r
699 #define f8(x) ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) \
\r
700 ^ (((x>>5) & 4) * WPOLY))
\r
701 #define f3(x) (f2(x) ^ x)
\r
702 #define f9(x) (f8(x) ^ x)
\r
703 #define fb(x) (f8(x) ^ f2(x) ^ x)
\r
704 #define fd(x) (f8(x) ^ f4(x) ^ x)
\r
705 #define fe(x) (f8(x) ^ f4(x) ^ f2(x))
\r
709 #define f2(x) ((x) ? pow[log[x] + 0x19] : 0)
\r
710 #define f3(x) ((x) ? pow[log[x] + 0x01] : 0)
\r
711 #define f9(x) ((x) ? pow[log[x] + 0xc7] : 0)
\r
712 #define fb(x) ((x) ? pow[log[x] + 0x68] : 0)
\r
713 #define fd(x) ((x) ? pow[log[x] + 0xee] : 0)
\r
714 #define fe(x) ((x) ? pow[log[x] + 0xdf] : 0)
\r
715 #define fi(x) ((x) ? pow[ 255 - log[x]] : 0)
\r
719 #if defined(FIXED_TABLES) /* declare and set values for static tables */
\r
721 #define sb_data(w) \
\r
722 w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\
\r
723 w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\
\r
724 w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\
\r
725 w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\
\r
726 w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\
\r
727 w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\
\r
728 w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\
\r
729 w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\
\r
730 w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\
\r
731 w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\
\r
732 w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\
\r
733 w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\
\r
734 w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\
\r
735 w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\
\r
736 w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\
\r
737 w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\
\r
738 w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\
\r
739 w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\
\r
740 w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\
\r
741 w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\
\r
742 w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\
\r
743 w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\
\r
744 w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\
\r
745 w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\
\r
746 w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\
\r
747 w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\
\r
748 w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\
\r
749 w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\
\r
750 w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\
\r
751 w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\
\r
752 w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\
\r
753 w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16)
\r
755 #define isb_data(w) \
\r
756 w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),\
\r
757 w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),\
\r
758 w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),\
\r
759 w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),\
\r
760 w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),\
\r
761 w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),\
\r
762 w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),\
\r
763 w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),\
\r
764 w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),\
\r
765 w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),\
\r
766 w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),\
\r
767 w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),\
\r
768 w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),\
\r
769 w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),\
\r
770 w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),\
\r
771 w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),\
\r
772 w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),\
\r
773 w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),\
\r
774 w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),\
\r
775 w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),\
\r
776 w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),\
\r
777 w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),\
\r
778 w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),\
\r
779 w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),\
\r
780 w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),\
\r
781 w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),\
\r
782 w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),\
\r
783 w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),\
\r
784 w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),\
\r
785 w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),\
\r
786 w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),\
\r
787 w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d),
\r
789 #define mm_data(w) \
\r
790 w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),\
\r
791 w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),\
\r
792 w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),\
\r
793 w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),\
\r
794 w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),\
\r
795 w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),\
\r
796 w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),\
\r
797 w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),\
\r
798 w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),\
\r
799 w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),\
\r
800 w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),\
\r
801 w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),\
\r
802 w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),\
\r
803 w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),\
\r
804 w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),\
\r
805 w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),\
\r
806 w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),\
\r
807 w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),\
\r
808 w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),\
\r
809 w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),\
\r
810 w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),\
\r
811 w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),\
\r
812 w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),\
\r
813 w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),\
\r
814 w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),\
\r
815 w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),\
\r
816 w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),\
\r
817 w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),\
\r
818 w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),\
\r
819 w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),\
\r
820 w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),\
\r
821 w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff)
\r
825 /* These defines are used to ensure tables are generated in the
\r
826 right format depending on the internal byte order required
\r
829 #define w0(p) bytes2word(p, 0, 0, 0)
\r
830 #define w1(p) bytes2word(0, p, 0, 0)
\r
831 #define w2(p) bytes2word(0, 0, p, 0)
\r
832 #define w3(p) bytes2word(0, 0, 0, p)
\r
834 #define u0(p) bytes2word(f2(p), p, p, f3(p))
\r
835 #define u1(p) bytes2word(f3(p), f2(p), p, p)
\r
836 #define u2(p) bytes2word(p, f3(p), f2(p), p)
\r
837 #define u3(p) bytes2word(p, p, f3(p), f2(p))
\r
839 #define v0(p) bytes2word(fe(p), f9(p), fd(p), fb(p))
\r
840 #define v1(p) bytes2word(fb(p), fe(p), f9(p), fd(p))
\r
841 #define v2(p) bytes2word(fd(p), fb(p), fe(p), f9(p))
\r
842 #define v3(p) bytes2word(f9(p), fd(p), fb(p), fe(p))
\r
844 const aes_32t t_dec(r,c)[RC_LENGTH] =
\r
846 w0(0x01), w0(0x02), w0(0x04), w0(0x08), w0(0x10),
\r
847 w0(0x20), w0(0x40), w0(0x80), w0(0x1b), w0(0x36)
\r
850 #if defined(__BORLANDC__)
\r
851 #define concat(s1, s2) s1##s2
\r
852 #define d_1(t,n,b,v) const t n[256] = { b(concat(v,0)) }
\r
853 #define d_4(t,n,b,v) const t n[4][256] = { { b(concat(v,0)) }, { b(concat(v,1)) }, { b(concat(v,2)) }, { b(concat(v,3)) } }
\r
855 #define d_1(t,n,b,v) const t n[256] = { b(v##0) }
\r
856 #define d_4(t,n,b,v) const t n[4][256] = { { b(v##0) }, { b(v##1) }, { b(v##2) }, { b(v##3) } }
\r
859 #else /* declare and instantiate tables for dynamic value generation in in tab.c */
\r
861 aes_32t t_dec(r,c)[RC_LENGTH];
\r
863 #define d_1(t,n,b,v) t n[256]
\r
864 #define d_4(t,n,b,v) t n[4][256]
\r
868 #else /* declare tables without instantiation */
\r
870 #if defined(FIXED_TABLES)
\r
872 extern const aes_32t t_dec(r,c)[RC_LENGTH];
\r
874 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
\r
875 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t n[256]
\r
876 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) const t n[4][256]
\r
878 #define d_1(t,n,b,v) extern const t n[256]
\r
879 #define d_4(t,n,b,v) extern const t n[4][256]
\r
883 extern aes_32t t_dec(r,c)[RC_LENGTH];
\r
885 #if defined(_MSC_VER) && defined(TABLE_ALIGN)
\r
886 #define d_1(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t n[256]
\r
887 #define d_4(t,n,b,v) extern __declspec(align(TABLE_ALIGN)) t n[4][256]
\r
889 #define d_1(t,n,b,v) extern t n[256]
\r
890 #define d_4(t,n,b,v) extern t n[4][256]
\r
897 d_1(aes_08t, t_dec(s,box), sb_data, h);
\r
900 d_1(aes_08t, t_dec(i,box), isb_data, h);
\r
904 d_1(aes_32t, t_dec(f,n), sb_data, u);
\r
907 d_4(aes_32t, t_dec(f,n), sb_data, u);
\r
911 d_1(aes_32t, t_dec(f,l), sb_data, w);
\r
914 d_4(aes_32t, t_dec(f,l), sb_data, w);
\r
918 d_1(aes_32t, t_dec(i,n), isb_data, v);
\r
921 d_4(aes_32t, t_dec(i,n), isb_data, v);
\r
925 d_1(aes_32t, t_dec(i,l), isb_data, w);
\r
928 d_4(aes_32t, t_dec(i,l), isb_data, w);
\r
935 d_1(aes_32t, t_dec(l,s), sb_data, w);
\r
943 d_4(aes_32t, t_dec(l,s), sb_data, w);
\r
948 d_1(aes_32t, t_dec(i,m), mm_data, v);
\r
951 d_4(aes_32t, t_dec(i,m), mm_data, v);
\r
projects / irrlicht.git / blob