#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "aeslib.h"



#define ROTL(x) (((x)>>7)|((x)<<1))
#define ROTR(x) (((x)<<7)|((x)>>1))

/* Rotation mot de 32 bits */

#define ROTL8(x) (((x)<<8)|((x)>>24))
#define ROTL16(x) (((x)<<16)|((x)>>16))
#define ROTL24(x) (((x)<<24)|((x)>>8))

#define ROTR8(x) (((x)>>8)|((x)<<24))
#define ROTR16(x) (((x)>>16)|((x)<<16))
#define ROTR24(x) (((x)>>24)|((x)<<8))


static BYTE InCo[4]={0xB,0xD,0x9,0xE};  /*Coeff. InvMixCol */

static BYTE fbsub[256];/* ByteSub(i) est stocke dans fbsub[i]*/
static BYTE rbsub[256];/* l'inverse de ByteSub est stocke dans rsub*/

//static BYTE ptab[256],ltab[256];

static WORD ftable[256];/* tableau T_0 */
static WORD rtable[256];/* inverse de T_0 */
static WORD rco[30]; 
/* taille maximale de la constante de tour ajoutée à chaque position multiple de Nk. Si Nb=8 il y a 120 éléments dans la clé éténdue et si 
Nk=4 (plus petite valeur) 
alors il y a 30 multiples de Nk*/


BYTE Nr, Nb, Nk;/* Nr le nombre de tours, Nb le nombre de colonnes d'un block, Nk le nombre de colonnes de la cle*/
 
BYTE fi[24],ri[24]; /* table des shifts */
WORD fkey[120]; /* taille maximale de la clé étendue dans le cas où Nb=8, on a alors Nr = Nb+6 = 14 et Nb(Nr+1)= 120 */
WORD rkey[120]; /* tableau de la clé étendue inverse */

static WORD pack(BYTE *b)
{ /* 4 octets -> 1 mot de 32 bits */
    return ((WORD)b[0]<<24)|((WORD)b[1]<<16)|((WORD)b[2]<<8)|(WORD)b[3];
}

static void unpack(WORD a,BYTE *b)
{ /* 1 mot de 32 bits -> 4 octets */
    b[3]=(BYTE)a;
    b[2]=(BYTE)(a>>8);
    b[1]=(BYTE)(a>>16);
    b[0]=(BYTE)(a>>24);
}

static BYTE xtime(BYTE a)
{
  /////////A completer
}

static BYTE bmul(BYTE x,BYTE y)
{ 
  ////////A completer
}

static WORD SubByte(WORD a)
{
    BYTE b[4];
    
    unpack(a,b);
    b[0]=fbsub[b[0]];
    b[1]=fbsub[b[1]];
    b[2]=fbsub[b[2]];
    b[3]=fbsub[b[3]];
    return pack(b);    
}

static BYTE product(WORD x,WORD y)
{ /* produit de 2 polys de degré 4, a été écrit spécialement  */
/* pour InvMixCol */

    BYTE xb[4],yb[4];
    unpack(x,xb);
    unpack(y,yb); 
    return bmul(xb[0],yb[0])^bmul(xb[1],yb[1])^bmul(xb[2],yb[2])^bmul(xb[3],yb[3]);
}

static WORD InvMixCol(WORD x)
{ /* matrix Multiplication */
    WORD y,m;
    BYTE b[4];

    m=pack(InCo);
    b[3]=product(m,x);
    m=ROTL8(m);
    b[2]=product(m,x);
    m=ROTL8(m);
    b[1]=product(m,x);
    m=ROTL8(m);
    b[0]=product(m,x);
    y=pack(b);
    return y;
}

BYTE ByteSub(BYTE x)
{
  ////////// A completer
}



void gkey(BYTE *key)
{ 

    int i,j,k,m,N;
    int C1,C2,C3;
    
  /* Calcul du nombre de tours */
    if (Nb>=Nk) Nr=6+Nb;
    else        Nr=6+Nk;

    C1=1;
    if (Nb<8) { C2=2; C3=3; }
    else      { C2=3; C3=4; }

  /* Calcul des tables de shifts */
    for (m=j=0;j<Nb;j++,m+=3)
    {
        fi[m]=(Nb+j-C1)%Nb;
        fi[m+1]=(Nb+j-C2)%Nb;
        fi[m+2]=(Nb+j-C3)%Nb;
        ri[m]=(j+C1)%Nb;
        ri[m+1]=(j+C2)%Nb;
        ri[m+2]=(j+C3)%Nb;
    }

    N=Nb*(Nr+1);
    
    for (i=j=0;i<Nk;i++,j+=4)
        fkey[i]=pack((BYTE *)&key[j]);
    for (j=Nk,k=0;j<N;j+=Nk,k++)
    {
        fkey[j]=fkey[j-Nk]^SubByte(ROTL8(fkey[j-1]))^(((WORD)rco[k+1]) << 24);
        if (Nk<=6)
        {
            for (i=1;i<Nk && (i+j)<N;i++)
                fkey[i+j]=fkey[i+j-Nk]^fkey[i+j-1];
        }
        else
        {
            for (i=1;i<4 &&(i+j)<N;i++)
                fkey[i+j]=fkey[i+j-Nk]^fkey[i+j-1];
            if ((j+4)<N) fkey[j+4]=fkey[j+4-Nk]^SubByte(fkey[j+3]);
            for (i=5;i<Nk && (i+j)<N;i++)
                fkey[i+j]=fkey[i+j-Nk]^fkey[i+j-1];
        }

    }

 /* Clé étendue inverse */

    for (j=0;j<Nb;j++) rkey[j+N-Nb]=fkey[j]; 
    for (i=Nb;i<N-Nb;i+=Nb)
    {
        k=N-Nb-i;
        for (j=0;j<Nb;j++) rkey[k+j]=InvMixCol(fkey[i+j]);
    }
    for (j=N-Nb;j<N;j++) rkey[j-N+Nb]=fkey[j];
}


