Main

Metodo Di Crittografia AES

Main.MetodoDiCrittografiaAES History

Hide minor edits - Show changes to output

Deleted lines 232-240:
!!!!Esempio

Prendiamo una stringa del tipo:  32 43 f6 a8 88 5a 30 8d 31 31 98 a2 e0 37 07 34

e una chiave:  2b 7e 15 16 28 ae d2 a6 ab f7 15 88 09 cf 4f 3c

||border= 1
||! Ciclo ||! Blocco iniziale ||! Dopo SubBytes() ||! Dopo ShiftRows() ||! Dopo MixColumns() ||! Chiave ||
|| {$ [ 32, 88, 31, e0 ] $} ||
Changed line 241 from:
|| [ 32, 88, 31, e0 ] $}
to:
|| {$ [ 32, 88, 31, e0 ] $} ||
Changed lines 225-226 from:
vanno eseguite una dietro l'altra 9 volte.
to:
vanno eseguite una dietro l'altra 9 volte (nel caso 128 bit).
Added lines 233-241:
!!!!Esempio

Prendiamo una stringa del tipo:  32 43 f6 a8 88 5a 30 8d 31 31 98 a2 e0 37 07 34

e una chiave:  2b 7e 15 16 28 ae d2 a6 ab f7 15 88 09 cf 4f 3c

||border= 1
||! Ciclo ||! Blocco iniziale ||! Dopo SubBytes() ||! Dopo ShiftRows() ||! Dopo MixColumns() ||! Chiave ||
|| [ 32, 88, 31, e0 ] $}
Changed lines 217-219 from:
!!!Cifrare

A questo punto si ripetono 9 permutazioni uguali ed poi una differente. In questo modo ritorna 10 il numero di permutazioni necessarie, ma è reso tutto molto complicato. La sequenza di operazione da ripetere 9 volte e':
to:
!!!Cifratura

A questo punto per ogni blocco si ripetono N'_r_'  (9 nel caso 128 bit) permutazioni uguali ed poi una differente. In questo modo ritorna 10 il numero di permutazioni necessarie, ma è reso tutto molto complicato. La sequenza di operazione da ripetere 9 volte e':
Changed line 227 from:
Mentre per l'ultimo blocco si esegue solo:
to:
Mentre per l'ultimo ciclo, il decimo nel caso di 128 bit, si esegue solo:
Added lines 213-214:

Il vettore di destra e' lo stesso per tutti i blocchi.
Changed line 212 from:
{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] * [{03}, {01},{01},{02} ]  $}
to:
{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] * [ ({03}), ({01}), ({01}), ({02}) ]  $}
Changed lines 197-198 from:
!!! Si comincia
to:
!!! Dividere in blocchi
Changed lines 204-205 from:
!!!Funzione AddRoundKey
to:
!!!Funzione AddRoundKey()
Added lines 207-215:

!!!Funzione MixColumns()

La funzione mixclomuns() fa il seguente prodotto matriciale:

{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] * [{03}, {01},{01},{02} ]  $}


!!!Cifrare
Added lines 215-220:

Mentre per l'ultimo blocco si esegue solo:

# SubBytes(blocco)
# ShiftRows(blocco)
# AddRoundKey(blocco'_i_', Chiave'_i_')
Changed line 193 from:
*K'_6_' =  si prende la chiave precedente 522c6b7b, poi si applica rotWord ottendendo 2c6b7b52, poi si applica subword ottenendo 717f2100, poi si prende l'elemento {$ Rcon_(i/N_k) $} che e' 01000000, facendo XOR con l'elemento Rcon si ottiene 707f2100. L'elemento {$ Chiave_(I-N_k) $} e' 8e73b0f7. Facendo XOR con quest'ultimo abbiamo il risultato fe0c91f7 = '''fe0c91f7'''
to:
*K'_6_' =  si prende la chiave precedente 522c6b7b, poi si applica rotWord ottendendo 2c6b7b52, poi si applica subword ottenendo 717f2100, poi si prende l'elemento {$ Rcon_(i/N_k) $} che e' 01000000, facendo XOR con l'elemento Rcon si ottiene 707f2100. L'elemento {$ Chiave_(i-N_k) $} e' 8e73b0f7. Facendo XOR con quest'ultimo abbiamo il risultato fe0c91f7 = '''fe0c91f7'''
Changed lines 185-189 from:

Per ogni matrice da 128 bit vengono fatte le seguenti operazioni:



to:
Vediamo un altro esempio nel dettaglio. Chiave 8e 73 b0 f7 da 0e 64 52 c8 10 f3 2b 80 90 79 e5 62 f8 ea d2 52 2c 6b 7b.

*K'_0_' = 8e73b0f7
*K'_1_' =  da0e6452
*K'_2_' =  c810f32b
*K'_3_' =  809079e5
*K'_4_' =  62f8ead2
*K'_5_' =  522c6b7b
*K'_6_' =  si prende la chiave precedente 522c6b7b, poi si applica rotWord ottendendo 2c6b7b52, poi si applica subword ottenendo 717f2100, poi si prende l'elemento {$ Rcon_(i/N_k) $} che e' 01000000, facendo XOR con l'elemento Rcon si ottiene 707f2100. L'elemento {$ Chiave_(I-N_k) $} e' 8e73b0f7. Facendo XOR con quest'ultimo abbiamo il risultato fe0c91f7 = '''fe0c91f7'''



Changed lines 206-207 from:
Preso un blocco, ad ogni byte del blocco è sommato (XOR), in ordine, un byte della chiave espansa. Se ogni blocco è di 16 byte, si sfruttano 16byte della chiave per blocco. Nessun byte della chiave espansa è usato più di una volta. Questa operazione è chiamata '''AddRoundKey'''.
to:
Preso un blocco, ad ogni byte del blocco è sommato (XOR) un byte della chiave espansa, in ordine. Se ogni blocco è di 16 byte, si sfruttano 16byte della chiave per blocco. Nessun byte della chiave espansa è usato più di una volta. Questa operazione è chiamata '''AddRoundKey'''.
Changed lines 209-212 from:
# SubBytes(state)
# ShiftRows(state)
# MixColumns(state)
# AddRoundKey(state, w[round*Nb, (round+1)*Nb-1])
to:
# SubBytes(blocco)
# ShiftRows(blocco)
# MixColumns(blocco)
# AddRoundKey(blocco'_i_', Chiave'_i_')
Added line 197:
!!!Funzione AddRoundKey
Added lines 85-91:
Per evitare confusioni mettiamo le variabili che ritroveremo spesso in tabella a seconda della lunghezza della chiave:

||border=1
|| || Nk || Nb || Nr ||
|| 128 bit || 4 || 4 || 10 ||
|| 192 bit || 6 || 4 || 12 ||
|| 256 bit || 8 || 4 || 14 ||
Changed lines 196-202 from:
Per evitare confusioni mettiamo le variabili che ritroveremo spesso in tabella a seconda della lunghezza della chiave:

||border=1
|| || Nk || Nb || Nr ||
|| 128 bit || 4 || 4 || 10 ||
|| 192 bit || 6 || 4 || 12 ||
|| 256 bit || 8 || 4 || 14 ||
to:
May 11, 2015, at 05:58 PM by 79.58.39.104 -
Added lines 199-205:
A questo punto si ripetono 9 permutazioni uguali ed poi una differente. In questo modo ritorna 10 il numero di permutazioni necessarie, ma è reso tutto molto complicato. La sequenza di operazione da ripetere 9 volte e':
# SubBytes(state)
# ShiftRows(state)
# MixColumns(state)
# AddRoundKey(state, w[round*Nb, (round+1)*Nb-1])

vanno eseguite una dietro l'altra 9 volte.
May 11, 2015, at 05:49 PM by 79.58.39.104 -
Changed lines 181-184 from:
!!! AddRoundKey

La funzione '''AddRoundKey'''

to:

Changed lines 197-200 from:
Per ogni blocco
to:
Preso un blocco, ad ogni byte del blocco è sommato (XOR), in ordine, un byte della chiave espansa. Se ogni blocco è di 16 byte, si sfruttano 16byte della chiave per blocco. Nessun byte della chiave espansa è usato più di una volta. Questa operazione è chiamata '''AddRoundKey'''.


