Rijndael è un cifrario a blocchi con una lunghezza del blocco e della chiave variabile. La  lunghezza del blocco  è di 128 bit, mentre la lunghezza della chiave, utilizzata nella cifratura, può essere  di 128, 192 o 256 bit. Inoltre Rijndael è stato progettato per essere utiilizzato con aggiuntive lunghezze del blocco e della chiave, tuttavia queste non vengono prese in considerazione nello standard. Lo standard prevede una lunghezza del blocco di 128 bit, 16 byte, ed una lunghezza della chiave di 128 bit, definendo così Rijndael come nuovo standard AES-128 (128 indica la lunghezza della chiave). Comunque sono prese in considerazione anche le altre due lunghezze della chiave 192 e 256, ottenendo così le versioni AES-192 e AES-256. Tali problematiche verranno trattate e chiarite in seguito, quando verranno presentate le specifiche dell'algoritmo. La presentazione dell'algoritmo parte da alcune notazioni e convenzioni che sono utilizzate nella descrizione dell'algoritmo. Sono riportati, quindi,  alcuni fondamentali preliminari matematici, infatti nelle varie fasi dell'algoritmo vengono utilizzati procedimenti matematici che realizzano il disegno schematico. Si prosegue con la specifica delle operazioni di espansione della chiave, di cifratura e decifratura, per poi concludere con una implementazione in C ed alcune considerazioni sulle prestazioni.
 
 

1. Schema razionale e convenzioni 

Il cifrario Rijndael utilizza semplici operazioni orientate ai byte impiegando una chiave di cifratura. Le varie operazioni sono applicate ai byte del blocco di input in diversi round, il numero dei round è variabile e dipende dalla lunghezza della chiave e del blocco. Ogni round coinvolge quattro operazioni fondamentali con le quali si effettuano sostituzioni, mescolanze e spostamenti dei byte di input creando in questo modo una non linearità dei dati e di conseguenza una maggiore sicurezza. Tutte le operazioni sui dati vengono effettuate su di un array bidimensionale, chiamato State, composto da un certo numero di righe e colonne che memorizza i byte di input.  Lo schema razionale rappresentato in figura descrive ciò che avviene durante l'algoritmo di cifratura.

Infatti, sono rappresentate le quattro operazioni fondamentali che caratterizzano ogni round: -  SubBytes(), questa operazione computa una sostituzione di byte utilizzando una tavola di sostituzione nota come S-Box; - ShiftRows(), questa operazione realizza uno spostamento ciclico delle righe dello State che contengono i byte dei dati di input; - MixColumns(), questa operazione realizza una mescolanza dei byte nelle colonne dello State; - AddRoundKey(), questa operazione realizza l'aggiunta di una Chiave di Round ai byte dei dati. L'operazione di sostituzione dei byte impone, attraverso l'applicazione della S-Box, una certa non linearità nei dati, mentre le operazioni successive di ShiftRows e MixColumns realizzano una mescolanza dei dati che ricorda un pò il famoso CUBO DI RUBIK nel quale si possono mescolare i colori dei cubetti con spostamenti sulle righe e sulle colonne. Per come è stato creato, questo cifrario realizza la fase di decifratura di un blocco cifrato semplicemente invertendo alcune delle operazioni citate. Queste operazioni inverse sono quindi applicate in un numero di round analogo a quello computato nella cifratura. Per entrare in argomentazioni che prevedono un maggiore approfondimento degli algoritmi di cifratura e decifratura, è indispensabile spiegare con alcune esemplificazioni le notazioni e le convenzioni che il cifrario utilizza. D'altro canto sarà ancora più importante trattare alcuni preliminari matematici in quanto tutte le operazioni realizzate sui byte dei dati in realtà sono applicazioni e trasformazioni matematiche che sottointendono concetti algebrici a volte complessi.

1.1  Input ed Output 

1.2  Byte  

  lunghezza della chiave = 128 bit,                                    con   0 <  n < 16

  lunghezza della chiave = 192 bit,                                    con   0 <  n < 24

  lunghezza della chiave = 256 bit,                                    con   0 <  n < 32

  lunghezza del blocco = 128 bit,                                      con   0 <  n < 16

E' utile anche rappresentare i valori dei byte utilizzando la notazione esadecimale, nella quale i gruppi di 8 bit vengono divisi in  due gruppi da quattro ed ognuno dei due rappresenta un carattere tra 0, ..., 9, a, ..., f (come mostrato in figura).
 
 

Bit Pattern Character 0 0 0 0 0 0 0 0 1 1 0 0 1 0 2 0 0 1 1 3

