crypt_aes.c File Reference

#include "config.h"
#include "config_unix.h"
#include "config_win32.h"
#include "debug.h"
#include "crypt_aes_impl.h"
#include "crypt_aes.h"

Include dependency graph for crypt_aes.c:

Go to the source code of this file.

Functions
int	blockDecrypt (cipherInstance *cipher, keyInstance *key, BYTE *input, int inputLen, BYTE *outBuffer)
int	blockEncrypt (cipherInstance *cipher, keyInstance *key, BYTE *input, int inputLen, BYTE *outBuffer)
int	cipherInit (cipherInstance *cipher, BYTE mode, char *IV)
int	cipherUpdateRounds (cipherInstance *cipher, keyInstance *key, BYTE *input, int inputLen, BYTE *outBuffer, int rounds)
int	makeKey (keyInstance *key, BYTE direction, int keyLen, const char *keyMaterial)
int	padDecrypt (cipherInstance *cipher, keyInstance *key, BYTE *input, int inputOctets, BYTE *outBuffer)
int	padEncrypt (cipherInstance *cipher, keyInstance *key, BYTE *input, int inputOctets, BYTE *outBuffer)

Function Documentation

blockDecrypt()

int blockDecrypt	(	cipherInstance *	cipher,
		keyInstance *	key,
		BYTE *	input,
		int	inputLen,
		BYTE *	outBuffer )

Definition at line 287 of file crypt_aes.c.

{
        int i, k, t, numBlocks;
        u8 block[16], *iv;
 
        if (cipher == NULL ||
            key == NULL ||
            (cipher->mode != MODE_CFB1 && key->direction == DIR_ENCRYPT)) {
                return BAD_CIPHER_STATE;
        }
        if (input == NULL || inputLen <= 0) {
                return 0;       /* nothing to do */
        }
 
        numBlocks = inputLen / 128;
 
        switch (cipher->mode) {
        case MODE_ECB:
                for (i = numBlocks; i > 0; i--) {
                        rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
                        input += 16;
                        outBuffer += 16;
                }
                break;
 
        case MODE_CBC:
                iv = cipher->IV;
                for (i = numBlocks; i > 0; i--) {
                        rijndaelDecrypt(key->rk, key->Nr, input, block);
                        ((u32 *)(void *) block)[0] ^= ((u32 *)(void *) iv)[0];
                        ((u32 *)(void *) block)[1] ^= ((u32 *)(void *) iv)[1];
                        ((u32 *)(void *) block)[2] ^= ((u32 *)(void *) iv)[2];
                        ((u32 *)(void *) block)[3] ^= ((u32 *)(void *) iv)[3];
                        memcpy(cipher->IV, input, 16);
                        memcpy(outBuffer, block, 16);
                        input += 16;
                        outBuffer += 16;
                }
                break;
 
        case MODE_CFB1:
                iv = cipher->IV;
                for (i = numBlocks; i > 0; i--) {
                        memcpy(outBuffer, input, 16);
                        for (k = 0; k < 128; k++) {
                                rijndaelEncrypt(key->ek, key->Nr, iv, block);
                                for (t = 0; t < 15; t++) {
                                        iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
                                }
                                iv[15] =
                                    (iv[15] << 1) |
                                    ((input[k >> 3] >> (7 - (k & 7))) & 1);
                                outBuffer[k >> 3] ^=
                                    (block[0] & 0x80U) >> (k & 7);
                        }
                        outBuffer += 16;
                        input += 16;
                }
                break;
 
        default:
                return BAD_CIPHER_STATE;
        }
 
        return 128 * numBlocks;
}
 