int gentables(int size, int sizekey, BYTE *key)
{ 
    int i, status;
    BYTE y,b[4];
    
    status = 1;
    if (size < 16)
       return(0);
    if ((size > 16) && (size < 24))
      {
        size = 16;
	status = 2;
      }
    else if ((size > 24) && (size < 32))
      {
       size = 24;
       status = 3;
      }
     else if (size > 32)
       {
         size = 32;
	 status = 4;
       }   
    
   Nb = (size >> 2);
    if (sizekey < 16)
       return(0);
    if ((sizekey > 16) && (sizekey < 24))
      {
        sizekey = 16;
	status = 5;
      }
    else if ((sizekey > 24) && (sizekey < 32))
      {
       sizekey = 24;
       status = 6;
      }
     else if (sizekey > 32)
       {
         sizekey = 32;
	 status = 7;
       }   
   Nk = (sizekey >> 2);


/* construction des boites S et S^{-1}*/

   ////// Construire la table fbsub 

   /*construction de la boite  S^{-1}*/
   for (i=1;i<256;i++)
    {
        y=ByteSub((BYTE)i);
        rbsub[y]=i;
    }

/* calcul de la constante de tour */

    for (i=0,y=1;i<30;i++)
    {
        rco[i]=y;
        y=xtime(y);
    }

  /* calcul des tables T décrites dans le papier  sur le Rijndael */
   
    // construire la ftable  à T_0 

    /* Calcul de la table de déchiffrement */

 for (i=0;i<256;i++)
    {
       
        y=rbsub[i];
        b[3]=bmul(InCo[0],y); b[2]=bmul(InCo[1],y);
        b[1]=bmul(InCo[2],y); b[0]=bmul(InCo[3],y);
        rtable[i]=pack(b);
    }

    gkey(key);
    return(status);
}


void encrypt(BYTE *buff)
{
    int i,j,k,m;
    WORD *x,*y,*t;
    
   
    y = (WORD *)malloc(8*sizeof(WORD));
    x = (WORD *)malloc(8*sizeof(WORD));

    /* Initialisation de l'algorithme */
    for (i=j=0;i<Nb;i++,j+=4)
    {
        x[i]=pack((BYTE *)&buff[j]);	
        x[i]^=fkey[i]; 
    }


 
    k=Nb;
    for (i=1;i<Nr;i++)
    { 
      /* tour 1 à Nr-1 */
      

      ///// A  compléter
      


        t=x; x=y; y=t;     
    }

/* Dernier tour */
    ///// A compléter



    for (i=j=0;i<Nb;i++,j+=4)
    {
        unpack(y[i],(BYTE *)&buff[j]);
	
    }
    free(x); free(y);
    
      
   return;
}




void decrypt(BYTE *buff)
{
    int i,j,k,m;
    WORD *x,*y,*t;

#if defined(_V1) || defined(_V2)    
    unsigned int kk, ll;
#endif


    x = (WORD *)malloc(8*sizeof(WORD));
    y = (WORD *)malloc(8*sizeof(WORD));



    for (i=j=0;i<Nb;i++,j+=4)
    {
        x[i]=pack((BYTE *)&buff[j]);
        x[i]^=rkey[i];
    }
    k=Nb;
    

    for (i=1;i<Nr;i++)
    { 
        for (m=j=0;j<Nb;j++,m+=3)
        { 
            y[j]=rkey[k++]^rtable[(BYTE)(x[j]>>24)]^
                 ROTR8(rtable[(BYTE)(x[ri[m]]>>16)])^
                 ROTR16(rtable[(BYTE)(x[ri[m+1]]>>8)])^
                 ROTR24(rtable[(BYTE)x[ri[m+2]]]);
        }

     

        t=x; x=y; y=t;	
    }

/* Dernier tour */

    for (m=j=0;j<Nb;j++,m+=3)
    {
        y[j]=rkey[k++]^ROTL24((WORD)rbsub[(BYTE)(x[j] >> 24)])^
             ROTL16((WORD)rbsub[(BYTE)(x[ri[m]]>>16)])^
             ROTL8((WORD)rbsub[(BYTE)(x[ri[m+1]]>>8)])^
             ((WORD)rbsub[(BYTE) x[ri[m+2]]]);
    }        


    for (i=j=0;i<Nb;i++,j+=4)
    {
        unpack(y[i],(BYTE *)&buff[j]);
	
    }
    free(x);free(y);

    return;
}