Bit Pattern Character 0 1 0 0 4 0 1 0 1 5 0 1 1 0 6 0 1 1 1 7

Bit Pattern Character 1 0 0 0 8 1 0 0 1 9 1 0 1 0 a 1 0 1 1 b

Bit Pattern Character 1 1 0 0 c 1 1 0 1 d 1 1 1 0 e 1 1 1 1 f

 

Ad esempio l'elemento { 0 1 1 0 0 0 1 1 } può essere rappresentato come { 6 3 }, dove i quattro bit più significativi formano il valore 6, mentre i restanti bit formano il valore 3.
 

1.3 Array di byte 

          a₀ a₁ a₂ . . .a₁₅

L'ordine dei bit rispetto ai byte viene definito dalla sequenza di 128 bit di input
 

input₀ input₁ input₂ . . . input₁₂₆ input₁₂₇  ( sequenza di input 128 bit)
 

come segue:

a₀ = { input_0, input_1,  . . ., input₇};

a₁ = { input_8,input_9, . . ., input₁₅};         (ordine dei bit tra i byte)
                         .
                         .
                         .

a₁₅ = { input_120, input_121,  . . ., input₁₂₇};

La figura mostra come i bit sono numerati in ogni byte, considerando insieme le definizioni dei par. 1.3 e 1.2:
 
 
 

1.4  Lo State 

All'inizio della cifratura o della decifratura, l'array di input in[] è copiato nell'array State in accordo con lo schema:

      s[r, c] = in[r + 4c]                     con r compreso tra con   0 <  r < 4   e   c compreso tra    0<  c < Nb

alla fine della cifratura o della decifratura, l'array State viene copiato nell'array di output out[] come segue:

      out[r + 4c] = s[r, c]                   con r compreso tra con   0 <  r < 4   e   c compreso tra    0<  c < Nb.

Si può notare che i 4 byte nelle colonne dell'array State formano parole di 32 bit, dove il numero di riga r stabilisce un indice per i 4 byte tra ogni parola.
 
 
 

1.5  Lo State come Array di Colonne 

w₀ =a₀ a₁ a₂ a₃      w₁ =a₄ a₅ a₆ a₇      w₂ =a₈ a₉ a₁₀ a₁₁     w₃ =a₁₂ a₁₃ a₁₄ a₁₅
 

dove abbiamo considerato che il blocco di input consiste dei seguenti byte a₀ a₁ a₂ . . .a₁₅ e che quindi viene mappato nell'array State:
 
 

2.  Preliminari matematici 

b₇ x⁷ +  b₆ x⁶ +  b₅ x⁵+ b₄ x⁴+ b₃ x³+ b₂ x²+ b₁ x + b₀
 

Esempio: il byte con valore binario 01010111 corrisponde al polinomio:

                            x⁶+ x⁴+ x²+ x + 1.

Gli elementi di un campo finito possono essere addizionati e moltiplicati, ma tali operazioni sono diverse da quelle usate per i numeri.
 
 
 

2.1 Addizione 

Esempio:      (x⁶+ x⁴ + x²+ x + 1) + (x⁷+ x + 1) = x⁷+ x⁶+ x⁴+ x².

In notazione binaria: "01010111" + "10000011" = "11010100".

Chiaramente, la somma modulo 2 coincide col  lo XOR (denotato  da  ) bit a bit dei due elementi, infatti si ha che 1  1 = 0, 1  0 = 1, e 0 0 = 0.
In notazione esadecimale si ha:  {5 7 }  { 8 3 } = { d 4 }.
La sottrazione mod 2 è identica alla somma, dal momento che l' inverso di ogni elemento è il  proprio aggiuntivo.
 

2.2 Moltiplicazione 

m (x) = x⁸+ x⁴ + x³ + x + 1.

Esempio:    (x ⁶+ x⁴+ x²+ x + 1) (x⁷+ x + 1)  =   x¹³+ x¹¹+ x⁹+ x⁸+ x⁷+x⁷+ x⁵+ x³+ x²+ x +x⁶+ x⁴+ x²+ x + 1
                                                                            =  x ¹³+ x¹¹+ x⁹+ x⁸+ x⁶+ x⁵+ x ⁴+ x³+ 1  modulo x⁸+ x⁴+ x³+ x + 1
                                                                            =  x ⁷+ x⁶+ 1

Chiaramente, il risultato sarà un polinomio binario di grado minore di 8, dal momento che si effettua l'operazione di modulo con il polinomio irriducibile.