May 11, 2015, at 05:35 PM by 79.58.39.104 -
Changed line 194 from:
|||| Nk || Nb || Nr ||
to:
|| || Nk || Nb || Nr ||
May 11, 2015, at 05:34 PM by 79.58.39.104 -
Added lines 191-199:
Per evitare confusioni mettiamo le variabili che ritroveremo spesso in tabella a seconda della lunghezza della chiave:

||border=1
|||| Nk || Nb || Nr ||
|| 128 bit || 4 || 4 || 10 ||
|| 192 bit || 6 || 4 || 12 ||
|| 256 bit || 8 || 4 || 14 ||

Per ogni blocco
May 11, 2015, at 05:14 PM by 79.58.39.104 -
Changed line 143 from:
 RotWord(cf4f3c09) = 8a84eb01
to:
 Subword(cf 4f 3c 09) = 8a 84 eb 01
Changed lines 72-74 from:
!!!Rotazione
Si
puo' ottenere una rotazione dei 32bit di partenza con il prodotto per {01}{00}{00}{00}, cioè per x'^3^'. Abbiamo, infatti, la seguente proprieta':
to:
!!!RotWord()
E' una rotazione che si
puo' ottenere una rotazione dei 32bit di partenza con il prodotto per {01}{00}{00}{00}, cioè per x'^3^'. Abbiamo, infatti, la seguente proprieta':
Changed lines 141-142 from:
E' una funzione che applica la funzione SubByte() ai quatto ''byte'' di un ''word''.
to:
E' una funzione che applica la funzione SubByte() ai quatto ''byte'' di un ''word''.  Esempio:

 RotWord(cf4f3c09) = 8a84eb01

Changed line 158 from:
* se usiamo una chiave a 256 bit il punto precendete vale ancora, ma invece della formula generale, quella generale diventa:
to:
* se usiamo una chiave a 256 bit il punto precedente vale ancora, ma invece della formula generale, quella generale diventa:
Deleted line 160:
'''(da completare)'''
Changed lines 145-150 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di byte chiave * (Numero di cicli + 1)] ''byte''.  Il numero di cicli è 10, 12 o 14 a seconda se usiamo una chiave rispettivamente a 128, 192 o 256 bit. Quindi con chiave da 128 bit (16 byte) abbiamo una chiave espansa da 176 ''byte''.

La chiave viene raggruppata in ''word'', ogni ''word'' e' composto da 32bit (4 * 8bit). La nuova chiave espansa è una serie di ''word''  messi in un vettore, dove i primi 4 word (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.

I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, con qualche eccezione in alcune posizioni. Quindi la formula generale sarebbe:
to:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di byte chiave * (Numero di cicli + 1)] ''byte''.  Il numero di cicli è 10, 12 o 14 a seconda se usiamo una chiave rispettivamente a 128, 192 o 256 bit. Quindi con chiave da 128 bit (16 byte) abbiamo una chiave espansa composta totalemente da 176 ''byte''.

La chiave viene raggruppata in ''word'', ricordiamo che ogni ''word'' e' composto da 32bit (4 byte, cioe' 4 * 8bit). La nuova chiave espansa è una serie di ''word''  messi in un vettore, dove i primi 4 word (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio da quelli della chiave di partenza. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.

I numeri dopo Nk-esimo word, i successivi sono generati facendo lo XOR tra il word precedente e il word Nk volte indietro nella sequenza, con qualche eccezione in alcune posizioni. Quindi la formula generale sarebbe:
Changed lines 156-157 from:
* usiamo una chiave a 256 bit invece della formula standard
to:
* se usiamo una chiave a 256 bit il punto precendete vale ancora, ma invece della formula generale, quella generale diventa:
{$ (K e y)_i = S u b W o r d((K e y)_(i-1)) cdot  XOR cdot (K e y)_(i-N_k)$}
Changed line 145 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di byte chiave * (Numero di cicli + 1)] ''byte''.  Quindi con chiave da 128 bit (16 byte) abbiamo una chiave espansa da 176 ''byte''.
to:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di byte chiave * (Numero di cicli + 1)] ''byte''.  Il numero di cicli è 10, 12 o 14 a seconda se usiamo una chiave rispettivamente a 128, 192 o 256 bit. Quindi con chiave da 128 bit (16 byte) abbiamo una chiave espansa da 176 ''byte''.
Changed lines 147-148 from:
Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 word (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.
to:
La chiave viene raggruppata in ''word'', ogni ''word'' e' composto da 32bit (4 * 8bit). La nuova chiave espansa è una serie di ''word'' messi in un vettore, dove i primi 4 word (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.
Changed line 154 from:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula (Rcon[i/Nk] è un elemento del vettoRcon):
to:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula (nota che Rcon[i/Nk] è un elemento del vettore Rcon):
Added line 156:
* usiamo una chiave a 256 bit invece della formula standard
Changed lines 64-65 from:
{$= [ ({04}),({00}),({04},{00}) ] = {00}{04}{00}{04} $}
to:

{$= [ ({04}),({00}),({04}),({00}) ] = {00}{04}{00}{04} $}
Changed lines 63-84 from:
{$= [ ({18}+{70}+{3c}+{50}), ({a8}+{b8}+{8e}+{9e}),({63}+{09}+{43}+{2d}),({d3}+{c1}+{f1}+{e3}) ]$}


che sono una serie di moltiplicazioni e addizioni a 8 bit. Il risultato si trasforma in polinomio e si divide per  per {
$ x^4 +1 $} e si utilizza come risultato il resto della divisione. La trasformazioni in polinomi abbiamo:

{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = $}

{$=  ({a3}x^3 + {a2}x^2 + {a1}x + {a0}) *  ({b3}x^3 + {b2}x^2 + {b1}x + {b0})  = $}

{$ = {a3}{b3}x^6 + ( {a3}{b2} + {a2}{b3} ) x^5 +  ({a3}{b1} + {a2}{b2} + {a1}{b3})x^4 + ({a3}{b0} + {a2}{b1} + {a1}{b2} + {a0}{b3})x^3 + ({a2}{b0} + {a1}{b1} + {a0}{b2})x^2 + ({a1}{b0} + {a0}{b1})x + {a0}{b0}  = $}

ricordandola moltiplicazione tra byte vista prima abbiamo:

{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + {c1} +{f1} +{e3} ) x^3 + ({63}+{09}+{43})x^2+({a8}+{b8})x + {18}  = $}

l'addizione e' lo XOR, quindi:

{$ = {2d}x^6 + {10}x^5 + {1c}x^4+ {29}x^2 + {10}x + {18} $}

dividiamo per {$ x^4 + 1 $} e otteniamo come resto {- { $  {1c}x^4 - {04}x^2 + {18}  $ }. Quindi possiamo scrivere: -}

{- { $ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = {1c}{00}{04}{18}$ } -}
to:
{$ = [ ({18}+{70}+{3c}+{50}), ({a8}+{b8}+{8e}+{9e}),({63}+{09}+{43}+{2d}),({d3}+{c1}+{f1}+{e3}) ] = $}
{$= [ ({04}),({00}),({04},{00}) ] = {00}{04}{00}{04} $}



Changed lines 59-61 from:
corrisponde al prodotto matriciale:

{$ [ (
{a0},{a3},{a2},{a1}),({a1},{a0},{a3},{a2}),({a2},{a1},{a0},{a3}),({a3},{a2},{a1},{a0})] * [({b0}),({b1}),({b2}),({b3})] = [( {a0}*{b0} + {a3}*{b1}+{a2}*{b2}+{a1}*{b3} ),({a1}*{b0} + {a0}*{b1}+{a3}*{b2}+{a2}*{b3}),({a2}*{b0}+{a1}*{b1}+{a0}*{b2}+{a3}*{b3}),({a3}*{b0}+{a2}*{b1}+{a1}*{b2}+{a0}*{b3})  ]$}
to:
applicando l'algebra dei campi finiti corrisponde al prodotto matriciale, molto piu' facile da calcolare:

{$ [ ({a0},{a3},{a2},{a1}),({a1},{a0},{a3},{a2}),({a2},{a1},{a0},{a3}),({a3},{a2},{a1},{a0})] * [({b0}),({b1}),({b2}),({b3})] = [( {a0}*{b0} + {a3}*{b1}+{a2}*{b2}+{a1}*{b3} ),({a1}*{b0} + {a0}*{b1}+{a3}*{b2}+{a2}*{b3}),({a2}*{b0}+{a1}*{b1}+{a0}*{b2}+{a3}*{b3}),({a3}*{b0}+{a2}*{b1}+{a1}*{b2}+{a0}*{b3})  ] = $}