int padDecrypt(cipherInstance * cipher, keyInstance * key,

References BAD_CIPHER_STATE, DIR_ENCRYPT, cipherInstance::IV, key, cipherInstance::mode, MODE_CBC, MODE_CFB1, MODE_ECB, rijndaelDecrypt(), and rijndaelEncrypt().

Referenced by rijndael_decrypt(), rijndaelCBC_MCT(), rijndaelECB_MCT(), rijndaelTKAT(), and rijndaelVKKAT().

Here is the call graph for this function:

blockEncrypt()

int blockEncrypt	(	cipherInstance *	cipher,
		keyInstance *	key,
		BYTE *	input,
		int	inputLen,
		BYTE *	outBuffer )

Definition at line 145 of file crypt_aes.c.

{
        int i, k, t, numBlocks;
        u8 block[16], *iv;
 
        if (cipher == NULL || key == NULL || key->direction == DIR_DECRYPT) {
                return BAD_CIPHER_STATE;
        }
        if (input == NULL || inputLen <= 0) {
                return 0;       /* nothing to do */
        }
 
        numBlocks = inputLen / 128;
 
        switch (cipher->mode) {
        case MODE_ECB:
                for (i = numBlocks; i > 0; i--) {
                        rijndaelEncrypt(key->rk, key->Nr, input, outBuffer);
                        input += 16;
                        outBuffer += 16;
                }
                break;
 
        case MODE_CBC:
                iv = cipher->IV;
                for (i = numBlocks; i > 0; i--) {
                        ((u32 *)(void *) block)[0] =
                            ((u32 *)(void *) input)[0] ^ ((u32 *)(void *) iv)[0];
                        ((u32 *)(void *) block)[1] =
                            ((u32 *)(void *) input)[1] ^ ((u32 *)(void *) iv)[1];
                        ((u32 *)(void *) block)[2] =
                            ((u32 *)(void *) input)[2] ^ ((u32 *)(void *) iv)[2];
                        ((u32 *)(void *) block)[3] =
                            ((u32 *)(void *) input)[3] ^ ((u32 *)(void *) iv)[3];
                        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
                        iv = outBuffer;
                        input += 16;
                        outBuffer += 16;
                }
                break;
 
        case MODE_CFB1:
                iv = cipher->IV;
                for (i = numBlocks; i > 0; i--) {
                        memcpy(outBuffer, input, 16);
                        for (k = 0; k < 128; k++) {
                                rijndaelEncrypt(key->ek, key->Nr, iv, block);
                                outBuffer[k >> 3] ^=
                                    (block[0] & 0x80U) >> (k & 7);
                                for (t = 0; t < 15; t++) {
                                        iv[t] = (iv[t] << 1) | (iv[t + 1] >> 7);
                                }
                                iv[15] =
                                    (iv[15] << 1) |
                                    ((outBuffer[k >> 3] >> (7 - (k & 7))) & 1);
                        }
                        outBuffer += 16;
                        input += 16;
                }
                break;
 
        default:
                return BAD_CIPHER_STATE;
        }
 
        return 128 * numBlocks;
}
 

References BAD_CIPHER_STATE, DIR_DECRYPT, cipherInstance::IV, key, cipherInstance::mode, MODE_CBC, MODE_CFB1, MODE_ECB, and rijndaelEncrypt().

Referenced by rijndael_encrypt(), rijndaelCBC_MCT(), rijndaelECB_MCT(), rijndaelTKAT(), rijndaelVKKAT(), and rijndaelVTKAT().

Here is the call graph for this function:

cipherInit()

int cipherInit	(	cipherInstance *	cipher,
		BYTE	mode,
		char *	IV )

Definition at line 105 of file crypt_aes.c.

{
        if ((mode == MODE_ECB) || (mode == MODE_CBC) || (mode == MODE_CFB1)) {
                cipher->mode = mode;
        } else {
                return BAD_CIPHER_MODE;
        }
        if (IV != NULL) {
                int i;
                for (i = 0; i < MAX_IV_SIZE; i++) {
                        int t, j;
 
                        t = IV[2 * i];
                        if ((t >= '0') && (t <= '9'))
                                j = (t - '0') << 4;
                        else if ((t >= 'a') && (t <= 'f'))
                                j = (t - 'a' + 10) << 4;
                        else if ((t >= 'A') && (t <= 'F'))
                                j = (t - 'A' + 10) << 4;
                        else
                                return BAD_CIPHER_INSTANCE;
 
                        t = IV[2 * i + 1];
                        if ((t >= '0') && (t <= '9'))
                                j ^= (t - '0');
                        else if ((t >= 'a') && (t <= 'f'))
                                j ^= (t - 'a' + 10);
                        else if ((t >= 'A') && (t <= 'F'))
                                j ^= (t - 'A' + 10);
                        else
                                return BAD_CIPHER_INSTANCE;
 
                        cipher->IV[i] = (u8) j;
                }
        } else {
                memset(cipher->IV, 0, MAX_IV_SIZE);
        }
        return TRUE;
}

References BAD_CIPHER_INSTANCE, BAD_CIPHER_MODE, cipherInstance::IV, MAX_IV_SIZE, cipherInstance::mode, mode, MODE_CBC, MODE_CFB1, MODE_ECB, and TRUE.

Referenced by rijndael_initialize(), rijndaelCBC_MCT(), rijndaelECB_MCT(), rijndaelIVKAT(), rijndaelTKAT(), rijndaelVKKAT(), and rijndaelVTKAT().

cipherUpdateRounds()

int cipherUpdateRounds	(	cipherInstance *	cipher,
		keyInstance *	key,
		BYTE *	input,
		int	inputLen,
		BYTE *	outBuffer,
		int	rounds )

cipherUpdateRounds:

Encrypts/Decrypts exactly one full block a specified number of rounds. Only used in the Intermediate Value Known Answer Test.

Returns: TRUE - on success BAD_CIPHER_STATE - cipher in bad state (e.g., not initialized)

Definition at line 444 of file crypt_aes.c.

{
        u8 block[16];
 
        UNUSED(inputLen);
 
        if (cipher == NULL || key == NULL) {
                return BAD_CIPHER_STATE;
        }
 
        memcpy(block, input, 16);
 
        switch (key->direction) {
        case DIR_ENCRYPT:
                rijndaelEncryptRound(key->rk, key->Nr, block, rounds);
                break;
 
        case DIR_DECRYPT:
                rijndaelDecryptRound(key->rk, key->Nr, block, rounds);
                break;
 
        default:
                return BAD_KEY_DIR;
        }
 
        memcpy(outBuffer, block, 16);
 
        return TRUE;
}

References BAD_CIPHER_STATE, BAD_KEY_DIR, DIR_DECRYPT, DIR_ENCRYPT, key, rijndaelDecryptRound(), rijndaelEncryptRound(), TRUE, and UNUSED.

Referenced by rijndaelIVKAT().

Here is the call graph for this function:

makeKey()

int makeKey	(	keyInstance *	key,
		BYTE	direction,
		int	keyLen,
		const char *	keyMaterial )

rijndael-api-fst.c

Version

2.9 (December 2000)

Optimised ANSI C code for the Rijndael cipher (now AES)

Author

Vincent Rijmen vince.nosp@m.nt.r.nosp@m.ijmen.nosp@m.@esa.nosp@m.t.kul.nosp@m.euve.nosp@m.n.ac..nosp@m.be

Antoon Bosselaers antoo.nosp@m.n.bo.nosp@m.ssela.nosp@m.ers@.nosp@m.esat..nosp@m.kule.nosp@m.uven..nosp@m.ac.b.nosp@m.e

Paulo Barreto paulo.nosp@m..bar.nosp@m.reto@.nosp@m.terr.nosp@m.a.com.nosp@m..br

This code is hereby placed in the public domain.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Acknowledgements:

We are deeply indebted to the following people for their bug reports, fixes, and improvement suggestions to this implementation. Though we tried to list all contributions, we apologise in advance for any missing reference.

Andrew Bales Andre.nosp@m.w.Ba.nosp@m.les@H.nosp@m.oney.nosp@m.well..nosp@m.com Markus Friedl marku.nosp@m.s.fr.nosp@m.iedl@.nosp@m.info.nosp@m.rmati.nosp@m.k.un.nosp@m.i-erl.nosp@m.ange.nosp@m.n.de John Skodon skodo.nosp@m.nj@w.nosp@m.ebqui.nosp@m.ll.c.nosp@m.om

Definition at line 45 of file crypt_aes.c.

{
        u8 cipherKey[MAXKB];
 
        if (key == NULL) {
                return BAD_KEY_INSTANCE;
        }
 
        if ((direction == DIR_ENCRYPT) || (direction == DIR_DECRYPT)) {
                key->direction = direction;
        } else {
                return BAD_KEY_DIR;
        }
 
        if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) {
                key->keyLen = keyLen;
        } else {
                return BAD_KEY_MAT;
        }
 
        if (keyMaterial != NULL) {
                strncpy(key->keyMaterial, keyMaterial, keyLen / 4);
        }
 
        /* initialize key schedule: */
        const char *keyMat = key->keyMaterial;
        for (int i = 0; i < key->keyLen / 8; i++) {
                int t = *keyMat++;
                int v;
 
                if ((t >= '0') && (t <= '9'))
                        v = (t - '0') << 4;
                else if ((t >= 'a') && (t <= 'f'))
                        v = (t - 'a' + 10) << 4;
                else if ((t >= 'A') && (t <= 'F'))
                        v = (t - 'A' + 10) << 4;
                else
                        return BAD_KEY_MAT;
 
                t = *keyMat++;
                if ((t >= '0') && (t <= '9'))
                        v ^= (t - '0');
                else if ((t >= 'a') && (t <= 'f'))
                        v ^= (t - 'a' + 10);
                else if ((t >= 'A') && (t <= 'F'))
                        v ^= (t - 'A' + 10);
                else
                        return BAD_KEY_MAT;
 
                cipherKey[i] = (u8) v;
        }
        if (direction == DIR_ENCRYPT) {
                key->Nr = rijndaelKeySetupEnc(key->rk, cipherKey, keyLen);
        } else {
                key->Nr = rijndaelKeySetupDec(key->rk, cipherKey, keyLen);
        }
        rijndaelKeySetupEnc(key->ek, cipherKey, keyLen);
        return TRUE;
}