La moltiplicazione  è associativa ed è dotata di un elemento neutro { 01 }. Inoltre, per qualunque polinomio binario b(x) di grado inferiore a 8, può essere usato l'algoritmo esteso di Euclide per calcolare l'inverso moltiplicativo di b(x), denotato con  b ^-1 (x). L'algoritmo di Euclide esteso calcola infatti i due polinomi a (x) e c (x) tali che:

b (x) a (x) + m (x) c (x) = 1.

Questo implica che  a (x) · b (x)   mod m (x) = 1 o  b ^-1(x) = a (x)  mod m (x)

Inoltre, possiamo vedere che a (x) · (b (x) + c (x)) = a (x) · b (x) + a (x) · c (x).

Ne consegue che l'insieme dei 256 possibili valori ottenuti con un byte, uniti allo XOR, utilizzato come addizione, e alla moltiplicazione, formano la struttura del campo finito  GF(2⁸).
 

2.3 Polinomi con coefficicienti in GF(2⁸) 

                  a(x) = a₃·x³ + a₂·x²+ a₁·x + a₀·

che viene denotato in termini di word nella forma [a₀, a₁, a₂, a₃].

Bisogna notare che i polinomi definiti in questo modo si comportano in maniera piuttosto differente dai polinomi usati per definire gli elementi di un campo finito, anche se utilizzano entrambi lo stesso valore indeterminato  x. Infatti, i coefficienti dei polinomi che stiamo adesso considerando sono essi stessi degli elementi di un campo finito, sono in questo caso byte, mentre nella definizione precedente erano bit. Così, un vettore di 4 byte corrisponde ad un polinomio di grado minore di 4 con coefficienti nel campo finito GF(2⁸). Questi polinomi possono essere addizionati sommando semplicemente i coefficienti aventi potenze di x  corrispondenti. La somma equivale ad una operazione di XOR tra byte corrispondenti in ognuna delle word.
 

                  a(x) + b(x) = (a₃  b₃ )·x³ + (a₂  b₂ )·x² + (a₁ b₁ )·x + (a₀  b₀ )
 

La moltiplicazione è più complicata. Supponiamo di avere due polinomi  con coefficienti nel campo finito GF(2⁸):

a(x) = a₃ x³+a₂ x²+a₁ x + a₀    e

b(x) = b₃ x³+ b₂ x²+ b₁ x + b₀.

Il loro prodotto c (x) = a (x) b (x) è dato da:

c (x) = c₆ x⁶+c₅ x⁵ + c₄x⁴+ c₃ x³+ c₂ x²+c₁ x + c₀    con

c₀ = a₀· b₀                                                                        c₄ = a₃· b₁   a₂· b₂  a₁· b₃
c₁ = a₁· b₀   a₀· b₁                                                        c₅ = a₃· b₂   a₂· b₃
c₂ = a₂· b₀   a₁· b₁  a₀· b₂                                         c₆ = a₃· b₃
c₃ = a₃· b₀   a₂· b₁  a₁· b₂   a₀· b₃

Chiaramente, c (x) può essere rappresentato da un vettore di 4 byte. Riducendo c (x) modulo un polinomio di grado 4, il risultato può essere ridotto ad un polinomio di grado inferiore a 4, in Rijndael viene utillizzato il  polinomio
m(x ) = x⁴+ 1.

Dal momento che xⁱ mod ( x⁴+ 1) = x^{(i mod 4)}, il prodotto modulare di a(x) e b (x), denotato con d (x) = a (x)  b (x), è dato da:

d (x) = d₃ x³+ d2x²+ d₁ x + d₀         con

d₀= a₀· b₀  a₃· b₁ a₂· b₂  a₁· b₃
d₁= a₁· b₀  a₀· b₁a₃· b₂ a₂· b₃
d₂= a₂· b₀  a₁· b₁ a₀· b₂  a₃· b₃
d₃= a₃· b₀ a₂· b₁ a₁· b₂  a₀· b₃

 L'operazione che consiste nella moltiplicazione di un polinomio fisso a (x), può essere scritta come moltiplicazione matriciale, dove la matrice è una matrice circolare:
 
 

Dal momento che   x⁴+ 1  non è un polinomio irriducibile  sul campo finito  GF(2⁸), la moltiplicazione con un fissato polinomio di 4 termini non è necessariamente invertibile. Pertanto Rijndael specifica un fissato polinomio con 4 termini che ha un inverso moltiplicativo:
 

   a(x) = {03}·x³ + {01}·x²+ {01}·x + {02}

   a^-1(x) = {0b}·x³ + {0d}·x²+ {09}·x + {0e}
 
  che sarà utilizzato nella cifratura e nella decifratura.
 

