/* * Fast, portable, and easy-to-use Twofish implementation, * Version 0.3. * Copyright (c) 2002 by Niels Ferguson. * * See the twofish.c file for the details of the how and why of this code. * * The author hereby grants a perpetual license to everybody to * use this code for any purpose as long as the copyright message is included * in the source code of this or any derived work. */ /* * PLATFORM FIXES * ============== * * The following definitions have to be fixed for each particular platform * you work on. If you have a multi-platform program, you no doubt have * portable definitions that you can substitute here without changing * the rest of the code. * * The defaults provided here should work on most PC compilers. */ #ifndef TWOFISH_H #define TWOFISH_H #ifdef __cplusplus extern "C" { #endif /** * @file twofish.h * @brief Function that provide basic Twofish crypto support * * @ingroup GNU_ZRTP * @{ */ /** * A Twofish_Byte must be an unsigned 8-bit integer. * * It must also be the elementary data size of your C platform, * i.e. sizeof( Twofish_Byte ) == 1. */ typedef unsigned char Twofish_Byte; /** * A Twofish_UInt32 must be an unsigned integer of at least 32 bits. * * This type is used only internally in the implementation, so ideally it * would not appear in the header file, but it is used inside the * Twofish_key structure which means it has to be included here. */ typedef unsigned int Twofish_UInt32; /* * END OF PLATFORM FIXES * ===================== * * You should not have to touch the rest of this file, but the code * in twofish.c has a few things you need to fix too. */ /** * Return codes */ #define SUCCESS 1 #define ERR_UINT32 -2 #define ERR_BYTE -3 #define ERR_GET32 -4 #define ERR_PUT32 -5 #define ERR_ROLR -6 #define ERR_BSWAP -7 #define ERR_SELECTB -8 #define ERR_TEST_ENC -9 #define ERR_TEST_DEC -10 #define ERR_SEQ_ENC -11 #define ERR_SEQ_DEC -12 #define ERR_ODD_KEY -13 #define ERR_INIT -14 #define ERR_KEY_LEN -15 #define ERR_ILL_ARG -16 /** * Structure that contains a prepared Twofish key. * * A cipher key is used in two stages. In the first stage it is converted * form the original form to an internal representation. * This internal form is then used to encrypt and decrypt data. * This structure contains the internal form. It is rather large: 4256 bytes * on a platform with 32-bit unsigned values. * * Treat this as an opague structure, and don't try to manipulate the * elements in it. I wish I could hide the inside of the structure, * but C doesn't allow that. */ typedef struct { Twofish_UInt32 s[4][256]; /* pre-computed S-boxes */ Twofish_UInt32 K[40]; /* Round key words */ } Twofish_key; /** * Initialise and test the Twofish implementation. * * This function MUST be called before any other function in the * Twofish implementation is called. * It only needs to be called once. * * Apart from initialising the implementation it performs a self test. * If the Twofish_fatal function is not called, the code passed the test. * (See the twofish.c file for details on the Twofish_fatal function.) * * @returns a negative number if an error happend, +1 otherwise */ extern int Twofish_initialise(); /** * Convert a cipher key to the internal form used for * encryption and decryption. * * The cipher key is an array of bytes; the Twofish_Byte type is * defined above to a type suitable on your platform. * * Any key must be converted to an internal form in the Twofisk_key structure * before it can be used. * The encryption and decryption functions only work with the internal form. * The conversion to internal form need only be done once for each key value. * * Be sure to wipe all key storage, including the Twofish_key structure, * once you are done with the key data. * A simple memset( TwofishKey, 0, sizeof( TwofishKey ) ) will do just fine. * * Unlike most implementations, this one allows any key size from 0 bytes * to 32 bytes. According to the Twofish specifications, * irregular key sizes are handled by padding the key with zeroes at the end * until the key size is 16, 24, or 32 bytes, whichever * comes first. Note that each key of irregular size is equivalent to exactly * one key of 16, 24, or 32 bytes. * * WARNING: Short keys have low entropy, and result in low security. * Anything less than 8 bytes is utterly insecure. For good security * use at least 16 bytes. I prefer to use 32-byte keys to prevent * any collision attacks on the key. * * The key length argument key_len must be in the proper range. * If key_len is not in the range 0,...,32 this routine attempts to generate * a fatal error (depending on the code environment), * and at best (or worst) returns without having done anything. * * @param key Array of key bytes * @param key_len Number of key bytes, must be in the range 0,1,...,32. * @param xkey Pointer to an Twofish_key structure that will be filled * with the internal form of the cipher key. * @returns a negative number if an error happend, +1 otherwise */ extern int Twofish_prepare_key( Twofish_Byte key[], int key_len, Twofish_key * xkey ); /** * Encrypt a single block of data. * * This function encrypts a single block of 16 bytes of data. * If you want to encrypt a larger or variable-length message, * you will have to use a cipher mode, such as CBC or CTR. * These are outside the scope of this implementation. * * The xkey structure is not modified by this routine, and can be * used for further encryption and decryption operations. * * @param xkey pointer to Twofish_key, internal form of the key * produces by Twofish_prepare_key() * @param p Plaintext to be encrypted * @param c Place to store the ciphertext */ extern void Twofish_encrypt( Twofish_key * xkey, Twofish_Byte p[16], Twofish_Byte c[16] ); /** * Decrypt a single block of data. * * This function decrypts a single block of 16 bytes of data. * If you want to decrypt a larger or variable-length message, * you will have to use a cipher mode, such as CBC or CTR. * These are outside the scope of this implementation. * * The xkey structure is not modified by this routine, and can be * used for further encryption and decryption operations. * * @param xkey pointer to Twofish_key, internal form of the key * produces by Twofish_prepare_key() * @param c Ciphertext to be decrypted * @param p Place to store the plaintext */ extern void Twofish_decrypt( Twofish_key * xkey, Twofish_Byte c[16], Twofish_Byte p[16] ); /** * Encrypt data in CFB mode. * * This function encrypts data in CFB mode. * * The key structure is not modified by this routine, and can be * used for further encryption and decryption operations. * * @param keyCtx pointer to Twofish_key, internal form of the key * produced by Twofish_prepare_key() * @param in Plaintext to be encrypted * @param out Place to store the ciphertext * @param len number of bytes to encrypt. * @param ivec initialization vector for this CFB mode encryption. * @param num pointer to integer that holds number of available crypto bytes. */ void Twofish_cfb128_encrypt(Twofish_key* keyCtx, Twofish_Byte* in, Twofish_Byte* out, size_t len, Twofish_Byte* ivec, int *num); /** * Decrypt data in CFB mode. * * This function decrypts data in CFB. * * The key structure is not modified by this routine, and can be * used for further encryption and decryption operations. * * @param keyCtx pointer to Twofish_key, internal form of the key * produced by Twofish_prepare_key() * @param in Ciphertext to be decrypted * @param out Place to store the plaintext * @param len number of bytes to decrypt. * @param ivec initialization vector for this CFB mode encryption. * @param num pointer to integer that holds number of available crypto bytes. */ void Twofish_cfb128_decrypt(Twofish_key* keyCtx, Twofish_Byte* in, Twofish_Byte* out, size_t len, Twofish_Byte* ivec, int *num); /** * @} */ #ifdef __cplusplus } #endif #endif