References BAD_KEY_DIR, BAD_KEY_INSTANCE, BAD_KEY_MAT, DIR_DECRYPT, DIR_ENCRYPT, key, MAXKB, rijndaelKeySetupDec(), rijndaelKeySetupEnc(), and TRUE.

Referenced by rijndael_initialize(), rijndaelCBC_MCT(), rijndaelECB_MCT(), rijndaelIVKAT(), rijndaelTKAT(), rijndaelVKKAT(), and rijndaelVTKAT().

Here is the call graph for this function:

padDecrypt()

int padDecrypt	(	cipherInstance *	cipher,
		keyInstance *	key,
		BYTE *	input,
		int	inputOctets,
		BYTE *	outBuffer )

Definition at line 356 of file crypt_aes.c.

{
        int i, numBlocks, padLen;
        u8 block[16];
 
        if (cipher == NULL || key == NULL || key->direction == DIR_ENCRYPT) {
                return BAD_CIPHER_STATE;
        }
        if (input == NULL || inputOctets <= 0) {
                return 0;       /* nothing to do */
        }
        if (inputOctets % 16 != 0) {
                return BAD_DATA;
        }
 
        numBlocks = inputOctets / 16;
 
        switch (cipher->mode) {
        case MODE_ECB:
                /* all blocks but last */
                for (i = numBlocks - 1; i > 0; i--) {
                        rijndaelDecrypt(key->rk, key->Nr, input, outBuffer);
                        input += 16;
                        outBuffer += 16;
                }
                /* last block */
                rijndaelDecrypt(key->rk, key->Nr, input, block);
                padLen = block[15];
                if (padLen >= 16) {
                        return BAD_DATA;
                }
                for (i = 16 - padLen; i < 16; i++) {
                        if (block[i] != padLen) {
                                return BAD_DATA;
                        }
                }
                memcpy(outBuffer, block, 16 - padLen);
                break;
 
        case MODE_CBC:
                /* all blocks but last */
                for (i = numBlocks - 1; i > 0; i--) {
                        rijndaelDecrypt(key->rk, key->Nr, input, block);
                        ((u32 *)(void *) block)[0] ^= ((u32 *)(void *) cipher->IV)[0];
                        ((u32 *)(void *) block)[1] ^= ((u32 *)(void *) cipher->IV)[1];
                        ((u32 *)(void *) block)[2] ^= ((u32 *)(void *) cipher->IV)[2];
                        ((u32 *)(void *) block)[3] ^= ((u32 *)(void *) cipher->IV)[3];
                        memcpy(cipher->IV, input, 16);
                        memcpy(outBuffer, block, 16);
                        input += 16;
                        outBuffer += 16;
                }
                /* last block */
                rijndaelDecrypt(key->rk, key->Nr, input, block);
                ((u32 *)(void *) block)[0] ^= ((u32 *)(void *) cipher->IV)[0];
                ((u32 *)(void *) block)[1] ^= ((u32 *)(void *) cipher->IV)[1];
                ((u32 *)(void *) block)[2] ^= ((u32 *)(void *) cipher->IV)[2];
                ((u32 *)(void *) block)[3] ^= ((u32 *)(void *) cipher->IV)[3];
                padLen = block[15];
                if (padLen <= 0 || padLen > 16) {
                        return BAD_DATA;
                }
                for (i = 16 - padLen; i < 16; i++) {
                        if (block[i] != padLen) {
                                return BAD_DATA;
                        }
                }
                memcpy(outBuffer, block, 16 - padLen);
                break;
 
        default:
                return BAD_CIPHER_STATE;
        }
 
        return 16 * numBlocks - padLen;
}
 