3.  Specifiche dell'algoritmo 

Sia per la cifratura che per la decifratura, Rijndael utilizza una funzione di round che si compone di 4 differenti trasformazioni orientate ai byte:

1) la prima è una trasformazione di sostituzione di byte, SubBytes(), che usa una tavola di sostituzione (S-box);

2) la seconda è una trasformazione di shift di righe con dei differenti offsets, ShiftRows();

3) la terza è una trasformazione di mescolanza di dati tra ogni colonna dell'array State, MixColumns();

4) la quarta è una trasformazione che prevede l'aggiunta della Chiave di Round all' array State, AddRoundKey().
 
 

4.  La Cifratura

All' inizio della cifratura, l'input, memorizzato nell'array in[], viene copiato nell'array State usando le convenzioni descritte precedentemente (par. 1.4). Dopo l' iniziale aggiunta di una Chiave di Round(Round Key), l'array State viene trasformato con un ciclo di trasformazione (Round Trasformation) di10, 12 o 14 round. Il numero dei round dipende dalla lunghezza della chiave ed inoltre l'ultimo round differisce dai primi Nr-1. Terminato il ciclo di trasformazione, lo State finale viene copiato nell'array di output, out[]. La cifratura utilizza anche la chiave schedulata che consiste in un array unidimensionale di word di 4 byte, denotato con w[], derivato dalla funzione di espansione della chiave.

Ora viene descritta la cifratura in pseudo-codice; le trasformazioni utilizzate SubBytes (), ShiftRows (), MixColumns () e AddRoundKey () servono a processare l'array State in moda da creare una non linearità nei dati di input.
 
 

Si può notare che gli Nr round sono identici ad eccezione del round finale, il quale non include la trasformazione MixColumns ().
L' algoritmo presentato in pseudo-codice può essere schematizzato in un disegno che ben chiarisce l'ordine delle trasformazioni applicate al blocco di input durante la cifratura.
 
 

4.1 SubBytes ()

1. prima, prendendo l'inverso moltiplicativo in GF(2⁸)  (l'elemento { 0 0 } rimane { 0 0 });

2. poi, applicando una trasformazione affine su GF(2⁸) definita da:
 
 

  b'_i  =  b_i  b_{(i+4) mod 8} b_{(i+5) mod 8} b_{(i+6) mod 8} b_{(i+7) mod 8}  c_i
 

per  i che varia tra  0 < i < 8, dove b_i è l' i-esimo bit del byte, e c_i è l' i-esimo bit di un byte c con il valore { 6 3 } in esadecimale oppure{ 0 1 1 0 0 0 0 1 1 } in binario. L'apice sulla variabile b' indica che la variabile sta per essere aggiornata con il valore di destra. In forma matriciale,
l' elemento della S-Box prodotto dalla trasformazione affine può essere espresso come:
 
 

La figura seguente illustra l' effetto della trasformazione SubBytes () sull'array State.
 
 

La S-Box usata nella trasformazione SubBytes () viene ora presentata in forma esadecimale:
 
 

Ad esempio, se s_1,1 = { 5 3 }, allora il valore della sostituzione dovrebbe essere determinato dall'intersezione della riga di indice ' 5 ' con la colonna di indice ' 3 '. Il risultato di tale sostituzione sarebbe dunque il valore s'_1,1 = { e d }.
 

Il criterio della struttura per la S-box è inspirato alla crittoanalisi differenziale e lineare ed ad attacchi che usano manipolazioni algebriche, come attacchi di interpolazione, oltre ad:

1. Invertibilità;

2. Minimizzazione della più grande correlazione non-banale tra combinazioni lineari di bit d'input e combinazione lineare di bit dell'output;

3. Minimizzazione del più grande valore non-banale nella tavola di XOR;

4. La complessità della sua espressione algebrica in GF(2⁸);

5. La semplicità di descrizione.

4.2  ShiftRows ()

 s'_r,c  =  s_{r,(c+shift(r,Nb)) mod Nb}         per 0 < r < 4       e      0 < c < Nb
 

dove il valore dello spostamento shift(r,Nb) dipende dal numero di riga, r, nel seguente modo ( ricordiamo che Nb nello standard è uguale a 4):

      shift(1,4) = 1 ;   shift(2,4) = 2 ;   shift(3,4) = 3.

La trasformazione può essere illustrata con la seguente figura:
 
 

4.3  MixColumns ()

per 0 < c < Nb

Come risultato di questa moltiplicazione, i 4 byte in una colonna sono sostituiti dai  byte seguenti:
 