{$= [ ({18}+{70}+{3c}+{50}), ({a8}+{b8}+{8e}+{9e}),({63}+{09}+{43}+{2d}),({d3}+{c1}+{f1}+{e3}) ]$}

Changed lines 61-65 from:
{$ [ ({a_0},{a_3},{a_2},{a_1}),({a_1},{a_0},{a_3},{a_2}),({a_2},{a_1},{a_0},{a_3}),({a_3},{a_2},{a_1},{a_0})] * [({b_0}),({b_1}),({b_2}),({b_3})] = [
( {a0}*{b0} + {a3}*{b1}+{a2}*{b2}+{a1}*{b3} ),
({a1}*{b0} + {a0}*{b1}+{a3}*{b2}+{a2}*{b3}),
({a2}*{b0}+{a1}*{b1}+{a0}*{b2}+{a3}*{b3}),
({a3}*{b0}+{a2}*{b1}+{a1}*{b2}+{a0}*{b3})  ]$}
to:
{$ [ ({a0},{a3},{a2},{a1}),({a1},{a0},{a3},{a2}),({a2},{a1},{a0},{a3}),({a3},{a2},{a1},{a0})] * [({b0}),({b1}),({b2}),({b3})] = [( {a0}*{b0} + {a3}*{b1}+{a2}*{b2}+{a1}*{b3} ),({a1}*{b0} + {a0}*{b1}+{a3}*{b2}+{a2}*{b3}),({a2}*{b0}+{a1}*{b1}+{a0}*{b2}+{a3}*{b3}),({a3}*{b0}+{a2}*{b1}+{a1}*{b2}+{a0}*{b3})  ]$}
Changed lines 61-65 from:
{$ [ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [(b_0),(b_1),(b_2),(b_3)] $}
to:
{$ [ ({a_0},{a_3},{a_2},{a_1}),({a_1},{a_0},{a_3},{a_2}),({a_2},{a_1},{a_0},{a_3}),({a_3},{a_2},{a_1},{a_0})] * [({b_0}),({b_1}),({b_2}),({b_3})] = [
( {a0}*{b0} + {a3}*{b1}+{a2}*{b2}+{a1}*{b3} ),
({a1}*{b0} + {a0}*{b1}+{a3}*{b2}+{a2}*{b3}),
({a2}*{b0}+{a1}*{b1}+{a0}*{b2}+{a3}*{b3}),
({a3}*{b0}+{a2}*{b1}+{a1}*{b2}+{a0}*{b3})  ]
$}
Changed lines 79-81 from:
dividiamo per {$ x^4 + 1 $} e otteniamo come resto {- {$  {1c}x^4 - {04}x^2 + {18}  $}. Quindi possiamo scrivere:

{$ {a3
}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0= {1c}{00}{04}{18}$} -}
to:
dividiamo per {$ x^4 + 1 $} e otteniamo come resto {- { $   {1c}x^4 - {04}x^2 + {18}  $ }. Quindi possiamo scrivere: -}

{- { $ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = {1c}{00}{04}{18}$ } -}
Changed lines 79-81 from:
dividiamo per {$ x^4 + 1 $} e otteniamo come resto {{1c}x^4 - {04}x^2 + {18}  $}. Quindi possiamo scrivere:

{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = {1c}{00}{04}{18}$}
to:
dividiamo per {$ x^4 + 1 $} e otteniamo come resto {- {$   {1c}x^4 - {04}x^2 + {18}  $}. Quindi possiamo scrivere:

{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = {1c}{00}{04}{18}$} -}
Changed line 166 from:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula:
to:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula (Rcon[i/Nk] è un elemento del vettoRcon):
Changed line 128 from:
!!!Funzione SubByte
to:
!!!Funzione SubByte()
Added lines 151-153:

!!!Funzione SubWord()
E' una funzione che applica la funzione SubByte() ai quatto ''byte'' di un ''word''.
Changed line 164 from:
{$  (K e y)_i = (K e y)_(i-k) cdot  XOR [ S u b W o r d(R o t W o r d((K e y)_(i-1))) xor Rcon_(i/N_k) ] $}
to:
{$  (K e y)_i = (K e y)_(i-k) cdot  XOR cdot [ S u b W o r d(R o t W o r d((K e y)_(i-1))) cdot X O R cdot Rcon_(i/N_k) ] $}
Changed lines 163-164 from:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula: {$  (K e y)_i = (K e y)_(i-k) cdot  XOR [ SubWord(RotWord((K e y)_(i-1))) xor Rcon[i/N_k] ] $}
to:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula:
{$  (K e y)_i = (K e y)_(i-k) cdot  XOR [ S u b W o r d(R o t W o r d((K e y)_(i-1))) xor Rcon_(i/N_k) ] $}
Changed line 163 from:
* ogni elemento della chiave multiplo di Nk
to:
* ogni elemento della chiave che e' nella posizione  che e' multiplo di Nk, segue quest'altra formula: {$  (K e y)_i = (K e y)_(i-k) cdot  XOR [ SubWord(RotWord((K e y)_(i-1))) xor Rcon[i/N_k] ] $}
Changed lines 160-162 from:
{$ (K e y)_i = (K e y)_(i-1) X O R (K e y)_(i-N_k)$}

* ogni Nk volte si non si usa il
to:
{$ (K e y)_i = (K e y)_(i-1) cdot  XOR cdot (K e y)_(i-N_k)$}

solo che:
*
ogni elemento della chiave multiplo di Nk
Changed lines 158-159 from:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, solo che ogni Nk volte si '(da completare)'
to:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, con qualche eccezione in alcune posizioni. Quindi la formula generale sarebbe:

{$ (K e y
)_i = (K e y)_(i-1) X O R (K e y)_(i-N_k)$}

* ogni Nk volte si non si usa il

'''(da completare)''
'
Changed line 195 from:
'(da completare)'
to:
''(da completare)''
Added lines 149-150:

Quindi il il subByte di {53} è {ED}.
Changed line 129 from:
Questa funzione opera su un byte, come ad esempio {2A}. La spiegazione e' complessa, ma si può vedere come un gioco dove si predono i due valori del byte e si trova il risultato nella tabella seguente:
to:
Questa funzione opera su un byte, come ad esempio {2A}. La spiegazione e' complessa, ma si può vedere come un gioco dove si predono i due valori del byte la cifra a sinistra e' la riga, la cifra a destra e' la colonna e si trova il risultato nell'incrocio della tabella seguente:
Changed lines 142-148 from:
||9 ||60  ||81  ||4f  ||dc  ||22  ||2a  ||90  ||88  ||46  ||ee  ||b8  ||14  ||de  ||5e  ||0b  db
||a ||e0  ||32  ||3a  ||0a  ||49  ||06  ||24 ||5c  ||c2  d3  ac  62  91  95  e4  79
||b ||e7  ||c8  ||37  ||6d  ||8d  ||d5  ||4e  ||a9  ||6c  56  f4  ea  65  7a  ae  08
||c ||ba  ||78  ||25  ||2e  ||1c  ||a6  ||b4  ||c6  ||e8  dd  74  1f  4b  bd  8b  8a
||d ||70  ||3e  ||b5  ||66  ||48  ||03  ||f6  ||0e  ||61  35  57  b9  86  c1  1d  9e
||e ||e1  ||f8  ||98  ||11  ||69  ||d9  ||8e  ||94  ||9b  1e  87  e9  ce  55  28  df
||f ||8c  ||a1  ||89  ||0d  ||bf  ||e6  ||42  ||68  ||41  99  2d  0f  b0  54  bb  16
to:
||9 ||60  ||81  ||4f  ||dc  ||22  ||2a  ||90  ||88  ||46  ||ee  ||b8  ||14  ||de  ||5e  ||0b  ||db
||
a ||e0  ||32  ||3a  ||0a  ||49  ||06  ||24 ||5c  ||c2  ||d3  ||ac  ||62  ||91  ||95  ||e4  ||79
||
b ||e7  ||c8  ||37  ||6d  ||8d  ||d5  ||4e  ||a9  ||6c  ||56  ||f4  ||ea  ||65  ||7a  ||ae  ||08
||
c ||ba  ||78  ||25  ||2e  ||1c  ||a6  ||b4  ||c6  ||e8  ||dd  ||74  ||1f  ||4b  ||bd  ||8b  ||8a
||
d ||70  ||3e  ||b5  ||66  ||48  ||03  ||f6  ||0e  ||61  ||35  ||57  ||b9 ||86  ||c1  ||1d ||9e
||
e ||e1  ||f8  ||98  ||11  ||69  ||d9  ||8e  ||94  ||9b  ||1e  ||87  ||e9  ||ce  ||55  ||28  ||df
||
f ||8c  ||a1  ||89  ||0d  ||bf  ||e6  ||42  ||68  ||41  ||99  ||2d  ||0f  ||b0  ||54  ||bb  ||16
Added lines 128-149:
!!!Funzione SubByte
Questa funzione opera su un byte, come ad esempio {2A}. La spiegazione e' complessa, ma si può vedere come un gioco dove si predono i due valori del byte e si trova il risultato nella tabella seguente:

||border=1
|| ||0  ||1  ||2  || 3  ||4  ||5  ||6  ||7  ||8  ||9  ||a  ||b  ||c  ||d  || e  || f
||0 ||63  ||7c  ||77  ||7b  ||f2  ||6b ||6f  ||c5  ||30  ||01  ||67  ||2b ||fe  ||d7  ||ab  ||76
||1 ||ca  ||82  ||c9  ||7d  ||fa  ||59  ||47  ||f0  ||ad  ||d4  ||a2  ||af  ||9c  ||a4  ||72  ||c0
||2 ||b7  ||fd  ||93  ||26  ||36  ||3f  ||f7  ||cc  ||34  ||a5  ||e5  ||f1  ||71  ||d8  ||31  ||15
||3 ||04  ||c7 ||23  ||c3  ||18  ||96  ||05  ||9a  ||07  ||12  ||80  ||e2  ||eb  ||27  ||b2  ||75
||4 ||09  ||83  ||2c ||1a  ||1b  ||6e  ||5a  ||a0  ||52  ||3b  ||d6  ||b3  ||29  ||e3  ||2f  ||84
||5 ||53  ||d1  ||00  ||ed  ||20  ||fc  ||b1  ||5b  ||6a  ||cb  ||be  ||39  ||4a  ||4c  ||58  ||cf
||6 ||d0  ||ef  ||aa  ||fb  ||43  ||4d  ||33  ||85  ||45  ||f9  ||02  ||7f  ||50  ||3c  ||9f  ||a8
||7 ||51  ||a3 ||40  ||8f  ||92  ||9d  ||38  ||f5  ||bc  ||b6  ||da  ||21  ||10 ||ff ||f3  ||d2
||8 ||cd  ||0c  ||13  ||ec  ||5f  ||97  ||44  ||17  ||c4  ||a7  ||7e  ||3d  ||64  ||5d  ||19  ||73
||9 ||60  ||81  ||4f  ||dc  ||22  ||2a  ||90  ||88  ||46  ||ee  ||b8  ||14  ||de  ||5e  ||0b  db
||a ||e0  ||32  ||3a  ||0a  ||49  ||06  ||24 ||5c  ||c2  d3  ac  62  91  95  e4  79
||b ||e7  ||c8  ||37  ||6d  ||8d  ||d5  ||4e  ||a9  ||6c  56  f4  ea  65  7a  ae  08
||c ||ba  ||78  ||25  ||2e  ||1c  ||a6  ||b4  ||c6  ||e8  dd  74  1f  4b  bd  8b  8a
||d ||70  ||3e  ||b5  ||66  ||48  ||03  ||f6  ||0e  ||61  35  57  b9  86  c1  1d  9e
||e ||e1  ||f8  ||98  ||11  ||69  ||d9  ||8e  ||94  ||9b  1e  87  e9  ce  55  28  df
||f ||8c  ||a1  ||89  ||0d  ||bf  ||e6  ||42  ||68  ||41  99  2d  0f  b0  54  bb  16

Changed lines 156-157 from:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, solo che ogni Nk volte si
to:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, solo che ogni Nk volte si '(da completare)'
Added lines 186-187:

'(da completare)'
August 22, 2014, at 11:31 AM by Massimiliano Vessi -
Added lines 79-81:
dividiamo per {$ x^4 + 1 $} e otteniamo come resto {$  {1c}x^4 - {04}x^2 + {18}  $}. Quindi possiamo scrivere:

{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = {1c}{00}{04}{18}$}
August 22, 2014, at 11:11 AM by Massimiliano Vessi -
Changed lines 73-75 from:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + {c1} +{f1} +{e3} ) x^3 + ({63}+{09}+{43})x^2+({a8}+{b8})x + {18}  $}

l'addizione è lo XOR, quindi:
to:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + {c1} +{f1} +{e3} ) x^3 + ({63}+{09}+{43})x^2+({a8}+{b8})x + {18}  = $}

l'addizione e' lo XOR, quindi:

{$ = {2d}x^6 + {10}x^5 + {1c}x^4+ {29}x^2 + {10}x + {18} $}

August 22, 2014, at 11:06 AM by Massimiliano Vessi -
Changed lines 73-76 from:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + )... $}
to:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + {c1} +{f1} +{e3} ) x^3 + ({63}+{09}+{43})x^2+({a8}+{b8})x + {18}  $}

l'addizione è lo XOR, quindi:

July 25, 2014, at 05:34 PM by Massimiliano Vessi -
Changed line 73 from:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ... $}
to:
{$= {2d}x^6 + ({8e} + {9e})x^5 + ({70} + {3c} + {50})x^4 + ({d3} + )... $}
July 25, 2014, at 05:17 PM by Massimiliano Vessi -
Added lines 70-73:

ricordandola moltiplicazione tra byte vista prima abbiamo:

{$= {2d}x^6 + ({8e} + {9e})x^5 + ... $}
July 25, 2014, at 04:54 PM by Massimiliano Vessi -
Changed line 69 from:
{$ = {a3}{b3}x^6 + ({a3}{b2} + {a2}{b3})x^5 +  ({a3}{b1} + {a2}{b2} + {a1}{b3})x^4 + ({a3}{b0} + {a2}{b1} + {a1}{b2} + {a0}{b3})x^3 + ({a2}{b0} + {a1}{b1} + {a0}{b2})x^2 + ({a1}{b0} + {a0}{b1})x + {a0}{b0}  = $}
to:
{$ = {a3}{b3}x^6 + ( {a3}{b2} + {a2}{b3} ) x^5 +  ({a3}{b1} + {a2}{b2} + {a1}{b3})x^4 + ({a3}{b0} + {a2}{b1} + {a1}{b2} + {a0}{b3})x^3 + ({a2}{b0} + {a1}{b1} + {a0}{b2})x^2 + ({a1}{b0} + {a0}{b1})x + {a0}{b0}  = $}
July 25, 2014, at 04:52 PM by Massimiliano Vessi -
Added lines 68-69:

{$ = {a3}{b3}x^6 + ({a3}{b2} + {a2}{b3})x^5 +  ({a3}{b1} + {a2}{b2} + {a1}{b3})x^4 + ({a3}{b0} + {a2}{b1} + {a1}{b2} + {a0}{b3})x^3 + ({a2}{b0} + {a1}{b1} + {a0}{b2})x^2 + ({a1}{b0} + {a0}{b1})x + {a0}{b0}  = $}
July 25, 2014, at 04:46 PM by Massimiliano Vessi -
Changed lines 63-67 from:
che sono una serie di moltiplicazioni e addizioni a 8 bit. Il risultato si trasforma in polinomio e si divide per  per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione.
to:
che sono una serie di moltiplicazioni e addizioni a 8 bit. Il risultato si trasforma in polinomio e si divide per  per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. La trasformazioni in polinomi abbiamo:

{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  = $}

{$=  ({a3}x^3 + {a2}x^2 + {a1}x + {a0}) *  ({b3}x^3 + {b2}x^2 + {b1}x + {b0})  = $}
July 25, 2014, at 04:36 PM by Massimiliano Vessi -
Changed lines 39-40 from:
Si potevano trovare altre strade per fare una moltiplicazione in un campo finito, ma questo metodo garantisce delle proprieta' che vengono sfruttate dal sistema AES.
to:
Si potevano trovare altre strade per fare una moltiplicazione in un campo finito, ma questo metodo garantisce delle proprieta' che vengono sfruttate dal sistema AES. Se i coefficienti del resto sono negativi o positivi non cambia nulla.
Changed lines 93-95 from:
{$ R c o n_3 = {08}{00}{00}{00} $}

{$ R c o n_10 = {36}{00}{00}{00} $}
to:
{$ R c o n_3 = {04}{00}{00}{00} $}

{$ R c o n_4 = {08}{00}{00}{00} $}

{$ R c o n_5 = {10}{00}{00}{00} $}

{$ R c o n_6 = {20}{00}{00}{00} $}

{$ R c o n_7 = {40}{00}{00}{00} $}

{$ R c o n_8 = {80}{00}{00}{00} $}

{$ R c o n_9  = {1B}{00}{00}{00} $}

e cosi'  via... Ricordando la moltiplicazione fra byte.
July 25, 2014, at 03:59 PM by Massimiliano Vessi -
Changed lines 85-86 from:
{$ R c o n_i = {prod_(n=0) ^(i-1) {02}}{00}{00}{00} $}
to:
{$ R c o n_i =  {02}^(i-1){00}{00}{00} $}
Changed lines 105-106 from:
Per esempio la chiave: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
to:
Per esempio la chiave: '''00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F'''
Changed line 108 from:
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
to:
'''00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F'''
July 24, 2014, at 05:14 PM by Massimiliano Vessi -
Changed line 74 from:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta (4 ''word''). Ricordiamo che ogni blocco di 32 bit (''word'') e' costituito a sua volta da 4 blocchi da 8 bit.
to:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a ''pezzi'' da 128bit, cioe' prende 4 gruppi di 32bit alla volta (4 ''word''). Ricordiamo che gruppo di 32 bit (''word'') e' costituito a sua volta da 4 blocchi da 8 bit (''byte'').
July 24, 2014, at 05:08 PM by Massimiliano Vessi -
Changed lines 85-95 from:
{$ R c o n_i) = {prod_(n=0) ^(i-1) {02}}{00}{00}{00} $}
to:
{$ R c o n_i = {prod_(n=0) ^(i-1) {02}}{00}{00}{00} $}

quindi:

{$ R c o n_1 = {00}{00}{00}{00} $}

{$ R c o n_2 = {02}{00}{00}{00} $}

{$ R c o n_3 = {08}{00}{00}{00} $}

{$ R c o n_10 = {36
}{00}{00}{00} $}
July 24, 2014, at 04:40 PM by Massimiliano Vessi -
Added lines 82-86:
!!!Vettore Rcon
Si crea il vettore Rcon, formato da ''word'', lungo 176 elementi. Ogni elemento corrisponde alla seguente formula

{$ R c o n_i) = {prod_(n=0) ^(i-1) {02}}{00}{00}{00} $}

Changed lines 93-94 from:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza.
to:
I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza, solo che ogni Nk volte si
Added line 109:
July 24, 2014, at 04:11 PM by Massimiliano Vessi -
Changed lines 80-83 from:
Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 8bit in matrici 4x4, andando per colonna, non per riga; quindi il messaggio di input i blocchetti di 8 bit si dispongono secondo una matrice fatta cosi':

{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] $}

to:
Prima di cifrare bisogna espandere la chiave e creare delle funzioni particolari.
Added lines 112-116:
!!! Si comincia

Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 8bit in matrici 4x4, andando per colonna, non per riga; quindi il messaggio di input i blocchetti di 8 bit si dispongono secondo una matrice fatta cosi':

{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] $}
July 24, 2014, at 04:10 PM by Massimiliano Vessi -
Changed lines 22-23 from:
!!Numeri a 8 bit
to:
!!Numeri a 8 bit (byte)

Un numero formato da 8 bit si chiama ''byte''.

Changed line 86 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di word chiave * (Numero di cicli + 1)] ''word''.  Quindi con chiave da 128 bit (16 word) abbiamo una chiave espansa da 176 ''word''.
to:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di byte chiave * (Numero di cicli + 1)] ''byte''.  Quindi con chiave da 128 bit (16 byte) abbiamo una chiave espansa da 176 ''byte''.
July 24, 2014, at 04:07 PM by Massimiliano Vessi -
July 24, 2014, at 04:04 PM by Massimiliano Vessi -
Changed lines 46-49 from:
!!Numeri a 32 bit

In
certi frangenti si lavora con 4 numeri di 8 bit, che fanno un sistema a 32 bit particolare. Anche qui le formule sono diverse:
to:
!!Numeri a 32 bit (word)

In
certi frangenti si lavora con 4 numeri di 8 bit, che fanno un sistema a 32 bit particolare. Un blocco di 4 numeri da 8 bit ciascuno e' chiamato ''word''. Anche qui le formule sono diverse:
Changed lines 66-67 from:
{$ [(b_1),(b_2),(b_3),(b_0)]=[ (00,01,00,00),(00,00,01,00),(00,00,00,01),(01,00,00,00)] * [(b_0),(b_1),(b_2),(b_3)] $}
to:
{$ [ (00,01,00,00),(00,00,01,00),(00,00,00,01),(01,00,00,00)] * [(b_0),(b_1),(b_2),(b_3)] = [(b_1),(b_2),(b_3),(b_0)]$}
Deleted lines 69-70:
'''Rotazione'''
Changed lines 72-75 from:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta. Ricordiamo che ogni blocco di 32 bit e' costituito a sua volta da 4 blocchi da 8 bit.

A
seconda della lunghezza della chiave, cambia solamente il numero di cicli da iterare, con chiave a 128bit sono 10, con la chiave a 192bit sono 12, con la chiave a 256bit sono 14.
to:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta (4 ''word''). Ricordiamo che ogni blocco di 32 bit (''word'') e' costituito a sua volta da 4 blocchi da 8 bit.

Il procedimento per cifrare e' sempre lo stesso: a
seconda della lunghezza della chiave, cambia solamente il numero di cicli da iterare, con chiave a 128bit sono 10, con la chiave a 192bit sono 12, con la chiave a 256bit sono 14.
Changed lines 82-84 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri. Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 numeri (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.

I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro.
to:
!!!Espandere la chiave

Poi bisogna
''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [Numero di word chiave * (Numero di cicli + 1)] ''word''.  Quindi con chiave da 128 bit (16 word) abbiamo una chiave espansa da 176 ''word''.

Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 word (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla
chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.

I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro nella sequenza.

Per esempio la chiave: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F

espansa diventa:
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
D6 AA 74 FD D2 AF 72 FA DA A6 78 F1 D6 AB 76 FE
B6 92 CF 0B 64 3D BD F1 BE 9B C5 00 68 30 B3 FE
B6 FF 74 4E D2 C2 C9 BF 6C 59 0C BF 04 69 BF 41
47 F7 F7 BC 95 35 3E 03 F9 6C 32 BC FD 05 8D FD
3C AA A3 E8 A9 9F 9D EB 50 F3 AF 57 AD F6 22 AA
5E 39 0F 7D F7 A6 92 96 A7 55 3D C1 0A A3 1F 6B
14 F9 70 1A E3 5F E2 8C 44 0A DF 4D 4E A9 C0 26
47 43 87 35 A4 1C 65 B9 E0 16 BA F4 AE BF 7A D2
54 99 32 D1 F0 85 57 68 10 93 ED 9C BE 2C 97 4E
13 11 1D 7F E3 94 4A 17 F3 07 A7 8B 4D 2B 30 C5
July 24, 2014, at 03:42 PM by Massimiliano Vessi -
Changed lines 27-28 from:
La '''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
to:
La '''moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
Changed lines 46-47 from:
!!!Numeri a 32 bit
to:
!!Numeri a 32 bit
Changed lines 50-52 from:
*'''Addizione''' è la funzione XOR (bit a bit)
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit viste qualche paragrafo prima. Esempio in esadecimale:
to:
!!!Addizione
L
' '''Addizione''' e' la funzione XOR (bit a bit)
!!!Moltiplicazione
La
''moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit viste qualche paragrafo prima. Esempio in esadecimale:
Changed lines 63-65 from:
*'''Rotazione'''

!!Algoritmo
  AES
to:
!!!Rotazione
Si puo
' ottenere una rotazione dei 32bit di partenza con il prodotto per {01}{00}{00}{00}, cioè per x'^3^'. Abbiamo, infatti, la seguente proprieta':

{$ [(b_1),(b_2),(b_3),(b_0)]=[ (00,01,00,00),(00,00,01,00),(00,00,00,01),(01,00,00,00)] * [(b_0),(b_1),(b_2),(b_3)] $}

che equivale a scrivere in esadecimale:  {b3}{b2}{b1}{b0} * {01}{00}{00}{00} = {b0}{b3}{b2}{b1}

'''Rotazione'''

!Algoritmo  AES
July 24, 2014, at 03:33 PM by Massimiliano Vessi -
Changed lines 5-6 from:
!!Prima di cominciare
to:
!Prima di cominciare
Changed lines 16-17 from:
!!Termini
to:
!Termini
Changed lines 22-26 from:
!!!Numeri a 8 bit

*'''Addizione''' è la funzione XOR (bit a bit)
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
to:
!!Numeri a 8 bit

!!!Addizione
L
' '''Addizione''' e' la funzione XOR (bit a bit)
!!!Moltiplicazione
La
'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
Changed lines 43-44 from:
*funzione '''xtime()''', serve a moltiplicare un numero per 00000010.
to:
!!! xtime()
La funzione '''xtime()''', serve a moltiplicare un numero per 00000010 (in esadecimale è {02}).
Added lines 60-61:

*'''Rotazione'''
July 15, 2014, at 12:58 PM by Massimiliano Vessi -
Changed lines 70-73 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri. Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 (o 6 o 8 a seconda della lunghezza della chiave), sono proprio i bit della chiave.
to:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri. Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 numeri (oppure 6 o 8, a seconda della lunghezza della chiave), sono costituiti proprio dai bit della chiave. Indichiamo i primi numeri corrispondenti alla  chiave con la variabile '''Nk''', cioe' Nk potra' valere solo 4, 6 o 8 a seconda se abbiamo una chiave rispettivamente a 128bit, a 192bit oppure a 256bit.

I numeri dopo Nk-esimo sono generati facendo lo XOR tra il numero precedente e il numero Nk volte indietro.

July 15, 2014, at 12:38 PM by Massimiliano Vessi -
July 15, 2014, at 12:31 PM by Massimiliano Vessi -
Changed line 70 from:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri.
to:
Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri. Ogni numero e' composto da 32bit (4 * 8bit). I numeri generati sono messi in un vettore, dove i primi 4 (o 6 o 8 a seconda della lunghezza della chiave), sono proprio i bit della chiave.
July 15, 2014, at 12:19 PM by Massimiliano Vessi -
Added lines 69-76:

Poi bisogna ''espandere'' la chiave di cifratura: il termine ''espandere'' significa che dobbiamo generare dei numeri. Per l'esattezza si generano [4 * (Numero di cicli + 1)] numeri.

Per ogni matrice da 128 bit vengono fatte le seguenti operazioni:

!!! AddRoundKey

La funzione '''AddRoundKey'''
July 15, 2014, at 12:09 PM by Massimiliano Vessi -
Changed line 66 from:
Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 4bit in matrici 4x4, andando per colonna, non per riga; quindi il messaggio di input di dispone a blocchetti di 8 bit secondo una matrice fatta cosi':
to:
Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 8bit in matrici 4x4, andando per colonna, non per riga; quindi il messaggio di input i blocchetti di 8 bit si dispongono secondo una matrice fatta cosi':
July 15, 2014, at 12:07 PM by Massimiliano Vessi -
Changed lines 18-19 from:
Siccome tutto il sistema di lavora con al massimo alla volta 8bit, tutto il sistema deve trasformare le operazioni in modo che i numeri non  superino mai gli 8bit. Tecnicamente si dice che di lavora in un [[http://it.wikipedia.org/wiki/Campo_finito | campo finito]] {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
to:
Siccome tutto il sistema fa operazioni numeriche con massimo blocchetti di 8bit alla volta, tutto il sistema deve trasformare le operazioni in modo che i numeri non  superino mai gli 8bit. Tecnicamente si dice che di lavora in un [[http://it.wikipedia.org/wiki/Campo_finito | campo finito]] {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
Changed lines 60-61 from:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta. Ricordiamo che ogni blocco di 32 bit e costituito a sua volta da 4 blocchi da 8 bit.
to:
Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta. Ricordiamo che ogni blocco di 32 bit e' costituito a sua volta da 4 blocchi da 8 bit.
Changed lines 66-67 from:
Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 4bit in matrici 4x4, andando per colonna, non per riga; quindi:
to:
Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 4bit in matrici 4x4, andando per colonna, non per riga; quindi il messaggio di input di dispone a blocchetti di 8 bit secondo una matrice fatta cosi':
July 15, 2014, at 12:02 PM by Massimiliano Vessi -
Changed lines 1-2 from:
La cifratura attraverso il metodo AES e' di tipo simmetrico.
to:
La cifratura attraverso il metodo AES e' di tipo simmetrico. E' oggi tra i sistemi piu' usati al mondo di crittografia.
Added lines 5-15:
!!Prima di cominciare

Anticipo che il sistema AES lavora solo a blocchi di 128 bit, se il vostro messaggio da cifrare non e' lungo un multiplo esatto di 128 bit, va modificato.
Il vantaggio di utilizzare blocchi fissi permette di spezzare il lavoro in blocchi, ogni blocco può essere elaborato in parallelo; quindi, avendo piu' elaboratori a disposizione, si puo' risparmiare molto tempo dando un blocco in pasto ad un elaboratore diverso.

I sistemi per modificare il messaggio in modo che sia un multiplo esatto di 128 bit sono vari. Devono garantire che non sia banale decifrare il messaggio, ''ad esempio aggiungere tutti zeri alla fine del messaggio non e' una buona idea'', e dovrebbero mantenere tutti i vantaggi del sistema AES intatti.

Tra i sistemi piu' utilizzati per portare la lunghezza del messaggio di partenza a un multiplo di 128 bit c'e' il sistema CBC che pero' rende il sistema AES non piu' parallelizzabile. Questo perche' il CBC sfrutta il risultato di cifratura di un blocco di 128bit per modificare il successivo e cosi' via fino ad ottenere tutti blocchi da 128 bit. E' il piu' usato perche' e' molto semplice, ma se avete problemi di velocita' evitatelo.

Al contrario il sistema CTR per portare la lunghezza del  messaggio ad un multiplo di  128 bit puo' essere parallelizzato. E' piu' difficile da implementare, ma vi risparmiera'  molto tempo se potete parallelizzare.

Changed lines 50-57 from:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3}  x^3 + {a2} x^2 + {a1} x + {a0}) * ( {b3}  x^3 + {b2} x^2 + {b1} x + {b0}) = $}

{$ = {a3}*{b3} x^6 + [ ({a3}*{b2}) + ({a2}*{b3}) ] x^5 + [ ({a3} * {b1})  + ( {a2}*{b2} ) + ({a1}*{b3}) ] x^4 + [({a3}*{b0})  +  ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ] x^3 + [ ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ] x^2  + [({a1}*{b0}) + ({a0}*{b1}) ] x + ({a0}*{b0}) $}

....

*'''Prodotto modulare''': si intende il prodotto matriciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit), considerando prodotto e moltiplicazione come appena esposto, messi nella forma polinomiale i coefficienti si moltiplicano cosi'
:
to:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0}  $}

corrisponde al prodotto matriciale
:
Added lines 55-56:

che sono una serie di moltiplicazioni e addizioni a 8 bit. Il risultato si trasforma in polinomio e si divide per  per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione.
July 14, 2014, at 06:26 PM by Massimiliano Vessi -
Deleted line 59:
poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = i n_(r+3c) $} , quindi l'elemento {$s_(2,3) = i n_(11)$}
July 14, 2014, at 06:21 PM by Massimiliano Vessi -
Changed line 47 from:
{$ [ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [b_0,b_1,b_2,b_3] $}
to:
{$ [ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [(b_0),(b_1),(b_2),(b_3)] $}
July 14, 2014, at 06:17 PM by Massimiliano Vessi -
Changed line 60 from:
poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = in_(r+3c) $} , quindi l'elemento {$s_(2,3) = i n_(11)$}
to:
poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = i n_(r+3c) $} , quindi l'elemento {$s_(2,3) = i n_(11)$}
July 14, 2014, at 06:17 PM by Massimiliano Vessi -
Changed line 60 from:
poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = in_(r+3c) $} , quindi l'elemento {$s_(2,3) = in_(11)$}
to:
poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = in_(r+3c) $} , quindi l'elemento {$s_(2,3) = i n_(11)$}
July 14, 2014, at 06:16 PM by Massimiliano Vessi -
Changed lines 58-60 from:
{$ [ (in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15) ] $}
to:
{$ [ (i n_1,i n_5,i n_9,i n_13),(i n_2,i n_6,i n_10,i n_14),( i n_3,i n_7,i n_11,i n_15),(i n_4,i n_8,i n_12,i n_16) ] $}

poi si copiano gli elementi una una matrice S (''state'') di passaggio spostandoli in una nuova posizione usando la regola {$s_(r,c) = in_(r+3c) $} , quindi l'elemento {$s_(2,3) = in_(11)
$}
July 14, 2014, at 06:08 PM by Massimiliano Vessi -
Changed lines 47-48 from:
{$ [ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [b_0,b_1,b_2,b_3]$}
to:
{$ [ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [b_0,b_1,b_2,b_3] $}
Changed line 58 from:
{$[ (in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15) ]$}
to:
{$ [ (in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15) ] $}
July 14, 2014, at 06:07 PM by Massimiliano Vessi -
Changed line 58 from:
{$[(in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15)]$}
to:
{$[ (in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15) ]$}
July 14, 2014, at 06:06 PM by Massimiliano Vessi -
Changed lines 49-58 from:
to:
!!Algoritmo  AES

Prima di tutto chiariamo che il sistema AES lavora '''sempre''' a blocchi da 128bit, cioe' prende 4 gruppi di 32bit alla volta. Ricordiamo che ogni blocco di 32 bit e costituito a sua volta da 4 blocchi da 8 bit.

A seconda della lunghezza della chiave, cambia solamente il numero di cicli da iterare, con chiave a 128bit sono 10, con la chiave a 192bit sono 12, con la chiave a 256bit sono 14.

!!Cifrare

Per cifrare si prendono i bit del messaggio e si dispongo a blocchi di 4bit in matrici 4x4, andando per colonna, non per riga; quindi:
{$[(in_0,in_4,in_8,in_12),(in_1,in_5,in_9,in_13),(in_2,in_6,in_10,in_14),(in_3,in_7,in_11,in_15)]$}
July 14, 2014, at 05:52 PM by Massimiliano Vessi -
Changed line 45 from:
*'''Prodotto modulare''': si intende il prodoto matriciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit), considerando prodotto e moltiplcazione come appena esposto, messi nella forma:
to:
*'''Prodotto modulare''': si intende il prodotto matriciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit), considerando prodotto e moltiplicazione come appena esposto, messi nella forma polinomiale i coefficienti si moltiplicano cosi':
July 14, 2014, at 05:48 PM by Massimiliano Vessi -
Changed lines 45-47 from:
*'''Prodotto modulare''': si intende il prodoto mariciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit, messi nella forma:

{$[ (a_0
,a_3,a_2,a_1),(a_1,a_0,a_3,a_2)]$}
to:
*'''Prodotto modulare''': si intende il prodoto matriciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit), considerando prodotto e moltiplcazione come appena esposto, messi nella forma:

{$ [ (
a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2),(a_2,a_1,a_0,a_3),(a_3,a_2,a_1,a_0)] * [b_0,b_1,b_2,b_3]$}
July 14, 2014, at 05:46 PM by Massimiliano Vessi -
Changed line 47 from:
{$[ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2)$}
to:
{$[ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2)]$}
July 14, 2014, at 05:45 PM by Massimiliano Vessi -
Added lines 42-47:

....

*'''Prodotto modulare''': si intende il prodoto mariciale fra due numeri a 32bit (cioè costituiti da 4 numeri a 8 bit, messi nella forma:

{$[ (a_0,a_3,a_2,a_1),(a_1,a_0,a_3,a_2)$}
July 14, 2014, at 04:39 PM by Massimiliano Vessi -
Changed lines 40-41 from:
{$ = {a3}*{b3} x^6 + [ ({a3}*{b2}) + ({a2}*{b3}) ] x^5 + [ ({a3} * {b1})  + ( {a2}*{b2} ) + ({a1}*{b3}) ] x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
to:

{$ = {a3}*{b3} x^6 + [ ({a3}*{b2}) + ({a2}*{b3}) ] x^5 + [ ({a3} * {b1})  + ( {a2}*{b2} ) + ({a1}*{b3}) ] x^4 + [({a3}*{b0})  +  ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ] x^3 + [ ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ] x^2  + [({a1}*{b0}) + ({a0}*{b1}) ] x + ({a0}*{b0}) $}
July 14, 2014, at 04:36 PM by Massimiliano Vessi -
Changed line 40 from:
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3})) x^5 + ( ({a3} * {b1})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
to:
{$ = {a3}*{b3} x^6 + [ ({a3}*{b2}) + ({a2}*{b3}) ] x^5 + [ ({a3} * {b1})  + ( {a2}*{b2} ) + ({a1}*{b3}) ] x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
July 12, 2014, at 11:52 PM by 151.24.4.36 -
Changed lines 7-8 from:
Siccome tutto il sistema di lavora con al massimo alla volta 8bit, tutto il sistema deve trasformare le operazioni in modo che i numeri non  superino mai gli 8bit. Tecnicamente di dice che di lavora in un campo finito {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
to:
Siccome tutto il sistema di lavora con al massimo alla volta 8bit, tutto il sistema deve trasformare le operazioni in modo che i numeri non  superino mai gli 8bit. Tecnicamente si dice che di lavora in un [[http://it.wikipedia.org/wiki/Campo_finito | campo finito]] {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
Changed line 40 from:
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3}})*x^5 + ( ({a3} * {b1})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
to:
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3})) x^5 + ( ({a3} * {b1})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
July 11, 2014, at 05:23 PM by Massimiliano Vessi -
Changed lines 39-40 from:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3} * x^3 + {a2} x^2 + {a1} x + {a0}) * ( {b3}  x^3 + {b2} x^2 + {b1} x + {b0}) = $}
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3}})*x^5 + ( ({a3} * {b2})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
to:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3}  x^3 + {a2} x^2 + {a1} x + {a0}) * ( {b3}  x^3 + {b2} x^2 + {b1} x + {b0}) = $}
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3}})*x^5 + ( ({a3} * {b1})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
July 11, 2014, at 05:16 PM by Massimiliano Vessi -
Changed lines 39-40 from:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3} * x^3 + {a2}*x^2 + {a1}*x + {a0}) * ( {b3} * x^3 + {b2}*x^2 + {b1}*x + {b0}) = $}
{$ = {a3}*{b3} *x^3 + (({a3}*{b2})+({a2}{b3}})*x^2 $}
to:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3} * x^3 + {a2} x^2 + {a1} x + {a0}) * ( {b3}   x^3 + {b2} x^2 + {b1} x + {b0}) = $}
{$ = {a3}*{b3} x^6 + (({a3}*{b2})+({a2}{b3}})*x^5 + ( ({a3} * {b2})  + ( {a2}*{b2}) + ({a1}*{b3}) ) x^4 + (({a3}*{b0})  + ( ({a2}*{b1}) + ({a1}*{b2}) +({a0}*{b3})  ) x^3 + ( ({a2}*{b0}) + ({a1}*{b1}) + ({a0}*{b2}) ) x^2  + (({a1}*{b0}) + ({a0}*{b1}) )x + ({a0}*{b0}) $}
July 10, 2014, at 03:15 PM by Massimiliano Vessi -
Changed lines 39-40 from:
{$ {57}{a2}{35}{d3} *  {83}{25}{4c}{5a} = ({57} * x^3 + {a2}*x^2 + {35}*x + {d3}) * ( {83} * x^3 + {25}*x^2 + {4c}*x + {5a})$}
to:
{$ {a3}{a2}{a1}{a0} *  {b3}{b2}{b1}{b0} = ({a3} * x^3 + {a2}*x^2 + {a1}*x + {a0}) * ( {b3} * x^3 + {b2}*x^2 + {b1}*x + {b0}) = $}
{$ = {a3}*{b3} *x^3 + (({a3}*{b2})+({a2}{b3}})*x^2 $}
July 10, 2014, at 03:04 PM by Massimiliano Vessi -
Changed lines 26-27 from:
Usando la notazione esadecimale per rappresentare i bit in maniera piu' stringata abbiamo:
to:
Usando la notazione esadecimale, per rappresentare i bit in maniera piu' stringata, abbiamo:
Changed lines 37-39 from:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit viste qualche paragrafo prima. Esempio:

{$ {57}.{a2}.{35}.{d3} *  {83}.{25}.{4c}.{5a} = ({57} * x^3 + {a2}*x^2 + {35}*x + {d3}) * ( {83} * x^3 + {25}*x^2 + {4c}*x + {5a})$}
to:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit viste qualche paragrafo prima. Esempio in esadecimale:

{$ {57}{a2}{35}{d3} *  {83}{25}{4c}{5a} = ({57} * x^3 + {a2}*x^2 + {35}*x + {d3}) * ( {83} * x^3 + {25}*x^2 + {4c}*x + {5a})$}
July 10, 2014, at 02:59 PM by Massimiliano Vessi -
Changed lines 37-39 from:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit vista qualche praragrafo prima. Esempio:

{$ 00000000.00010001.00100111.0101000110000000.01010001.00110111.01010101 = (00000000 * x^3 +$}
to:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit viste qualche paragrafo prima. Esempio:

{$ {57}.{a2}.{35}.{d3}{83}.{25}.{4c}.{5a} = ({57} * x^3 + {a2}*x^2 + {35}*x + {d3}) * ( {83} * x^3 + {25}*x^2 + {4c}*x + {5a})$}
July 10, 2014, at 02:54 PM by Massimiliano Vessi -
Added lines 25-28:

Usando la notazione esadecimale per rappresentare i bit in maniera piu' stringata abbiamo:

{$ {57} * {83} = {c1}  $}
July 10, 2014, at 02:51 PM by Massimiliano Vessi -
Changed lines 33-35 from:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
to:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]].  Bisogna fare attenzione che i coefficienti dei polinomi a 32 bit sono numeri a 8 bit e quindi il loro prodotto segue le regole dei prodotti a 8 bit vista qualche praragrafo prima. Esempio:

{$ 00000000.00010001.00100111.01010001 *  10000000.01010001.00110111.01010101 = (00000000 * x^3 +$}
July 10, 2014, at 02:31 PM by Massimiliano Vessi -
Added lines 11-12:
!!!Numeri a 8 bit
Changed lines 28-33 from:
to:
!!!Numeri a 32 bit

In certi frangenti si lavora con 4 numeri di 8 bit, che fanno un sistema a 32 bit particolare. Anche qui le formule sono diverse:

*'''Addizione''' è la funzione XOR (bit a bit)
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^4 +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
July 10, 2014, at 02:25 PM by Massimiliano Vessi -
Changed lines 12-13 from:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:
to:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. [[http://www.lezionidimatematica.net/Polinomi/lezioni/poli_lezione_28.htm | La spiegazione della divisione fra polinomi e' qui]]. Esempio:
Added lines 23-26:

*funzione '''xtime()''', serve a moltiplicare un numero per 00000010.

July 10, 2014, at 02:09 PM by Massimiliano Vessi -
Changed lines 7-8 from:
Siccome tutto il sistema di lavora con al massimo 256bit, tutto il sistema deve trasformare le operazioni in modo che non si superino mai i 256bit. Tecnicamente di dice che di lavora in un campo finito {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
to:
Siccome tutto il sistema di lavora con al massimo alla volta 8bit, tutto il sistema deve trasformare le operazioni in modo che i numeri non  superino mai gli 8bit. Tecnicamente di dice che di lavora in un campo finito {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.
Changed lines 20-23 from:
{$ 01010111 * 10000011 = x^7 + x^6 + 1  = 11000001 $}
to:
{$ 01010111 * 10000011 = x^7 + x^6 + 1  = 11000001 $}

Si potevano trovare altre strade per fare una moltiplicazione in un campo finito, ma questo metodo garantisce delle proprieta' che vengono sfruttate dal sistema AES.

July 10, 2014, at 02:05 PM by Massimiliano Vessi -
Changed line 16 from:
{$ ( x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1) : (x^8 + x^4 +x^3 +x +1) =  x^5 + x^3$} con il resto {$ x^7 + x^6 + 1 $}
to:
{$ ( x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1) : (x^8 + x^4 +x^3 +x +1) =  x^5 + x^3$} , con il resto {$ x^7 + x^6 + 1 $}
July 10, 2014, at 02:04 PM by Massimiliano Vessi -
Changed lines 12-16 from:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + X^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:

{$ 01010111 * 10000011 = (x^6 + X^4 + x^2 + x +1) * (x^7 + x +1) = x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1 $}

{$ ( x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1) : (x^8 + X^4 +x^3 +x +1) =  x^5 + x^3$} con il resto {$ x^7 + x^6 + 1 $}
to:
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + x^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:

{$ 01010111 * 10000011 = (x^6 + x^4 + x^2 + x +1) * (x^7 + x +1) = x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1 $}

{$ ( x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1) : (x^8 + x^4 +x^3 +x +1) =  x^5 + x^3$} con il resto {$ x^7 + x^6 + 1 $}
July 10, 2014, at 02:03 PM by Massimiliano Vessi -
Changed lines 14-20 from:
{$ 01010111 * 10000011 = $}
to:
{$ 01010111 * 10000011 = (x^6 + X^4 + x^2 + x +1) * (x^7 + x +1) = x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1 $}

{$ ( x^13 + x^11 + x^9 + x^8 + x^6 + x^5 +x^4 +x^3 +1) : (x^8 + X^4 +x^3 +x +1) =  x^5 + x^3$} con il resto {$ x^7 + x^6 + 1 $}

quindi:

{$ 01010111 * 10000011 = x^7 + x^6 + 1  = 11000001
$}
July 10, 2014, at 01:46 PM by Massimiliano Vessi -
Changed lines 11-14 from:
*Addizione è la funzione XOR (bit a bit)
*Moltiplicazione e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + X^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:

{$ 001+ 101 $}
to:
*'''Addizione''' è la funzione XOR (bit a bit)
*'''Moltiplicazione''' e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + X^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:

{$ 01010111 * 10000011 = $}
July 10, 2014, at 01:40 PM by Massimiliano Vessi -
Changed lines 12-14 from:
*Moltiplicazione e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano e il risultato si divide per modulo 283. Esempio:

{$ 00000101 * 1000000010 = ((x^2 +1) * (x^8 + x )) mod 283 =
$}
to:
*Moltiplicazione e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano, poi si dividono per {$ x^8 + X^4 +x^3 +x +1 $} e si utilizza come risultato il resto della divisione. Esempio:

{$ 001+ 101
$}
July 10, 2014, at 12:17 PM by Massimiliano Vessi -
Added lines 5-14:
!!Termini

Siccome tutto il sistema di lavora con al massimo 256bit, tutto il sistema deve trasformare le operazioni in modo che non si superino mai i 256bit. Tecnicamente di dice che di lavora in un campo finito {$ P_(2^8) $}. Per esempio noi quando facciamo un'addizione tipo 9+3=12 aggiungiamo una cifra al numero, in un campo finito non si posso aggiungere cifre. In un campo finito i numeri non sono su una retta, ma su un cerchio e quindi si può scrivere 9+3=2.

Per questo motivo i termini utilizzati vanno rivisti:

*Addizione è la funzione XOR (bit a bit)
*Moltiplicazione e' una funzione complicatissima, si trasforma il numeri binari in polinomi, si moltiplicano e il risultato si divide per modulo 283. Esempio:

{$ 00000101 * 1000000010 = ((x^2 +1) * (x^8 + x )) mod 283 =  $}
July 10, 2014, at 11:35 AM by Massimiliano Vessi -
Added lines 1-4:
La cifratura attraverso il metodo AES e' di tipo simmetrico.

AES permette di scegliere una chiave (un numero) che puo' essere a scelta dell'utilizzatore o a 128 bit, o 192 bit o 256 bit; per questo motivo si divide in AES-128, AES-192 e AES-256.

HomePage

Guide

Altro

Translate:

Pubblicità:

Licenza Creative Commons
DuckDuckGo

edit SideBar

edit TopNav

Blix theme adapted by David Gilbert, powered by PmWiki