Return to aessmall.h CVS log

Up to [truecrypt] / truecrypt / crypto

Annotation of truecrypt/crypto/aessmall.h, revision 1.1

1.1     ! root        1: /*
        !             2:  ---------------------------------------------------------------------------
        !             3:  Copyright (c) 1998-2006, 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 09/09/2006
        !            31: 
        !            32:  This is an AES implementation that uses only 8-bit byte operations on the
        !            33:  cipher state.
        !            34:  */
        !            35: 
        !            36: #ifndef AES_H
        !            37: #define AES_H
        !            38: 
        !            39: #if defined(__cplusplus)
        !            40: extern "C"
        !            41: {
        !            42: #endif
        !            43: 
        !            44: /*  This provides speed optimisation opportunities if 32-bit word
        !            45:     operations are available
        !            46: */
        !            47: #if 1
        !            48: #  define HAVE_UINT_32T
        !            49: #endif
        !            50: 
        !            51: #if 1
        !            52: #  define AES_ENC_PREKEYED  /* AES encryption with a precomputed key schedule  */
        !            53: #endif
        !            54: #if 1
        !            55: #  define AES_DEC_PREKEYED  /* AES decryption with a precomputed key schedule  */
        !            56: #endif
        !            57: #if 0
        !            58: #  define AES_ENC_128_OTFK  /* AES encryption with 'on the fly' 128 bit keying */
        !            59: #endif
        !            60: #if 0
        !            61: #  define AES_DEC_128_OTFK  /* AES decryption with 'on the fly' 128 bit keying */
        !            62: #endif
        !            63: #if 0
        !            64: #  define AES_ENC_256_OTFK  /* AES encryption with 'on the fly' 256 bit keying */
        !            65: #endif
        !            66: #if 0
        !            67: #  define AES_DEC_256_OTFK  /* AES decryption with 'on the fly' 256 bit keying */
        !            68: #endif
        !            69: 
        !            70: #define N_ROW                   4
        !            71: #define N_COL                   4
        !            72: #define N_BLOCK   (N_ROW * N_COL)
        !            73: #define N_MAX_ROUNDS           14
        !            74: 
        !            75: typedef unsigned char uint_8t;
        !            76: 
        !            77: typedef uint_8t return_type;
        !            78: typedef uint_8t length_type;
        !            79: typedef uint_8t uint_type;
        !            80: 
        !            81: typedef unsigned char uint_8t;
        !            82: 
        !            83: typedef struct
        !            84: {   uint_8t ksch[(N_MAX_ROUNDS + 1) * N_BLOCK];
        !            85:     uint_8t rnd;
        !            86: } aes_context;
        !            87: 
        !            88: /*  The following calls are for a precomputed key schedule
        !            89: 
        !            90:     NOTE: If the length_type used for the key length is an
        !            91:     unsigned 8-bit character, a key length of 256 bits must
        !            92:     be entered as a length in bytes (valid inputs are hence
        !            93:     128, 192, 16, 24 and 32).
        !            94: */
        !            95: 
        !            96: #if defined( AES_ENC_PREKEYED ) || defined( AES_DEC_PREKEYED )
        !            97: 
        !            98: return_type aes_set_key( const unsigned char key[],
        !            99:                          length_type keylen,
        !           100:                          aes_context ctx[1] );
        !           101: #endif
        !           102: 
        !           103: #if defined( AES_ENC_PREKEYED )
        !           104: 
        !           105: return_type aes_encrypt( const unsigned char in[N_BLOCK],
        !           106:                          unsigned char out[N_BLOCK],
        !           107:                          const aes_context ctx[1] );
        !           108: #endif
        !           109: 
        !           110: #if defined( AES_DEC_PREKEYED )
        !           111: 
        !           112: return_type aes_decrypt( const unsigned char in[N_BLOCK],
        !           113:                          unsigned char out[N_BLOCK],
        !           114:                          const aes_context ctx[1] );
        !           115: #endif
        !           116: 
        !           117: /*  The following calls are for 'on the fly' keying.  In this case the
        !           118:     encryption and decryption keys are different.
        !           119: 
        !           120:     The encryption subroutines take a key in an array of bytes in
        !           121:     key[L] where L is 16, 24 or 32 bytes for key lengths of 128,
        !           122:     192, and 256 bits respectively.  They then encrypts the input
        !           123:     data, in[] with this key and put the reult in the output array
        !           124:     out[].  In addition, the second key array, o_key[L], is used
        !           125:     to output the key that is needed by the decryption subroutine
        !           126:     to reverse the encryption operation.  The two key arrays can
        !           127:     be the same array but in this case the original key will be
        !           128:     overwritten.
        !           129: 
        !           130:     In the same way, the decryption subroutines output keys that
        !           131:     can be used to reverse their effect when used for encryption.
        !           132: 
        !           133:     Only 128 and 256 bit keys are supported in these 'on the fly'
        !           134:     modes.
        !           135: */
        !           136: 
        !           137: #if defined( AES_ENC_128_OTFK )
        !           138: void aes_encrypt_128( const unsigned char in[N_BLOCK],
        !           139:                       unsigned char out[N_BLOCK],
        !           140:                       const unsigned char key[N_BLOCK],
        !           141:                       uint_8t o_key[N_BLOCK] );
        !           142: #endif
        !           143: 
        !           144: #if defined( AES_DEC_128_OTFK )
        !           145: void aes_decrypt_128( const unsigned char in[N_BLOCK],
        !           146:                       unsigned char out[N_BLOCK],
        !           147:                       const unsigned char key[N_BLOCK],
        !           148:                       unsigned char o_key[N_BLOCK] );
        !           149: #endif
        !           150: 
        !           151: #if defined( AES_ENC_256_OTFK )
        !           152: void aes_encrypt_256( const unsigned char in[N_BLOCK],
        !           153:                       unsigned char out[N_BLOCK],
        !           154:                       const unsigned char key[2 * N_BLOCK],
        !           155:                       unsigned char o_key[2 * N_BLOCK] );
        !           156: #endif
        !           157: 
        !           158: #if defined( AES_DEC_256_OTFK )
        !           159: void aes_decrypt_256( const unsigned char in[N_BLOCK],
        !           160:                       unsigned char out[N_BLOCK],
        !           161:                       const unsigned char key[2 * N_BLOCK],
        !           162:                       unsigned char o_key[2 * N_BLOCK] );
        !           163: #endif
        !           164: 
        !           165: #if defined(__cplusplus)
        !           166: }
        !           167: #endif
        !           168: 
        !           169: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.