s'_0,c = ({02} · s_0,c)  ({03} · s_1,c)  s_2,c  s_3,c

s'_1,c = s_0,c  ({02} · s_1,c)  ({03} · s_2,c)  s_3,c

s'_2,c = s_0,c   s_1,c  ({02} · s_2,c) ({03} · s_3,c )

s'_3,c = ({0b} · s_0,c )  s_1,c  s_2,c  ({0e} · s_3,c )
 
 

La trasformazione può essere illustrata con la seguente figura:
 
 

La trasformazione MixColumns () è stata scelta secondo i seguenti criteri:

1. Invertibilità;

2. linearità in GF(2⁸);

3. la velocità su microprocessori a 8-bit;

4. la simmetria;

5. la semplicità di descrizione.
I criteri 2, 4 e 5  hanno condotto alla scelta del modulo della moltiplicazione polinomiale x⁴+1, i criteri 1, 3 impongono le condizioni sui coefficienti. Il criterio 3 impone che i coefficienti abbiano valori piccoli, in ordine di preferenza {00}, {01}, {02}, {03}.
 
 

4.4 AddRoundKey ()

[ s'_0,c , s'_1,c , s'_2,c , s'_3,c ] = [ s_0,c , s_1,c , s_2,c , s_3,c ] [  w_round*Nb+c ]         per 0 < c < Nb
 

dove le [ w_i ]  sono le word della chiave schedulata, come sarà descritto in seguito, e dove round è un valore nel range 0 < round < Nr. Nella cifratura, la prima addizione della Round Key avviene quando round = 0, prima dell'applicazione della funzione di round. L'applicazione della trasformazione AddRoundKey () negli Nr round della cifratura si verifica invece quando  1 < round <Nr.
 
 

L'azione della trasformazione è illustrata nella seguente figura, dove l = round * Nb.
 
 

5. Espansione della chiave

Si può notare dalla figura che le prime Nk word della chiave espansa sono ottenute direttamente dalla chiave di cifratura, mentre ogni word successiva, w[ i ], è uguale allo XOR della word precedente, w[ i-1 ], con la word di Nk posizioni più indietro. Per le word con posizioni che sono multiple di Nk, viene applicata a w[ i-1 ] una trasformazione prima dello XOR, seguita da uno XOR con una costante di round, Rcon[ i ]. Questa trasformazione consiste di uno shift ciclico dei byte in una word (RotWord () ), seguito da una funzione SubWord () che applica una S-Box a tutti e quattro i byte della word. E' impotante notare che l'algoritmo di espansione della chiave per una chiave di 256 bit ( Nk = 8) si compota diversamente rispetto ad una chiave di 128 o 192 bit. Se Nk = 8 ed i-4 è multiplo di Nk, la trasformazione SubWord () è applicata a w[ i-1 ] prima dello XOR.

La funzione dell'algoritmo di espansione della chiave è quella di provvedere alla resistenza contro i seguenti tipi di attacco:

- Attacchi  nei quali parte della cifratura della  chiave è conosciuta al  crittoanalista;

- Attacchi nei quali la cifratura della chiave è conosciuta e  la cifratura è usata come  funzione di compressione di una funzione;

- Attacchi Related-Key.

Una condizione necessaria per resistere agli  attacchi Related-Key è quella di non avere mai due cifrature della chiavi diverse che abbiano  un insieme di Round key  in comune.

L'espansione della chiave ha un ruolo importante  anche nell'eliminazione di simmetrie:

- Simmetria  nella Round Trasformation: essa tratta tutti i byte di uno State nello stesso modo. Questa simmetria può essere rimossa avendo round
costanti nella schedulazione della chiave;

- Simmetria tra i round: la Round Trasformation è la stessa per tutti i round.
Questa uguaglianza può essere rimossa avendo round dipendenti e costanti nella schedulazione della chiave.

L'espansione della chiave è stata scelta secondo i seguenti criteri:

- Utilizzo di trasformazioni invertibili,infatti conoscere  ogni  Nk parole consecutive della chiave espansa  permetterà di rigenerare la tavola completa;

- Velocità su una serie larga di microprocessori;

- l'uso di  costanti round per eliminare simmetrie;

- la diffusione di  cifrature della chiave differenti  nelle Round Key;

- la conoscenza di  una parte della cifratura della chiave o pezzi di Round Key non permetterà di calcolare
molte altre parti di Round Key.

- Sufficienti  non-linearità per proibire la piena determinazione di Round Key differenti da  cifrature di chiavi differenti;