References BAD_CIPHER_STATE, BAD_DATA, DIR_ENCRYPT, cipherInstance::IV, key, cipherInstance::mode, MODE_CBC, MODE_ECB, and rijndaelDecrypt().

Here is the call graph for this function:

padEncrypt()

int padEncrypt	(	cipherInstance *	cipher,
		keyInstance *	key,
		BYTE *	input,
		int	inputOctets,
		BYTE *	outBuffer )

Encrypt data partitioned in octets, using RFC 2040-like padding.

Parameters

input	data to be encrypted (octet sequence)
inputOctets	input length in octets (not bits)
outBuffer	encrypted output data

Returns

length in octets (not bits) of the encrypted output buffer.

Definition at line 224 of file crypt_aes.c.

{
        int i, numBlocks, padLen;
        u8 block[16], *iv;
 
        if (cipher == NULL || key == NULL || key->direction == DIR_DECRYPT) {
                return BAD_CIPHER_STATE;
        }
        if (input == NULL || inputOctets <= 0) {
                return 0;       /* nothing to do */
        }
 
        numBlocks = inputOctets / 16;
 
        switch (cipher->mode) {
        case MODE_ECB:
                for (i = numBlocks; i > 0; i--) {
                        rijndaelEncrypt(key->rk, key->Nr, input, outBuffer);
                        input += 16;
                        outBuffer += 16;
                }
                padLen = 16 - (inputOctets - 16 * numBlocks);
                assert(padLen > 0 && padLen <= 16);
                memcpy(block, input, 16 - padLen);
                memset(block + 16 - padLen, padLen, padLen);
                rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
                break;
 
        case MODE_CBC:
                iv = cipher->IV;
                for (i = numBlocks; i > 0; i--) {
                        ((u32 *)(void *) block)[0] =
                            ((u32 *)(void *) input)[0] ^ ((u32 *)(void *) iv)[0];
                        ((u32 *)(void *) block)[1] =
                            ((u32 *)(void *) input)[1] ^ ((u32 *)(void *) iv)[1];
                        ((u32 *)(void *) block)[2] =
                            ((u32 *)(void *) input)[2] ^ ((u32 *)(void *) iv)[2];
                        ((u32 *)(void *) block)[3] =
                            ((u32 *)(void *) input)[3] ^ ((u32 *)(void *) iv)[3];
                        rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
                        iv = outBuffer;
                        input += 16;
                        outBuffer += 16;
                }
                padLen = 16 - (inputOctets - 16 * numBlocks);
                assert(padLen > 0 && padLen <= 16);
                for (i = 0; i < 16 - padLen; i++) {
                        block[i] = input[i] ^ iv[i];
                }
                for (i = 16 - padLen; i < 16; i++) {
                        block[i] = (BYTE) padLen ^ iv[i];
                }
                rijndaelEncrypt(key->rk, key->Nr, block, outBuffer);
                break;
 
        default:
                return BAD_CIPHER_STATE;
        }
 
        return 16 * (numBlocks + 1);
}
 

References BAD_CIPHER_STATE, DIR_DECRYPT, cipherInstance::IV, key, cipherInstance::mode, MODE_CBC, MODE_ECB, and rijndaelEncrypt().

Here is the call graph for this function: