Référence du fichier aes.c

Utilisée pour décrypter des shaders données en archive cryptée AES. Plus de détails...

#include <string.h>
#include <stdio.h>
#include <errno.h>
#include "aes.h"
#include "gl4dummies.h"
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>

Graphe des dépendances par inclusion de aes.c:

Aller au code source de ce fichier.

Macros
#define	uint8   unsigned char
#define	uint32   unsigned long
#define	GET_UINT32_BE(n, b, i)
#define	PUT_UINT32_BE(n, b, i)
#define	ROTR8(x)
#define	XTIME(x)   ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
#define	MUL(x, y)   ( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 )
#define	AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)
#define	AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3)

Fonctions
static void	aes_gen_tables (void)
void	aes_set_key (aes_context *ctx, uint8 *key, int keysize)
void	aes_encrypt (aes_context *ctx, unsigned char input[16], unsigned char output[16])
	AES block encryption (ECB mode) Plus de détails...
void	aes_decrypt (aes_context *ctx, unsigned char input[16], unsigned char output[16])
	AES block decryption (ECB mode) Plus de détails...
void	aes_cbc_encrypt (aes_context *ctx, unsigned char iv[16], unsigned char *input, unsigned char *output, int len)
	AES-CBC buffer encryption. Plus de détails...
void	aes_cbc_decrypt (aes_context *ctx, unsigned char iv[16], unsigned char *input, unsigned char *output, int len)
	AES-CBC buffer decryption. Plus de détails...
void	vaetvient (unsigned char *data, int len, int vaouvient)
char *	aes_from_tar (const char *file)
int	aes_self_test (void)
	Checkup routine. Plus de détails...

Variables
static uint8	FSb [256]
static uint32	FT0 [256]
static uint32	FT1 [256]
static uint32	FT2 [256]
static uint32	FT3 [256]
static uint8	RSb [256]
static uint32	RT0 [256]
static uint32	RT1 [256]
static uint32	RT2 [256]
static uint32	RT3 [256]
static uint32	RCON [10]
static uint32	KT0 [256]
static uint32	KT1 [256]
static uint32	KT2 [256]
static uint32	KT3 [256]

Description détaillée

Utilisée pour décrypter des shaders données en archive cryptée AES.

FIPS-197 compliant AES implementation
Copyright (C) 2003-2006 Christophe Devine
This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf

Auteur

Christophe Devine

Définition dans le fichier aes.c.

Documentation des macros

AES_FROUND

#define AES_FROUND	(		X0,
			X1,
			X2,
			X3,
			Y0,
			Y1,
			Y2,
			Y3
	)

Valeur :

{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ FT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X1 = RK[1] ^ FT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y0       ) ];           \
                                                        \
    X2 = RK[2] ^ FT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X3 = RK[3] ^ FT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y2       ) ];           \
}

AES_RROUND

#define AES_RROUND	(		X0,
			X1,
			X2,
			X3,
			Y0,
			Y1,
			Y2,
			Y3
	)

Valeur :

{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ RT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X1 = RK[1] ^ RT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y2       ) ];           \
                                                        \
    X2 = RK[2] ^ RT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X3 = RK[3] ^ RT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y0       ) ];           \
}

GET_UINT32_BE

#define GET_UINT32_BE	(		n,
			b,
			i
	)

Valeur :

{                                                       \
    (n) = ( (uint32) (b)[(i)    ] << 24 )        \
        | ( (uint32) (b)[(i) + 1] << 16 )        \
        | ( (uint32) (b)[(i) + 2] <<  8 )        \
        | ( (uint32) (b)[(i) + 3]       );       \
}

MUL

#define MUL	(		x,
			y
	)		( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 )

PUT_UINT32_BE

#define PUT_UINT32_BE	(		n,
			b,
			i
	)

Valeur :

{                                                       \
    (b)[(i)    ] = (uint8) ( (n) >> 24 );       \
    (b)[(i) + 1] = (uint8) ( (n) >> 16 );       \
    (b)[(i) + 2] = (uint8) ( (n) >>  8 );       \
    (b)[(i) + 3] = (uint8) ( (n)       );       \
}

ROTR8

#define ROTR8

(

x

)

Valeur :

                   ( ( ( x << 24 ) & 0xFFFFFFFF ) | \
                   ( ( x & 0xFFFFFFFF ) >> 8 ) )

uint32

#define uint32   unsigned long

uint8

#define uint8   unsigned char

XTIME

#define XTIME

(

x

)

( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )

Documentation des fonctions

aes_cbc_decrypt()

void aes_cbc_decrypt	(	aes_context *	ctx,
		unsigned char	iv[16],
		unsigned char *	input,
		unsigned char *	output,
		int	len
	)

AES-CBC buffer decryption.

Paramètres

ctx	AES context
iv	initialization vector (modified after use)
input	buffer holding the ciphertext
output	buffer holding the plaintext
len	length of the data to be decrypted

{
    int i;
    unsigned char temp[16];
 
    while( len > 0 )
    {
        memcpy( temp, input, 16 );
        aes_decrypt( ctx, input, output );
 
        for( i = 0; i < 16; i++ )
            output[i] = output[i] ^ iv[i];
 
        memcpy( iv, temp, 16 );
 
        input  += 16;
        output += 16;
        len    -= 16;
    }
}

Références aes_decrypt().

aes_cbc_encrypt()

void aes_cbc_encrypt	(	aes_context *	ctx,
		unsigned char	iv[16],
		unsigned char *	input,
		unsigned char *	output,
		int	len
	)

AES-CBC buffer encryption.

Paramètres

ctx	AES context
iv	initialization vector (modified after use)
input	buffer holding the plaintext
output	buffer holding the ciphertext
len	length of the data to be encrypted

{
    int i;
 
    while( len > 0 )
    {
        for( i = 0; i < 16; i++ )
            output[i] = input[i] ^ iv[i];
 
        aes_encrypt( ctx, output, output );
        memcpy( iv, output, 16 );
 
        input  += 16;
        output += 16;
        len    -= 16;
    }
}

Références aes_encrypt().

aes_decrypt()

void aes_decrypt	(	aes_context *	ctx,
		unsigned char	input[16],
		unsigned char	output[16]
	)

AES block decryption (ECB mode)

Paramètres

ctx	AES context
input	ciphertext block
output	plaintext block

{
    uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
 
    RK = ctx->drk;
 
    GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
    GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
    GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
    GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
 
#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)             \
{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ RT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X1 = RK[1] ^ RT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y2       ) ];           \
                                                        \
    X2 = RK[2] ^ RT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X3 = RK[3] ^ RT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 RT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 RT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 RT3[ (uint8) ( Y0       ) ];           \
}
 
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 
    if( ctx->nr > 10 )
    {
        AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }
 
    if( ctx->nr > 12 )
    {
        AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }
 
    RK += 4;
 
    X0 = RK[0] ^ ( RSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y1       ) ]       );
 
    X1 = RK[1] ^ ( RSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y2       ) ]       );
 
    X2 = RK[2] ^ ( RSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y3       ) ]       );
 
    X3 = RK[3] ^ ( RSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
                 ( RSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
                 ( RSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
                 ( RSb[ (uint8) ( Y0       ) ]       );
 
    PUT_UINT32_BE( X0, output,  0 );
    PUT_UINT32_BE( X1, output,  4 );
    PUT_UINT32_BE( X2, output,  8 );
    PUT_UINT32_BE( X3, output, 12 );
}

Références AES_RROUND, aes_context::drk, GET_UINT32_BE, aes_context::nr, PUT_UINT32_BE, RSb, uint32, et uint8.

Référencé par aes_cbc_decrypt(), et vaetvient().

aes_encrypt()

void aes_encrypt	(	aes_context *	ctx,
		unsigned char	input[16],
		unsigned char	output[16]
	)

AES block encryption (ECB mode)

AES block encryption (ECB mode)

{
    uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
 
    RK = ctx->erk;
 
    GET_UINT32_BE( X0, input,  0 ); X0 ^= RK[0];
    GET_UINT32_BE( X1, input,  4 ); X1 ^= RK[1];
    GET_UINT32_BE( X2, input,  8 ); X2 ^= RK[2];
    GET_UINT32_BE( X3, input, 12 ); X3 ^= RK[3];
 
#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)             \
{                                                       \
    RK += 4;                                            \
                                                        \
    X0 = RK[0] ^ FT0[ (uint8) ( Y0 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y1 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y2 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y3       ) ];           \
                                                        \
    X1 = RK[1] ^ FT0[ (uint8) ( Y1 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y2 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y3 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y0       ) ];           \
                                                        \
    X2 = RK[2] ^ FT0[ (uint8) ( Y2 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y3 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y0 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y1       ) ];           \
                                                        \
    X3 = RK[3] ^ FT0[ (uint8) ( Y3 >> 24 ) ] ^          \
                 FT1[ (uint8) ( Y0 >> 16 ) ] ^          \
                 FT2[ (uint8) ( Y1 >>  8 ) ] ^          \
                 FT3[ (uint8) ( Y2       ) ];           \
}
 
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
    AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
 
    if( ctx->nr > 10 )
    {
        AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }
 
    if( ctx->nr > 12 )
    {
        AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
    }
 
    RK += 4;
 
    X0 = RK[0] ^ ( FSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y2 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y3       ) ]       );
 
    X1 = RK[1] ^ ( FSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y3 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y0       ) ]       );
 
    X2 = RK[2] ^ ( FSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y0 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y1       ) ]       );
 
    X3 = RK[3] ^ ( FSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^
                 ( FSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^
                 ( FSb[ (uint8) ( Y1 >>  8 ) ] <<  8 ) ^
                 ( FSb[ (uint8) ( Y2       ) ]       );
 
    PUT_UINT32_BE( X0, output,  0 );
    PUT_UINT32_BE( X1, output,  4 );
    PUT_UINT32_BE( X2, output,  8 );
    PUT_UINT32_BE( X3, output, 12 );
}

Références AES_FROUND, aes_context::erk, FSb, GET_UINT32_BE, aes_context::nr, PUT_UINT32_BE, uint32, et uint8.

Référencé par aes_cbc_encrypt(), et vaetvient().

aes_from_tar()

char* aes_from_tar

(

const char *

file

)

                                              {
  size_t l = 0;
  char * data = NULL;
  FILE * f;
  struct stat buf;
  if(stat(file, &buf) != 0) {
    fprintf(stderr, "%s:%d: erreur %d: %s\n", __FILE__, __LINE__, errno, strerror(errno));
    return NULL;
  }
  data = malloc( (buf.st_size + 1) * sizeof * data );
  assert(data);
  if( (f = fopen(file, "rb")) == NULL ) {
    fprintf(stderr, "%s:%d: erreur %d: %s\n", __FILE__, __LINE__, errno, strerror(errno));
    free(data);
    return NULL;
  }
  if( (l = fread(data, sizeof * data, buf.st_size, f)) != (size_t)buf.st_size) {
    fprintf(stderr, "%s:%d:In %s: une erreur s'est produite lors de la lecture du fichier %s\n",
        __FILE__, __LINE__, __func__, file);
    free(data);
    fclose(f);
    return NULL;
  }
  fclose(f);
  vaetvient((unsigned char *)data, (int)l, 1);
  return data;
}

Références vaetvient().

Référencé par gl4duCreateProgramFED().

aes_gen_tables()

static void aes_gen_tables ( void  )

static

{
    int i;
    uint8 x, y;
    uint8 pow[256];
    uint8 log[256];
 
    /*
     * compute pow and log tables over GF(2^8)
     */
    for( i = 0, x = 1; i < 256; i++, x ^= XTIME( x ) )
    {
        pow[i] = x;
        log[x] = i;
    }
 
    /*
     * calculate the round constants
     */
    for( i = 0, x = 1; i < 10; i++, x = XTIME( x ) )
    {
        RCON[i] = (uint32) x << 24;
    }
 
    /*
     * generate the forward and reverse S-boxes
     */
    FSb[0x00] = 0x63;
    RSb[0x63] = 0x00;
 
    for( i = 1; i < 256; i++ )
    {
        x = pow[255 - log[i]];
 
        y  = x; y = ( y << 1 ) | ( y >> 7 );
        x ^= y; y = ( y << 1 ) | ( y >> 7 );
        x ^= y; y = ( y << 1 ) | ( y >> 7 );
        x ^= y; y = ( y << 1 ) | ( y >> 7 );
        x ^= y ^ 0x63;
 
        FSb[i] = x;
        RSb[x] = i;
    }
 
    /*
     * generate the forward and reverse tables
     */
    for( i = 0; i < 256; i++ )
    {
        x = FSb[i]; y = XTIME( x );
 
        FT0[i] =   (uint32) ( x ^ y ) ^
                 ( (uint32) x <<  8 ) ^
                 ( (uint32) x << 16 ) ^
                 ( (uint32) y << 24 );
 
        FT0[i] &= 0xFFFFFFFF;
 
        FT1[i] = ROTR8( FT0[i] );
        FT2[i] = ROTR8( FT1[i] );
        FT3[i] = ROTR8( FT2[i] );
 
        y = RSb[i];
 
        RT0[i] = ( (uint32) MUL( 0x0B, y )       ) ^
                 ( (uint32) MUL( 0x0D, y ) <<  8 ) ^
                 ( (uint32) MUL( 0x09, y ) << 16 ) ^
                 ( (uint32) MUL( 0x0E, y ) << 24 );
 
        RT0[i] &= 0xFFFFFFFF;
 
        RT1[i] = ROTR8( RT0[i] );
        RT2[i] = ROTR8( RT1[i] );
        RT3[i] = ROTR8( RT2[i] );
    }
}

Références FSb, FT0, FT1, FT2, FT3, MUL, RCON, ROTR8, RSb, RT0, RT1, RT2, RT3, uint32, uint8, et XTIME.

Référencé par aes_set_key().

aes_self_test()

int aes_self_test

(

void

)

Checkup routine.

Renvoie

0 if successful, or 1 if the test failed

                          {
    return 0;
}

aes_set_key()

void aes_set_key	(	aes_context *	ctx,
		uint8 *	key,
		int	keysize
	)

{
    int i;
    uint32 *RK, *SK;
    static int ft_init = 0;
    static int kt_init = 0;
 
    if( ft_init == 0 )
    {
        aes_gen_tables();
 
        ft_init = 1;
    }
 
    switch( keysize )
    {
        case 128: ctx->nr = 10; break;
        case 192: ctx->nr = 12; break;
        case 256: ctx->nr = 14; break;
        default : return;
    }
 
    RK = ctx->erk;
 
    for( i = 0; i < (keysize >> 5); i++ )
    {
        GET_UINT32_BE( RK[i], key, i << 2 );
    }
 
    /*
     * setup encryption round keys
     */
    switch( ctx->nr )
    {
    case 10:
 
        for( i = 0; i < 10; i++, RK += 4 )
        {
            RK[4]  = RK[0] ^ RCON[i] ^
                ( FSb[ (uint8) ( RK[3] >> 16 ) ] << 24 ) ^
                ( FSb[ (uint8) ( RK[3] >>  8 ) ] << 16 ) ^
                ( FSb[ (uint8) ( RK[3]       ) ] <<  8 ) ^
                ( FSb[ (uint8) ( RK[3] >> 24 ) ]       );
 
            RK[5]  = RK[1] ^ RK[4];
            RK[6]  = RK[2] ^ RK[5];
            RK[7]  = RK[3] ^ RK[6];
        }
        break;
 
    case 12:
 
        for( i = 0; i < 8; i++, RK += 6 )
        {
            RK[6]  = RK[0] ^ RCON[i] ^
                ( FSb[ (uint8) ( RK[5] >> 16 ) ] << 24 ) ^
                ( FSb[ (uint8) ( RK[5] >>  8 ) ] << 16 ) ^
                ( FSb[ (uint8) ( RK[5]       ) ] <<  8 ) ^
                ( FSb[ (uint8) ( RK[5] >> 24 ) ]       );
 
            RK[7]  = RK[1] ^ RK[6];
            RK[8]  = RK[2] ^ RK[7];
            RK[9]  = RK[3] ^ RK[8];
            RK[10] = RK[4] ^ RK[9];
            RK[11] = RK[5] ^ RK[10];
        }
        break;
 
    case 14:
 
        for( i = 0; i < 7; i++, RK += 8 )
        {
            RK[8]  = RK[0] ^ RCON[i] ^
                ( FSb[ (uint8) ( RK[7] >> 16 ) ] << 24 ) ^
                ( FSb[ (uint8) ( RK[7] >>  8 ) ] << 16 ) ^
                ( FSb[ (uint8) ( RK[7]       ) ] <<  8 ) ^
                ( FSb[ (uint8) ( RK[7] >> 24 ) ]       );
 
            RK[9]  = RK[1] ^ RK[8];
            RK[10] = RK[2] ^ RK[9];
            RK[11] = RK[3] ^ RK[10];
 
            RK[12] = RK[4] ^
                ( FSb[ (uint8) ( RK[11] >> 24 ) ] << 24 ) ^
                ( FSb[ (uint8) ( RK[11] >> 16 ) ] << 16 ) ^
                ( FSb[ (uint8) ( RK[11] >>  8 ) ] <<  8 ) ^
                ( FSb[ (uint8) ( RK[11]       ) ]       );
 
            RK[13] = RK[5] ^ RK[12];
            RK[14] = RK[6] ^ RK[13];
            RK[15] = RK[7] ^ RK[14];
        }
        break;
 
    default:
 
        break;
    }
 
    /*
     * setup decryption round keys
     */
    if( kt_init == 0 )
    {
        for( i = 0; i < 256; i++ )
        {
            KT0[i] = RT0[ FSb[i] ];
            KT1[i] = RT1[ FSb[i] ];
            KT2[i] = RT2[ FSb[i] ];
            KT3[i] = RT3[ FSb[i] ];
        }
 
        kt_init = 1;
    }
 
    SK = ctx->drk;
 
    *SK++ = *RK++;
    *SK++ = *RK++;
    *SK++ = *RK++;
    *SK++ = *RK++;
 
    for( i = 1; i < ctx->nr; i++ )
    {
        RK -= 8;
 
        *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
                KT1[ (uint8) ( *RK >> 16 ) ] ^
                KT2[ (uint8) ( *RK >>  8 ) ] ^
                KT3[ (uint8) ( *RK       ) ]; RK++;
 
        *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
                KT1[ (uint8) ( *RK >> 16 ) ] ^
                KT2[ (uint8) ( *RK >>  8 ) ] ^
                KT3[ (uint8) ( *RK       ) ]; RK++;
 
        *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
                KT1[ (uint8) ( *RK >> 16 ) ] ^
                KT2[ (uint8) ( *RK >>  8 ) ] ^
                KT3[ (uint8) ( *RK       ) ]; RK++;
 
        *SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^
                KT1[ (uint8) ( *RK >> 16 ) ] ^
                KT2[ (uint8) ( *RK >>  8 ) ] ^
                KT3[ (uint8) ( *RK       ) ]; RK++;
    }
 
    RK -= 8;
 
    *SK++ = *RK++;
    *SK++ = *RK++;
    *SK++ = *RK++;
    *SK++ = *RK++;
}

Références aes_gen_tables(), aes_context::drk, aes_context::erk, FSb, GET_UINT32_BE, KT0, KT1, KT2, KT3, aes_context::nr, RCON, RT0, RT1, RT2, RT3, uint32, et uint8.

Référencé par vaetvient().

vaetvient()

void vaetvient	(	unsigned char *	data,
		int	len,
		int	vaouvient
	)

                                                                    {
    int i;
    static aes_context ctx;
    static int ft = 1;
    static unsigned char buf[32] = { 0xAA, 0x99, 0x55, 0x51, 0x25, 0x76, 0x58, 0x8C,
                                     0xFA, 0x10, 0x54, 0x11, 0xCA, 0xCD, 0xDD, 0xAD,
                                     0x21, 0x30, 0xAB, 0xB5, 0x5D, 0x2B, 0x3C, 0x7A,
                                     0xDC, 0x24, 0xCD, 0xA1, 0xF3, 0x39, 0x95, 0x00 };
    if(ft) {
        aes_set_key( &ctx, buf, 256 );
        for(i = 0; i < 15; i++)
            aes_encrypt(&ctx, buf, buf);
        aes_set_key( &ctx, buf, 256 );
        ft = 0;
    }
    i = 0;
    if(vaouvient == 0) {
        while(i < len) {
            aes_encrypt(&ctx, &data[i], &data[i]);
            i += 16;
        }
    } else {
        while(i < len) {
            aes_decrypt(&ctx, &data[i], &data[i]);
            i += 16;
        }
    }
}

Références aes_decrypt(), aes_encrypt(), et aes_set_key().

Référencé par aes_from_tar().

Documentation des variables

FSb

uint8 FSb[256]

static

Référencé par aes_encrypt(), aes_gen_tables(), et aes_set_key().

FT0

uint32 FT0[256]

static

Référencé par aes_gen_tables().

FT1

uint32 FT1[256]

static

Référencé par aes_gen_tables().

FT2

uint32 FT2[256]

static

Référencé par aes_gen_tables().

FT3

uint32 FT3[256]

static

Référencé par aes_gen_tables().

KT0

uint32 KT0[256]

static

Référencé par aes_set_key().

KT1

uint32 KT1[256]

static

Référencé par aes_set_key().

KT2

uint32 KT2[256]

static

Référencé par aes_set_key().

KT3

uint32 KT3[256]

static

Référencé par aes_set_key().

RCON

uint32 RCON[10]

static

Référencé par aes_gen_tables(), et aes_set_key().

RSb

uint8 RSb[256]

static

Référencé par aes_decrypt(), et aes_gen_tables().

RT0

uint32 RT0[256]

static

Référencé par aes_gen_tables(), et aes_set_key().

RT1

uint32 RT1[256]

static

Référencé par aes_gen_tables(), et aes_set_key().

RT2

uint32 RT2[256]

static

Référencé par aes_gen_tables(), et aes_set_key().

RT3

uint32 RT3[256]

static

Référencé par aes_gen_tables(), et aes_set_key().