- La semplicità di descrizione.
 
 

6. La decifratura

6.1 InvShiftRows ()

       shift(1,4) = 1 ;   shift(2,4) = 2 ;   shift(3,4) = 3.

Precisamente, la trasformazione InvShiftRows () procede come segue:

  s_{r,(c+shift(r,Nb)) mod Nb}  =  s'_r,c       per 0 < r < 4       e      0 < c < Nb

La trasformazione può anche essere illustrata con una figura:
 
 

6.2  InvSubBytes ()

La trasformazione InvSubBytes () realizza una sostituzione dei byte applicando l'inverso della  S-box ad ogni byte dell'array State. Questa S-Box inversa è costruita dalla composizione di due trasformazioni:

1. prima, applicando l'inverso della trasformazione affine descritta precedentemente(par. 4.1),

2. poi, prendendo l'inverso moltiplicativo nel campo finito GF(2⁸).

La trasformazione di sostituzione procede in modo del tutto analogo a quello descritto nella fase di cifratura:
 
 

L' inverso della S-Box, usata nella trasformazione, è presentata nella seguente figura in notazione esadecimale:
 
 

Ad esempio, se s_1,1 = { e 3 }, allora il valore della sostituzione viene determinato dall'intersezione della riga di indice ' 5 ' con la colonna di indice ' 3 '. Il risultato di tale sostituzione è dunque il valore s'_1,1 = { 4 d }.
 
 

6.3  InvMixColumns ()

                                                         a^-1(x) = {0b}·x³ + {0d}·x²+ {09}·x + {0e}.

Ciò può essere scritto come prodotto matriciale:

s'(x) =  a^-1(x)  s(x), ossia:
 
 

Come risultato di questa moltiplicazione, i 4 byte di ogni colonna sono rimpiazzati dai seguenti byte:
 

s'_0,c= ({0e} · s_0,c) ({0b} · s_1,c) ({0d} · s_2,c) ({09} · s_3,c)

s'_1,c= ({09} · s_0,c) ({0e} · s_1,c)({0b} · s_2,c) ({0d} · s_3,c)

s'_2,c= ({0d} · s_0,c) ({09} · s_1,c) ({0e} · s_2,c)({0b} · s_3,c)

s'_3,c= ({0b} · s_0,c) ({0d} · s_1,c)({09} · s_2,c) ({0e} · s_3,c)

Possiamo quindi illustrare la trasformazione con la seguente figura:
 
 

6.4  InvAddRoundKey ()

7. Implementazione

#ifndef __RIJNDAEL_ALG_H
#define __RIJNDAEL_ALG_H

#define MAXBC (256/32)
#define MAXKC (256/32)
#define MAXROUNDS 14

typedef unsigned char word8;
typedef unsigned short word16;
typedef unsigned long word32;
 

int rijndaelKeySched (word8 k[4][MAXKC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC]);
int rijndaelEncrypt (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC]);
int rijndaelEncryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds);
int rijndaelDecrypt (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC]);
int rijndaelDecryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds);

#endif

/* __RIJNDAEL_ALG_H */
/* rijndael-alg-ref.c v2.0 August '99
* Reference ANSI C code
* authors: Paulo Barreto
* Vincent Rijmen
*/
/*

#include <stdio.h>
#include <stdlib.h>

#include "rijndael-alg-ref.h"

#define SC ((BC - 4) >> 1)

#include "boxes-ref.dat"

static word8 shifts[3][4][2] = {
                                                        0, 0, 1, 3,
                                                        2, 2, 3, 1,
                                                        0, 0, 1, 5,
                                                        2, 4, 3, 3,
                                                        0, 0, 1, 7,
                                                        3, 5, 4, 4
                                                    };
 

word8 mul(word8 a, word8 b) {

 /* vengono moltiplicati due elementi di GF(28)
  * necessari per MixColumn e InvMixColumn
  */

    if (a && b)
        return Alogtable[(Logtable[a] + Logtable[b])%255];
    else
        return 0;
}

void KeyAddition(word8 a[4][MAXBC], word8 rk[4][MAXBC], word8 BC) {
    int i, j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < BC; j++)
            a[i][j] ^= rk[i][j];
}
 

void ShiftRow(word8 a[4][MAXBC], word8 d, word8 BC) {

/* La riga  0 rimane inalterata
* Le altre tre righe sono shiftate di una lunghezza variabile
*/

    word8 tmp[MAXBC];
    int i, j;
    for(i = 1; i < 4; i++) {
        for(j = 0; j < BC; j++)
            tmp[j] = a[i][(j + shifts[SC][i][d]) % BC];
        for(j = 0; j < BC; j++) a[i][j] = tmp[j];
    }
}
 

