Chapitre 5

Le décryptage et ses fonction.

Les fonctions qui interviennent dans l'encryptage sont toutes inversibles.
Ce sont rappelons les :

SubBytes() ;
ShiftRows() ;
MixColumns() ;
AddRoundKey() ;

Les fonctions inverses notées InvSubBytes(), InvShiftRows() , InvMixColumns()
ont la même structure que leurs homologues. Aussi nous n'en ferons pas l'analyse.

AddRoundKey() est auto-inverse .

La fonction InvSubBytes()

InvSubBytes() est l'inverse de SubBytes() .
InvSubBytes() est construite sur InvSBox[16][16] qui définit
l'application inverse de celle associée à la SBox[16][16]
La fonction InitInvSBox() construit directement InvSBox[16][16] à partir de la SBox[16][16] .


void InitInvSBox(){	// construction de InvSBox[][] à partir de SBox[][]
    byte i,j            ;
    byte aux , L, H     ;
    
    for(i=0; i< 16; i++)
        for(j=0; j< 16; j++){
            aux = SBox[i][j]        ;
            L = aux & 0x0F          ;
            H = (aux & 0xF0) >> 4   ;
            InvSBox[H][L] = (i<<4) | j  ;
            
        }
}

La fonction Invsbx() inverse de sbx() permet d'appliquer la transformation
définie par InvSBox à un byte de Status[][].


byte Invsbx(byte b){                //  La fonction b -> InvSBox(b)
    unsigned L, C       ;
    
    L = (b & 0xF0) >> 4     ;
    C = b & 0x0F            ;
    return InvSBox[L][C]    ;
}

Finalement InvSubBytes() applique Invsbx() à tous les éléments de Status[][].


void InvSubBytes(){
    unsigned i,j    ;
    
    for(i=0; i<4; i++)
        for(j=0; j<4; j++)State[i][j]= Invsbx(State[i][j]) ;
}

La fonction InvShiftRows().

InvShiftRows(), inverse de ShiftRows() décale à droite chaque ligne de Status[][] de son rang.
La ligne 0 n'est pas décalée.
La ligne 1 est décalée de 1 à droite etc ....

void InvShiftRows(){ 	//  chaque ligne de Status[] est décalée à droite de son rang
    unsigned i,j,k  ;
    byte    aux     ;
    
    for(i=0; i<4; i++){
        //  tourner de k
        for(k=0; k < i; k ++){  //  k = nbre de tours par ligne
            aux = State[i][3]  ;
            for(j=3; j > 0 ; j--){
                State[i][j] = State[i][j-1]  ;
            }
            State[i][0] = aux   ;
        }
    }
}

La fonction InvMixColumns()

Inverse de MixColumns() cette fonctions effectue le produit matriciel de Status[4][4]
par la matrice Invmixc[4][4] inverse de la matrice mixc[4][4] associée à MixColumns().

byte Invmixc[4][4] = {
  0x0E, 0x0B, 0x0D, 0x09,
  0x09, 0x0E, 0x0B, 0x0D,
  0x0D, 0x09, 0x0E, 0x0B,
  0x0B, 0x0D, 0x09, 0x0E
};


void InvMixColumns(){	//  produit matriciel de Invmixc[][] par State[][]
    byte aux[4][4]      ;
    unsigned i, j, k    ;
    
    for(i=0;i<4; i++){
        for(j=0; j<4; j++){
            aux[i][j] = 0 ;
            for(k=0;k<4;k++)aux[i][j]= aux[i][j] ^ MLT(Invmixc[i][k],State[k][j]);
        }
    }
    for(i=0; i<4; i++){
        for(j=0; j<4; j++)State[i][j] = aux[i][j] ; 
    }
}

Le décryptage


void Decrypt(byte * txt){	// décrypte un groupe de 16 bytes.
    unsigned rnd				 ;
    
    InitState(txt)          ;
    //
    AddRoundKey(14)         ; 
    
    for(rnd = 13; rnd > 0 ; rnd--){
        InvShiftRows()      ;
        InvSubBytes()       ;
        AddRoundKey(rnd)    ;
        InvMixColumns()     ;
    }
    
    InvShiftRows()          ;
    InvSubBytes()           ;
    AddRoundKey(0)          ;  
    
}