![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aesopt.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / crypto|
Return to aesopt.h CVS log | Up to [truecrypt] / truecrypt / crypto |
1.1 root 1: /*
2: ---------------------------------------------------------------------------
3: Copyright (c) 2003, Dr Brian Gladman, Worcester, UK. All rights reserved.
4:
5: LICENSE TERMS
6:
7: The free distribution and use of this software in both source and binary
8: form is allowed (with or without changes) provided that:
9:
10: 1. distributions of this source code include the above copyright
11: notice, this list of conditions and the following disclaimer;
12:
13: 2. distributions in binary form include the above copyright
14: notice, this list of conditions and the following disclaimer
15: in the documentation and/or other associated materials;
16:
17: 3. the copyright holder's name is not used to endorse products
18: built using this software without specific written permission.
19:
20: ALTERNATIVELY, provided that this notice is retained in full, this product
21: may be distributed under the terms of the GNU General Public License (GPL),
22: in which case the provisions of the GPL apply INSTEAD OF those given above.
23:
24: DISCLAIMER
25:
26: This software is provided 'as is' with no explicit or implied warranties
27: in respect of its properties, including, but not limited to, correctness
28: and/or fitness for purpose.
29: ---------------------------------------------------------------------------
30: Issue 28/01/2004
31:
32: My thanks go to Dag Arne Osvik for devising the schemes used here for key
33: length derivation from the form of the key schedule
34:
35: This file contains the compilation options for AES (Rijndael) and code
36: that is common across encryption, key scheduling and table generation.
37:
38: OPERATION
39:
40: These source code files implement the AES algorithm Rijndael designed by
41: Joan Daemen and Vincent Rijmen. This version is designed for the standard
42: block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24
43: and 32 bytes).
44:
45: This version is designed for flexibility and speed using operations on
46: 32-bit words rather than operations on bytes. It can be compiled with
47: either big or little endian internal byte order but is faster when the
48: native byte order for the processor is used.
49:
50: THE CIPHER INTERFACE
51:
52: The cipher interface is implemented as an array of bytes in which lower
53: AES bit sequence indexes map to higher numeric significance within bytes.
54:
55: aes_08t (an unsigned 8-bit type)
56: aes_32t (an unsigned 32-bit type)
57: struct aes_encrypt_ctx (structure for the cipher encryption context)
58: struct aes_decrypt_ctx (structure for the cipher decryption context)
59: aes_rval the function return type
60:
61: C subroutine calls:
62:
63: aes_rval aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]);
64: aes_rval aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]);
65: aes_rval aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]);
66: aes_rval aes_encrypt(const unsigned char *in, unsigned char *out,
67: const aes_encrypt_ctx cx[1]);
68:
69: aes_rval aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]);
70: aes_rval aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]);
71: aes_rval aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]);
72: aes_rval aes_decrypt(const unsigned char *in, unsigned char *out,
73: const aes_decrypt_ctx cx[1]);
74:
75: IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that
76: you call genTabs() before AES is used so that the tables are initialised.
77:
78: C++ aes class subroutines:
79:
80: Class AESencrypt for encryption
81:
82: Construtors:
83: AESencrypt(void)
84: AESencrypt(const unsigned char *key) - 128 bit key
85: Members:
86: aes_rval key128(const unsigned char *key)
87: aes_rval key192(const unsigned char *key)
88: aes_rval key256(const unsigned char *key)
89: aes_rval encrypt(const unsigned char *in, unsigned char *out) const
90:
91: Class AESdecrypt for encryption
92: Construtors:
93: AESdecrypt(void)
94: AESdecrypt(const unsigned char *key) - 128 bit key
95: Members:
96: aes_rval key128(const unsigned char *key)
97: aes_rval key192(const unsigned char *key)
98: aes_rval key256(const unsigned char *key)
99: aes_rval decrypt(const unsigned char *in, unsigned char *out) const
100:
101: COMPILATION
102:
103: The files used to provide AES (Rijndael) are
104:
105: a. aes.h for the definitions needed for use in C.
106: b. aescpp.h for the definitions needed for use in C++.
107: c. aesopt.h for setting compilation options (also includes common code).
108: d. aescrypt.c for encryption and decrytpion, or
109: e. aeskey.c for key scheduling.
110: f. aestab.c for table loading or generation.
111: g. aescrypt.asm for encryption and decryption using assembler code.
112: h. aescrypt.mmx.asm for encryption and decryption using MMX assembler.
113:
114: To compile AES (Rijndael) for use in C code use aes.h and set the
115: defines here for the facilities you need (key lengths, encryption
116: and/or decryption). Do not define AES_DLL or AES_CPP. Set the options
117: for optimisations and table sizes here.
118:
119: To compile AES (Rijndael) for use in in C++ code use aescpp.h but do
120: not define AES_DLL
121:
122: To compile AES (Rijndael) in C as a Dynamic Link Library DLL) use
123: aes.h and include the AES_DLL define.
124:
125: CONFIGURATION OPTIONS (here and in aes.h)
126:
127: a. set AES_DLL in aes.h if AES (Rijndael) is to be compiled as a DLL
128: b. You may need to set PLATFORM_BYTE_ORDER to define the byte order.
129: c. If you want the code to run in a specific internal byte order, then
130: ALGORITHM_BYTE_ORDER must be set accordingly.
131: d. set other configuration options decribed below.
132: */
133:
134: #if !defined( _AESOPT_H )
135: #define _AESOPT_H
136:
137: #include "aes.h"
138:
139: /* CONFIGURATION - USE OF DEFINES
140:
141: Later in this section there are a number of defines that control the
142: operation of the code. In each section, the purpose of each define is
143: explained so that the relevant form can be included or excluded by
144: setting either 1's or 0's respectively on the branches of the related
145: #if clauses.
146:
147: PLATFORM SPECIFIC INCLUDES AND BYTE ORDER IN 32-BIT WORDS
148:
149: To obtain the highest speed on processors with 32-bit words, this code
150: needs to determine the byte order of the target machine. The following
151: block of code is an attempt to capture the most obvious ways in which
152: various environemnts define byte order. It may well fail, in which case
153: the definitions will need to be set by editing at the points marked
154: **** EDIT HERE IF NECESSARY **** below. My thanks go to Peter Gutmann
155: for his assistance with this endian detection nightmare.
156: */
157:
158: #define BRG_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */
159: #define BRG_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */
160:
161: #if defined(__GNUC__) || defined(__GNU_LIBRARY__)
162: # if defined(__FreeBSD__) || defined(__OpenBSD__)
163: # include <sys/endian.h>
164: # elif defined( BSD ) && BSD >= 199103
165: # include <machine/endian.h>
166: # elif defined(__APPLE__)
167: # if defined(__BIG_ENDIAN__) && !defined( BIG_ENDIAN )
168: # define BIG_ENDIAN
169: # elif defined(__LITTLE_ENDIAN__) && !defined( LITTLE_ENDIAN )
170: # define LITTLE_ENDIAN
171: # endif
172: # else
173: # include <endian.h>
174: # if defined(__BEOS__)
175: # include <byteswap.h>
176: # endif
177: # endif
178: #endif
179:
180: #if !defined(PLATFORM_BYTE_ORDER)
181: # if defined(LITTLE_ENDIAN) || defined(BIG_ENDIAN)
182: # if defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
183: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
184: # elif !defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN)
185: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
186: # elif defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
187: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
188: # elif defined(BYTE_ORDER) && (BYTE_ORDER == BIG_ENDIAN)
189: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
190: # endif
191: # elif defined(_LITTLE_ENDIAN) || defined(_BIG_ENDIAN)
192: # if defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
193: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
194: # elif !defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
195: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
196: # elif defined(_BYTE_ORDER) && (_BYTE_ORDER == _LITTLE_ENDIAN)
197: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
198: # elif defined(_BYTE_ORDER) && (_BYTE_ORDER == _BIG_ENDIAN)
199: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
200: # endif
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: # endif
212: #endif
213:
214: /* if the platform is still unknown, try to find its byte order */
215: /* from commonly used machine defines */
216:
217: #if !defined(PLATFORM_BYTE_ORDER)
218:
219: #if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \
220: defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \
221: defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \
222: defined( vax ) || defined( vms ) || defined( VMS ) || \
223: defined( __VMS )
224: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
225:
226: #elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \
227: defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \
228: defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \
229: defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \
230: defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \
231: defined( __TANDEM ) || defined( THINK_C ) || defined( __VMCMS__ )
232: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
233:
234: #elif 0 /* **** EDIT HERE IF NECESSARY **** */
235: # define PLATFORM_BYTE_ORDER BRG_LITTLE_ENDIAN
236: #elif 0 /* **** EDIT HERE IF NECESSARY **** */
237: # define PLATFORM_BYTE_ORDER BRG_BIG_ENDIAN
238: #else
239: # error Please edit aesopt.h (line 234 or 236) to set the platform byte order
240: #endif
241:
242: #endif
243:
244: /* SOME LOCAL DEFINITIONS */
245:
246: #define NO_TABLES 0
247: #define ONE_TABLE 1
248: #define FOUR_TABLES 4
249: #define NONE 0
250: #define PARTIAL 1
251: #define FULL 2
252:
253: #if defined(bswap32)
254: #define aes_sw32 bswap32
255: #elif defined(bswap_32)
256: #define aes_sw32 bswap_32
257: #else
258: #define brot(x,n) (((aes_32t)(x) << n) | ((aes_32t)(x) >> (32 - n)))
259: #define aes_sw32(x) ((brot((x),8) & 0x00ff00ff) | (brot((x),24) & 0xff00ff00))
260: #endif
261:
262: /* 1. FUNCTIONS REQUIRED
263:
264: This implementation provides subroutines for encryption, decryption
265: and for setting the three key lengths (separately) for encryption
266: and decryption. When the assembler code is not being used the following
267: definition blocks allow the selection of the routines that are to be
268: included in the compilation.
269: */
270: #if defined( AES_ENCRYPT )
271: #define ENCRYPTION
272: #define ENCRYPTION_KEY_SCHEDULE
273: #endif
274:
275: #if defined( AES_DECRYPT )
276: #define DECRYPTION
277: #define DECRYPTION_KEY_SCHEDULE
278: #endif
279:
280: /* 2. ASSEMBLER SUPPORT
281:
282: This define (which can be on the command line) enables the use of the
283: assembler code routines for encryption and decryption with the C code
284: only providing key scheduling
285: */
286: #if 0 && !defined(AES_ASM)
287: #define AES_ASM
288: #endif
289:
290: /* 3. BYTE ORDER WITHIN 32 BIT WORDS
291:
292: The fundamental data processing units in Rijndael are 8-bit bytes. The
293: input, output and key input are all enumerated arrays of bytes in which
294: bytes are numbered starting at zero and increasing to one less than the
295: number of bytes in the array in question. This enumeration is only used
296: for naming bytes and does not imply any adjacency or order relationship
297: from one byte to another. When these inputs and outputs are considered
298: as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to
299: byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte.
300: In this implementation bits are numbered from 0 to 7 starting at the
301: numerically least significant end of each byte (bit n represents 2^n).
302:
303: However, Rijndael can be implemented more efficiently using 32-bit
304: words by packing bytes into words so that bytes 4*n to 4*n+3 are placed
305: into word[n]. While in principle these bytes can be assembled into words
306: in any positions, this implementation only supports the two formats in
307: which bytes in adjacent positions within words also have adjacent byte
308: numbers. This order is called big-endian if the lowest numbered bytes
309: in words have the highest numeric significance and little-endian if the
310: opposite applies.
311:
312: This code can work in either order irrespective of the order used by the
313: machine on which it runs. Normally the internal byte order will be set
314: to the order of the processor on which the code is to be run but this
315: define can be used to reverse this in special situations
316:
317: NOTE: Assembler code versions rely on PLATFORM_BYTE_ORDER being set
318: */
319: #if 1 || defined(AES_ASM)
320: #define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER
321: #elif 0
322: #define ALGORITHM_BYTE_ORDER BRG_LITTLE_ENDIAN
323: #elif 0
324: #define ALGORITHM_BYTE_ORDER BRG_BIG_ENDIAN
325: #else
326: #error The algorithm byte order is not defined
327: #endif
328:
329: /* 4. FAST INPUT/OUTPUT OPERATIONS.
330:
331: On some machines it is possible to improve speed by transferring the
332: bytes in the input and output arrays to and from the internal 32-bit
333: variables by addressing these arrays as if they are arrays of 32-bit
334: words. On some machines this will always be possible but there may
335: be a large performance penalty if the byte arrays are not aligned on
336: the normal word boundaries. On other machines this technique will
337: lead to memory access errors when such 32-bit word accesses are not
338: properly aligned. The option SAFE_IO avoids such problems but will
339: often be slower on those machines that support misaligned access
340: (especially so if care is taken to align the input and output byte
341: arrays on 32-bit word boundaries). If SAFE_IO is not defined it is
342: assumed that access to byte arrays as if they are arrays of 32-bit
343: words will not cause problems when such accesses are misaligned.
344: */
345: #if 1 && !defined(_MSC_VER)
346: #define SAFE_IO
347: #endif
348:
349: /* 5. LOOP UNROLLING
350:
351: The code for encryption and decrytpion cycles through a number of rounds
352: that can be implemented either in a loop or by expanding the code into a
353: long sequence of instructions, the latter producing a larger program but
354: one that will often be much faster. The latter is called loop unrolling.
355: There are also potential speed advantages in expanding two iterations in
356: a loop with half the number of iterations, which is called partial loop
357: unrolling. The following options allow partial or full loop unrolling
358: to be set independently for encryption and decryption
359: */
360: #if 1
361: #define ENC_UNROLL FULL
362: #elif 0
363: #define ENC_UNROLL PARTIAL
364: #else
365: #define ENC_UNROLL NONE
366: #endif
367:
368: #if 1
369: #define DEC_UNROLL FULL
370: #elif 0
371: #define DEC_UNROLL PARTIAL
372: #else
373: #define DEC_UNROLL NONE
374: #endif
375:
376: /* 6. FAST FINITE FIELD OPERATIONS
377:
378: If this section is included, tables are used to provide faster finite
379: field arithmetic (this has no effect if FIXED_TABLES is defined).
380: */
381: #if 1
382: #define FF_TABLES
383: #endif
384:
385: /* 7. INTERNAL STATE VARIABLE FORMAT
386:
387: The internal state of Rijndael is stored in a number of local 32-bit
388: word varaibles which can be defined either as an array or as individual
389: names variables. Include this section if you want to store these local
390: varaibles in arrays. Otherwise individual local variables will be used.
391: */
392: #if 1
393: #define ARRAYS
394: #endif
395:
396: /* In this implementation the columns of the state array are each held in
397: 32-bit words. The state array can be held in various ways: in an array
398: of words, in a number of individual word variables or in a number of
399: processor registers. The following define maps a variable name x and
400: a column number c to the way the state array variable is to be held.
401: The first define below maps the state into an array x[c] whereas the
402: second form maps the state into a number of individual variables x0,
403: x1, etc. Another form could map individual state colums to machine
404: register names.
405: */
406:
407: #if defined(ARRAYS)
408: #define s(x,c) x[c]
409: #else
410: #define s(x,c) x##c
411: #endif
412:
413: /* 8. FIXED OR DYNAMIC TABLES
414:
415: When this section is included the tables used by the code are compiled
416: statically into the binary file. Otherwise the subroutine gen_tabs()
417: must be called to compute them before the code is first used.
418: */
419: #if 1
420: #define FIXED_TABLES
421: #endif
422:
423: /* 9. TABLE ALIGNMENT
424:
425: On some sytsems speed will be improved by aligning the AES large lookup
426: tables on particular boundaries. This define should be set to a power of
427: two giving the desired alignment. It can be left undefined if alignment
428: is not needed. This option is specific to the Microsft VC++ compiler -
429: it seems to sometimes cause trouble for the VC++ version 6 compiler.
430: */
431:
432: #if 0 && defined(_MSC_VER) && (_MSC_VER >= 1300)
433: #define TABLE_ALIGN 64
434: #endif
435:
436: /* 10. INTERNAL TABLE CONFIGURATION
437:
438: This cipher proceeds by repeating in a number of cycles known as 'rounds'
439: which are implemented by a round function which can optionally be speeded
440: up using tables. The basic tables are each 256 32-bit words, with either
441: one or four tables being required for each round function depending on
442: how much speed is required. The encryption and decryption round functions
443: are different and the last encryption and decrytpion round functions are
444: different again making four different round functions in all.
445:
446: This means that:
447: 1. Normal encryption and decryption rounds can each use either 0, 1
448: or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
449: 2. The last encryption and decryption rounds can also use either 0, 1
450: or 4 tables and table spaces of 0, 1024 or 4096 bytes each.
451:
452: Include or exclude the appropriate definitions below to set the number
453: of tables used by this implementation.
454: */
455:
456: #if 1 /* set tables for the normal encryption round */
457: #define ENC_ROUND FOUR_TABLES
458: #elif 0
459: #define ENC_ROUND ONE_TABLE
460: #else
461: #define ENC_ROUND NO_TABLES
462: #endif
463:
464: #if 1 /* set tables for the last encryption round */
465: #define LAST_ENC_ROUND FOUR_TABLES
466: #elif 0
467: #define LAST_ENC_ROUND ONE_TABLE
468: #else
469: #define LAST_ENC_ROUND NO_TABLES
470: #endif
471:
472: #if 1 /* set tables for the normal decryption round */
473: #define DEC_ROUND FOUR_TABLES
474: #elif 0
475: #define DEC_ROUND ONE_TABLE
476: #else
477: #define DEC_ROUND NO_TABLES
478: #endif
479:
480: #if 1 /* set tables for the last decryption round */
481: #define LAST_DEC_ROUND FOUR_TABLES
482: #elif 0
483: #define LAST_DEC_ROUND ONE_TABLE
484: #else
485: #define LAST_DEC_ROUND NO_TABLES
486: #endif
487:
488: /* The decryption key schedule can be speeded up with tables in the same
489: way that the round functions can. Include or exclude the following
490: defines to set this requirement.
491: */
492: #if 1
493: #define KEY_SCHED FOUR_TABLES
494: #elif 0
495: #define KEY_SCHED ONE_TABLE
496: #else
497: #define KEY_SCHED NO_TABLES
498: #endif
499:
500: /* END OF CONFIGURATION OPTIONS */
501:
502: #define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))
503:
504: /* Disable or report errors on some combinations of options */
505:
506: #if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES
507: #undef LAST_ENC_ROUND
508: #define LAST_ENC_ROUND NO_TABLES
509: #elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES
510: #undef LAST_ENC_ROUND
511: #define LAST_ENC_ROUND ONE_TABLE
512: #endif
513:
514: #if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE
515: #undef ENC_UNROLL
516: #define ENC_UNROLL NONE
517: #endif
518:
519: #if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES
520: #undef LAST_DEC_ROUND
521: #define LAST_DEC_ROUND NO_TABLES
522: #elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES
523: #undef LAST_DEC_ROUND
524: #define LAST_DEC_ROUND ONE_TABLE
525: #endif
526:
527: #if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE
528: #undef DEC_UNROLL
529: #define DEC_UNROLL NONE
530: #endif
531:
532: /* upr(x,n): rotates bytes within words by n positions, moving bytes to
533: higher index positions with wrap around into low positions
534: ups(x,n): moves bytes by n positions to higher index positions in
535: words but without wrap around
536: bval(x,n): extracts a byte from a word
537:
538: NOTE: The definitions given here are intended only for use with
539: unsigned variables and with shift counts that are compile
540: time constants
541: */
542:
543: #if (ALGORITHM_BYTE_ORDER == BRG_LITTLE_ENDIAN)
544: #define upr(x,n) (((aes_32t)(x) << (8 * (n))) | ((aes_32t)(x) >> (32 - 8 * (n))))
545: #define ups(x,n) ((aes_32t) (x) << (8 * (n)))
546: #define bval(x,n) ((aes_08t)((x) >> (8 * (n))))
547: #define bytes2word(b0, b1, b2, b3) \
548: (((aes_32t)(b3) << 24) | ((aes_32t)(b2) << 16) | ((aes_32t)(b1) << 8) | (b0))
549: #endif
550:
551: #if (ALGORITHM_BYTE_ORDER == BRG_BIG_ENDIAN)
552: #define upr(x,n) (((aes_32t)(x) >> (8 * (n))) | ((aes_32t)(x) << (32 - 8 * (n))))
553: #define ups(x,n) ((aes_32t) (x) >> (8 * (n))))
554: #define bval(x,n) ((aes_08t)((x) >> (24 - 8 * (n))))
555: #define bytes2word(b0, b1, b2, b3) \
556: (((aes_32t)(b0) << 24) | ((aes_32t)(b1) << 16) | ((aes_32t)(b2) << 8) | (b3))
557: #endif
558:
559: #if defined(SAFE_IO)
560:
561: #define word_in(x,c) bytes2word(((aes_08t*)(x)+4*c)[0], ((aes_08t*)(x)+4*c)[1], \
562: ((aes_08t*)(x)+4*c)[2], ((aes_08t*)(x)+4*c)[3])
563: #define word_out(x,c,v) { ((aes_08t*)(x)+4*c)[0] = bval(v,0); ((aes_08t*)(x)+4*c)[1] = bval(v,1); \
564: ((aes_08t*)(x)+4*c)[2] = bval(v,2); ((aes_08t*)(x)+4*c)[3] = bval(v,3); }
565:
566: #elif (ALGORITHM_BYTE_ORDER == PLATFORM_BYTE_ORDER)
567:
568: #define word_in(x,c) (*((aes_32t*)(x)+(c)))
569: #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = (v))
570:
571: #else
572:
573: #define word_in(x,c) aes_sw32(*((aes_32t*)(x)+(c)))
574: #define word_out(x,c,v) (*((aes_32t*)(x)+(c)) = aes_sw32(v))
575:
576: #endif
577:
578: /* the finite field modular polynomial and elements */
579:
580: #define WPOLY 0x011b
581: #define BPOLY 0x1b
582:
583: /* multiply four bytes in GF(2^8) by 'x' {02} in parallel */
584:
585: #define m1 0x80808080
586: #define m2 0x7f7f7f7f
587: #define gf_mulx(x) ((((x) & m2) << 1) ^ ((((x) & m1) >> 7) * BPOLY))
588:
589: /* The following defines provide alternative definitions of gf_mulx that might
590: give improved performance if a fast 32-bit multiply is not available. Note
591: that a temporary variable u needs to be defined where gf_mulx is used.
592:
593: #define gf_mulx(x) (u = (x) & m1, u |= (u >> 1), ((x) & m2) << 1) ^ ((u >> 3) | (u >> 6))
594: #define m4 (0x01010101 * BPOLY)
595: #define gf_mulx(x) (u = (x) & m1, ((x) & m2) << 1) ^ ((u - (u >> 7)) & m4)
596: */
597:
598: /* Work out which tables are needed for the different options */
599:
600: #if defined( AES_ASM )
601: #if defined( ENC_ROUND )
602: #undef ENC_ROUND
603: #endif
604: #define ENC_ROUND FOUR_TABLES
605: #if defined( LAST_ENC_ROUND )
606: #undef LAST_ENC_ROUND
607: #endif
608: #define LAST_ENC_ROUND FOUR_TABLES
609: #if defined( DEC_ROUND )
610: #undef DEC_ROUND
611: #endif
612: #define DEC_ROUND FOUR_TABLES
613: #if defined( LAST_DEC_ROUND )
614: #undef LAST_DEC_ROUND
615: #endif
616: #define LAST_DEC_ROUND FOUR_TABLES
617: #if defined( KEY_SCHED )
618: #undef KEY_SCHED
619: #define KEY_SCHED FOUR_TABLES
620: #endif
621: #endif
622:
623: #if defined(ENCRYPTION) || defined(AES_ASM)
624: #if ENC_ROUND == ONE_TABLE
625: #define FT1_SET
626: #elif ENC_ROUND == FOUR_TABLES
627: #define FT4_SET
628: #else
629: #define SBX_SET
630: #endif
631: #if LAST_ENC_ROUND == ONE_TABLE
632: #define FL1_SET
633: #elif LAST_ENC_ROUND == FOUR_TABLES
634: #define FL4_SET
635: #elif !defined(SBX_SET)
636: #define SBX_SET
637: #endif
638: #endif
639:
640: #if defined(DECRYPTION) || defined(AES_ASM)
641: #if DEC_ROUND == ONE_TABLE
642: #define IT1_SET
643: #elif DEC_ROUND == FOUR_TABLES
644: #define IT4_SET
645: #else
646: #define ISB_SET
647: #endif
648: #if LAST_DEC_ROUND == ONE_TABLE
649: #define IL1_SET
650: #elif LAST_DEC_ROUND == FOUR_TABLES
651: #define IL4_SET
652: #elif !defined(ISB_SET)
653: #define ISB_SET
654: #endif
655: #endif
656:
657: #if defined(ENCRYPTION_KEY_SCHEDULE) || defined(DECRYPTION_KEY_SCHEDULE)
658: #if KEY_SCHED == ONE_TABLE
659: #define LS1_SET
660: #define IM1_SET
661: #elif KEY_SCHED == FOUR_TABLES
662: #define LS4_SET
663: #define IM4_SET
664: #elif !defined(SBX_SET)
665: #define SBX_SET
666: #endif
667: #endif
668:
669: /* generic definitions of Rijndael macros that use tables */
670:
671: #define no_table(x,box,vf,rf,c) bytes2word( \
672: box[bval(vf(x,0,c),rf(0,c))], \
673: box[bval(vf(x,1,c),rf(1,c))], \
674: box[bval(vf(x,2,c),rf(2,c))], \
675: box[bval(vf(x,3,c),rf(3,c))])
676:
677: #define one_table(x,op,tab,vf,rf,c) \
678: ( tab[bval(vf(x,0,c),rf(0,c))] \
679: ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \
680: ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \
681: ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))
682:
683: #define four_tables(x,tab,vf,rf,c) \
684: ( tab[0][bval(vf(x,0,c),rf(0,c))] \
685: ^ tab[1][bval(vf(x,1,c),rf(1,c))] \
686: ^ tab[2][bval(vf(x,2,c),rf(2,c))] \
687: ^ tab[3][bval(vf(x,3,c),rf(3,c))])
688:
689: #define vf1(x,r,c) (x)
690: #define rf1(r,c) (r)
691: #define rf2(r,c) ((8+r-c)&3)
692:
693: /* perform forward and inverse column mix operation on four bytes in long word x in */
694: /* parallel. NOTE: x must be a simple variable, NOT an expression in these macros. */
695:
696: #if defined(FM4_SET) /* not currently used */
697: #define fwd_mcol(x) four_tables(x,t_use(f,m),vf1,rf1,0)
698: #elif defined(FM1_SET) /* not currently used */
699: #define fwd_mcol(x) one_table(x,upr,t_use(f,m),vf1,rf1,0)
700: #else
701: #define dec_fmvars aes_32t g2
702: #define fwd_mcol(x) (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1))
703: #endif
704:
705: #if defined(IM4_SET)
706: #define inv_mcol(x) four_tables(x,t_use(i,m),vf1,rf1,0)
707: #elif defined(IM1_SET)
708: #define inv_mcol(x) one_table(x,upr,t_use(i,m),vf1,rf1,0)
709: #else
710: #define dec_imvars aes_32t g2, g4, g9
711: #define inv_mcol(x) (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \
712: (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1))
713: #endif
714:
715: #if defined(FL4_SET)
716: #define ls_box(x,c) four_tables(x,t_use(f,l),vf1,rf2,c)
717: #elif defined(LS4_SET)
718: #define ls_box(x,c) four_tables(x,t_use(l,s),vf1,rf2,c)
719: #elif defined(FL1_SET)
720: #define ls_box(x,c) one_table(x,upr,t_use(f,l),vf1,rf2,c)
721: #elif defined(LS1_SET)
722: #define ls_box(x,c) one_table(x,upr,t_use(l,s),vf1,rf2,c)
723: #else
724: #define ls_box(x,c) no_table(x,t_use(s,box),vf1,rf2,c)
725: #endif
726:
727: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.