void Substitution(word8 a[4][MAXBC], word8 box[256], word8 BC) {

/* Sostituisce ogni byte di input con byte ottenuti
* con una trasformazione non lineare S-box
*/

    int i, j;
    for(i = 0; i < 4; i++)
        for(j = 0; j < BC; j++)
            a[i][j] = box[a[i][j]] ;
}
 

void MixColumn(word8 a[4][MAXBC], word8 BC) {

/* Mescola quattro byte di ogni colonna in maniera lineare*/

    word8 b[4][MAXBC];
    int i, j;
    for(j = 0; j < BC; j++)
        for(i = 0; i < 4; i++)
            b[i][j] = mul(2,a[i][j]) ^ mul(3,a[(i + 1) % 4][j]) ^ a[(i + 2) % 4][j] ^ a[(i + 3) % 4][j];
    for(i = 0; i < 4; i++)
        for(j = 0; j < BC; j++)
            a[i][j] = b[i][j];
}
 

void InvMixColumn(word8 a[4][MAXBC], word8 BC) {

/* Mescola i quattro byte di ogni colonna in modo lineare
* Questa è l'operazione inversa di Mixcolumn
*/

    word8 b[4][MAXBC];
    int i, j;
    for(j = 0; j < BC; j++)
        for(i = 0; i < 4; i++)
           b[i][j] = mul(0xe,a[i][j]) ^ mul(0xb,a[(i + 1) % 4][j])  ^ mul(0xd,a[(i + 2) % 4][j]) ^ mul(0x9,a[(i + 3) % 4][j]);
    for(i = 0; i < 4; i++)
        for(j = 0; j < BC; j++)
            a[i][j] = b[i][j];
}
 

int rijndaelKeySched (word8 k[4][MAXKC], int keyBits, int blockBits, word8 W[MAXROUNDS+1][4][MAXBC]) {

/* Vengono calcolate i round delle chiavi
*  Il numero di calcoli dipende dai bit della chiave
*/

    int KC, BC, ROUNDS;
    int i, j, t, rconpointer = 0;
    word8 tk[4][MAXKC];
    switch (keyBits) {
                                    case 128: KC = 4; break;
                                    case 192: KC = 6; break;
                                    case 256: KC = 8; break;
                                    default : return (-1);
                                    }
    switch (blockBits) {
                                        case 128: BC = 4; break;
                                        case 192: BC = 6; break;
                                        case 256: BC = 8; break;
                                        default : return (-2);
                                     }
    switch (keyBits >= blockBits ? keyBits : blockBits) {
                                                                                                case 128: ROUNDS = 10; break;
                                                                                                case 192: ROUNDS = 12; break;
                                                                                                case 256: ROUNDS = 14; break;
                                                                                                default : return (-3); /* this cannot happen */
                                                                                              }
    for(j = 0; j < KC; j++)
        for(i = 0; i < 4; i++)
            tk[i][j] = k[i][j];
    t = 0;
    for(j = 0; (j < KC) && (t < (ROUNDS+1)*BC); j++, t++)
        for(i = 0; i < 4; i++) W[t / BC][i][t % BC] = tk[i][j];
    while (t < (ROUNDS+1)*BC) {
        for(i = 0; i < 4; i++)
            tk[i][0] ^= S[tk[(i+1)%4][KC-1]];
        tk[0][0] ^= rcon[rconpointer++];
    if (KC != 8)
        for(j = 1; j < KC; j++)
            for(i = 0; i < 4; i++)
                tk[i][j] ^= tk[i][j-1];
    else {
                for(j = 1; j < KC/2; j++)
                    for(i = 0; i < 4; i++)
                        tk[i][j] ^= tk[i][j-1];
                for(i = 0; i < 4; i++)
                    tk[i][KC/2] ^= S[tk[i][KC/2 - 1]];
               for(j = KC/2 + 1; j < KC; j++)
                    for(i = 0; i < 4; i++)
                        tk[i][j] ^= tk[i][j-1];
            }
    for(j = 0; (j < KC) && (t < (ROUNDS+1)*BC); j++, t++)
        for(i = 0; i < 4; i++)
            W[t / BC][i][t % BC] = tk[i][j];
    }

    return 0;
}
 

int rijndaelEncrypt (word8 a[4][MAXBC], int keyBits, int blockBits, word8 rk[MAXROUNDS+1][4][MAXBC])
{
    int r, BC, ROUNDS;
    switch (blockBits) {
                                        case 128: BC = 4; break;
                                        case 192: BC = 6; break;
                                        case 256: BC = 8; break;
                                        default : return (-2);
                                     }
    switch (keyBits >= blockBits ? keyBits : blockBits) {
                                                                                                case 128: ROUNDS = 10; break;
                                                                                                case 192: ROUNDS = 12; break;
                                                                                                case 256: ROUNDS = 14; break;
                                                                                                default : return (-3);
                                                                                             }
    KeyAddition(a,rk[0],BC);
    for(r = 1; r < ROUNDS; r++) {
       Substitution(a,S,BC);
        ShiftRow(a,0,BC);
        MixColumn(a,BC);
        KeyAddition(a,rk[r],BC);
     }
    Substitution(a,S,BC);
    ShiftRow(a,0,BC);
    KeyAddition(a,rk[ROUNDS],BC);
    return 0;
}
 

int rijndaelEncryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds)
{
    int r, BC, ROUNDS;
    switch (blockBits) {
                                       case 128: BC = 4; break;
                                        case 192: BC = 6; break;
                                        case 256: BC = 8; break;
                                        default : return (-2);
                                     }
    switch (keyBits >= blockBits ? keyBits : blockBits) {
                                                                                                case 128: ROUNDS = 10; break;
                                                                                               case 192: ROUNDS = 12; break;
                                                                                                case 256: ROUNDS = 14; break;
                                                                                                default : return (-3); /* this cannot happen */
                                                                                             }
    if (rounds > ROUNDS) rounds = ROUNDS;
    KeyAddition(a,rk[0],BC);
    for(r = 1; (r <= rounds) && (r < ROUNDS); r++) {
        Substitution(a,S,BC);
        ShiftRow(a,0,BC);
        MixColumn(a,BC);
        KeyAddition(a,rk[r],BC);
    }
    if (rounds == ROUNDS) {
        Substitution(a,S,BC);
        ShiftRow(a,0,BC);
        KeyAddition(a,rk[ROUNDS],BC);
    }
    return 0;
}
 

int rijndaelDecrypt (word8 a[4][MAXBC], int keyBits, int blockBits, word8 rk[MAXROUNDS+1][4][MAXBC])
{
    int r, BC, ROUNDS;
    switch (blockBits) {
                                        case 128: BC = 4; break;
                                        case 192: BC = 6; break;
                                        case 256: BC = 8; break;
                                        default : return (-2);
                                      }
    switch (keyBits >= blockBits ? keyBits : blockBits) {
                                                                                               case 128: ROUNDS = 10; break;
                                                                                               case 192: ROUNDS = 12; break;
                                                                                                case 256: ROUNDS = 14; break;
                                                                                                 default : return (-3);
                                                                                            }
    KeyAddition(a,rk[ROUNDS],BC);
    Substitution(a,Si,BC);
    ShiftRow(a,1,BC);
    for(r = ROUNDS-1; r > 0; r--) {
        KeyAddition(a,rk[r],BC);
        InvMixColumn(a,BC);
        Substitution(a,Si,BC);
        ShiftRow(a,1,BC);
    }
    KeyAddition(a,rk[0],BC);
    return 0;
}
 

int rijndaelDecryptRound (word8 a[4][MAXBC], int keyBits, int blockBits,
word8 rk[MAXROUNDS+1][4][MAXBC], int rounds)
{
    int r, BC, ROUNDS;
    switch (blockBits) {
                                        case 128: BC = 4; break;
                                        case 192: BC = 6; break;
                                        case 256: BC = 8; break;
                                        default : return (-2);
                                     }
    switch (keyBits >= blockBits ? keyBits : blockBits) {
                                                                                                case 128: ROUNDS = 10; break;
                                                                                                case 192: ROUNDS = 12; break;
                                                                                                case 256: ROUNDS = 14; break;
                                                                                                gladmandefault : return (-3);
                                                                                            }
    if (rounds > ROUNDS)
        rounds = ROUNDS;
    KeyAddition(a,rk[ROUNDS],BC);
    Substitution(a,Si,BC);
    ShiftRow(a,1,BC);
    for(r = ROUNDS-1; r > rounds; r--) {
        KeyAddition(a,rk[r],BC);
       InvMixColumn(a,BC);
        Substitution(a,Si,BC);
        ShiftRow(a,1,BC);
    }
    if (rounds == 0) {
        KeyAddition(a,rk[0],BC);
    }
    return 0;
}
 
 
 

8. Prestazioni

I dati relativi alle performance dell' algoritmo sono stati computati da Brian Gladman: