You are on page 1of 9

Come DES funziona in dettaglio

DES un cifrario a blocchi - il che significa che opera su blocchi di testo in chiaro di una certa
dimensione ( 64 - bit) e restituisce i blocchi di testo cifrato della stessa dimensione . Cos DES
risulta in una permutazione tra il 2 ^ 64 possibili disposizioni di 64 bit , ciascuno dei quali pu
essere 0 o 1 . Ogni blocco di 64 bit diviso in due blocchi di 32 bit ciascuno , la met sinistra L e la
met destra R.
Esempio : Sia M il messaggio di testo in chiaro M = 0123456789ABCDEF , dove M in formato
( base 16 ) esadecimale . Riscrittura M in formato binario , si ottiene il blocco di 64 bit di testo :
M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
L = 0000 0001 0010 0011 0100 0101 0110 0111
R = 1000 1001 1010 1011 1100 1101 1110 1111
DES opera su blocchi di 64 bit che utilizzando chiavi di 56 - bit . Le chiavi sono in realt
memorizzate come se fossero di 64 bit , ma ogni ottavo bit della chiave non viene utilizzato (ad
esempio bit numerati 8 , 16 , 24 , 32 , 40 , 48 , 56 , e 64) . Tuttavia , numereremo i bit da 1 a 64 , da
sinistra a destra , con i seguenti calcoli . Ma , come si vedr , gli otto bit appena citati vengono
eliminati quando creiamo le sotto-chiavi .
Esempio : Sia K la chiave esadecimale K = 133457799BBCDFF1 . In binario ( posizione 1 =
0001 , 3 = 0011 , ecc, e vengono raggruppati ogni 8 bit , di cui l' ultimo in ogni gruppo sar
inutilizzato) :
K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
L'algoritmo DES utilizza i seguenti passi :
Passo 1: Creare 16 sotto-chiavi , ognuna dei quali lunga 48 bit .
La chiave a 64 bit viene permutata secondo la seguente tabella , PC - 1 . Poich il primo elemento
nella tabella " 57" , ci significa che il bit 57 della chiave originale K diventa il primo bit della
chiave permutata K + . Il bit 49 della chiave originale diventa il secondo bit della chiave
permutato . Il 4 bit della chiave originale l'ultimo bit della chiave permutato . Nota solo il 56 bit
della chiave originale appare nella chiave permutato .

Esempio : Dalla chiave originale a 64 bit


K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
otteniamo la permutazione a 56 bit

K + = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111


Poi, dividere questa chiave in due met destra e sinistra , C0 e D0 , dove ogni met ha 28 bit .
Esempio : Dalla chiave permutata K + , otteniamo
C0 = 1111000 0110011 0010101 0101111
D0 = 0101010 1011001 1001111 0001111
Con C0 e D0 definiti , ora creiamo sedici blocchi Cn e Dn , 1 < = n < = 16 . Ogni coppia di blocchi
Cn e Dn formato dalla coppia precedente Cn - 1 e Dn - 1 , rispettivamente, per n = 1 , 2 , ... , 16 ,
utilizzando il seguente schema di shift a sinistra del blocco precedente . Per effettuare uno
spostamento a sinistra , spostare ogni bit di una posizione a sinistra , ad eccezione del primo bit ,
che viene ciclato alla fine del blocco .

Questo significa , per esempio , C3 e D3 sono ottenuti da C2 e D2 , rispettivamente , da due shift a


sinistra , e C16 e D16 sono ottenuti da C15 e D15 , rispettivamente , da uno spostamento a sinistra .
In tutti i casi , da un unico spostamento a sinistra si intende una rotazione dei bit di una posizione a
sinistra , in modo che dopo uno spostamento a sinistra i bit delle 28 posizioni sono i bit che in
precedenza erano nelle posizioni 2 , 3, ... , 28 , 1 .
Esempio : Da originale coppia coppia C0 e D0 otteniamo :
C0 = 1111000011001100101010101111
D0 = 0101010101100110011110001111
C1 = 1110000110011001010101011111
D1 = 1010101011001100111100011110
C2 = 1100001100110010101010111111
D2 = 0101010110011001111000111101
C3 = 0000110011001010101011111111
D3 = 0101011001100111100011110101

C4 = 0011001100101010101111111100
D4 = 0101100110011110001111010101
C5 = 1100110010101010111111110000
D5 = 0110011001111000111101010101
C6 = 0011001010101011111111000011
D6 = 1001100111100011110101010101
C7 = 1100101010101111111100001100
D7 = 0110011110001111010101010110
C8 = 0010101010111111110000110011
D8 = 1001111000111101010101011001
C9 = 0101010101111111100001100110
D9 = 0011110001111010101010110011
C10 = 0101010111111110000110011001
D10 = 1111000111101010101011001100
C11 = 0101011111111000011001100101
D11 = 1100011110101010101100110011
C12 = 0101111111100001100110010101
D12 = 0001111010101010110011001111
C13 = 0111111110000110011001010101
D13 = 0111101010101011001100111100
C14 = 1111111000011001100101010101
D14 = 1110101010101100110011110001
C15 = 1111100001100110010101010111
D15 = 1010101010110011001111000111
C16 = 1111000011001100101010101111
D16 = 0101010101100110011110001111
Ora formiamo le chiavi Kn , per 1 < = n < = 16 , applicando la seguente tabella di permutazione per
ciascuna delle coppie concatenati con CnDn . Ogni coppia ha 56 bit , ma PC - 2 utilizza solo 48 di
questi.

Pertanto , il primo bit di Kn il bit 14 di CnDn , il secondo bit il17 , e cos via , e termina con il
48 bit di Kn uguale al bit 32 di CnDn .

Esempio : Per la prima chiave che abbiamo


C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110
che , dopo aver applicato la permutazione PC - 2 , diventa
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
Per le altri chiavi abbiamo che
K2 = 011110 011010 111011 011001 110110 111100 100111 100101
K3 = 010101 011111 110010 001010 010000 101100 111110 011001
K4 = 011100 101010 110111 010110 110110 110011 010100 011101
K5 = 011111 001110 110000 000111 111010 110101 001110 101000
K6 = 011000 111010 010100 111110 010100 000111 101100 101111
K7 = 111011 001000 010010 110111 111101 100001 100010 111100
K8 = 111101 111000 101000 111010 110000 010011 101111 111011
K9 = 111000 001101 101111 101011 111011 011110 011110 000001
K10 = 101100 011111 001101 000111 101110 100100 011001 001111
K11 = 001000 010101 111111 010011 110111 101101 001110 000110
K12 = 011101 010111 000111 110101 100101 000110 011111 101001
K13 = 100101 111100 010111 010001 111110 101011 101001 000001
K14 = 010111 110100 001110 110111 111100 101110 011100 111010
K15 = 101111 111001 000110 001101 001111 010011 111100 001010
K16 = 110010 110011 110110 001011 000011 100001 011111 110101
Questo per quanto riguarda le sotto-chiavi . Ora guardiamo al messaggio stesso .
Fase 2 : Codificare ogni blocco di 64 bit di dati .
Vi una permutazione iniziale IP dei 64 bit dei dati del messaggio M. Questo riordina i bit secondo
la seguente tabella, in cui le voci nella tabella mostrano la nuova disposizione dei bit dal loro ordine
iniziale . Il bit 58 di M diventa il primo bit di IP . Il bit 50 di M diventa il secondo bit di IP . Il 7 bit
M l'ultimo bit di IP .

Esempio applicando la permutazione iniziale al blocco di testo M , dato in precedenza , otteniamo


M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
IP = 1100 1100 0000 0000 1100 1100 1111 1111 1111 0000 1010 1010 1111 0000 1010 1010
Poi dividere il blocco permutato IP in un met sinistra L0 di 32 bit , e in una met destra R0 di 32
bit .
Esempio : Da IP , otteniamo L0 e R0
L0 = 1100 1100 0000 0000 1100 1100 1111 1111
R0 = 1111 0000 1010 1010 1111 0000 1010 1010
Passiamo ora attraverso 16 iterazioni , per 1 < = n < = 16 , utilizzando una funzione f che opera su
due blocchi - un blocco di dati di 32 bit e una chiave Kn di 48 bit - per produrre un blocco di 32 bit .
Con + si intende lo XOR. Poi per n cicli da 1 a 16 si calcola
Ln = Rn - 1
Rn = Ln - 1 + f ( Rn - 1 , Kn )
Ci si traduce in un blocco finale , per n = 16 , composto da L16R16 . Cio, in ogni iterazione ,
prendiamo i 32 bit a destra del risultato precedente e li rendiamo quelli a sinistra del passo corrente.
Per i 32 bit a destra del passo corrente, si fa XOR tra i 32bit a sinistra del passaggio precedente il
risultato della funzione 'f' (funzione Feistel).
Esempio: per n = 1 , abbiamo
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
L1 = R0 = 1111 0000 1010 1010 1111 0000 1010 1010
R1 = L0 + f ( R0 , K1 )
Resta da spiegare come funziona la funzione f . Per calcolare f , prima espandiamo ogni blocco Rn 1 da 32 bit a 48 bit . Questo viene fatto utilizzando una tabella di selezione che ripete alcuni dei bit
di Rn - 1 . Chiameremo l' uso di questa tabella di selezione della funzione E. Cos E(Rn - 1) ha un
blocco in ingresso di 32 bit , e un blocco in uscita di 48 bit .
I 48 bit in uscita, scritti come 8 blocchi di 6 bit ciascuno, sono ottenuti selezionando i bit suoi
ingressi in ordine secondo la seguente tabella :

Cos i primi tre bit di E ( Rn - 1) sono i bit nelle posizioni 32 , 1 e 2 di Rn - 1, mentre gli ultimi 2 bit
di E ( Rn - 1) sono i bit nelle posizioni 32 e 1 .
Esempio : Calcoliamo E ( R0 ) da R0 come segue :
R0 = 1111 0000 1010 1010 1111 0000 1010 1010
E ( R0 ) = 011110 100001 010101 010101 011110 100001 010101 010101
( Si noti che ogni blocco originale di 4 bit stato espanso a un blocco di 6 bit in uscita . )
Avanti nel calcolo f , facciamo lo XOR tra l'uscita E ( Rn - 1 ) con la chiave Kn :
Kn + E ( Rn - 1) .
Esempio : Per K1 , E ( R0 ) , abbiamo
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
E ( R0 ) = 011110 100001 010101 010101 011110 100001 010101 010101
K1 + E ( R0 ) = 011000 010001 011110 111010 100001 100110 010100 100111 .
Non abbiamo ancora finito di calcolare la funzione f . A questo punto abbiamo ampliato Rn - 1 da
32 bit a 48 bit , utilizzando la tabella di selezione , e il risultato XORato con la chiave Kn . Ora
abbiamo 48 bit (otto gruppi di sei bit) . Ora facciamo qualcosa con ogni gruppo di sei bit : li usiamo
come indirizzi nelle tabelle chiamate "S-box" . Ogni gruppo di sei bit ci dar un indirizzo in una
casella diversa S . A tale indirizzo sar un numero a 4 bit . Questo numero 4 bit sostituir i 6 bit
originali. Il risultato che gli otto gruppi di 6 bit vengono trasformati in otto gruppi di 4 bit (le
uscite di 4 - bit dalle S-box) per un totale di 32 bit .
Scrivere il risultato precedente , che di 48 bit , nella forma :
Kn + E ( Rn - 1 ) = B1B2B3B4B5B6B7B8 , dove ogni Bi un gruppo di sei bit . Calcoliamo ora
S1 ( B1 ) S2 ( B2 ) S3 ( B3 ) S4 ( B4 ) S5 ( B5 ) S6 ( B6 ) S7 ( B7 ) S8 ( B8 )
dove Si (Bi) sono ottenute da l'uscita del S-box i- esimo.
In breve, ciascuna delle funzioni S1 , S2 , ... , S8 , prende un blocco di 6 -bit come input e produce
un blocco di 4 bit come output . La tabella per determinare S1 mostrata e spiegata di seguito :

Se S1 la funzione definita in questa tabella e B un blocco di 6 bit , allora S1 ( B ) viene


determinato come segue : Il primo e l'ultimo bit di B rappresentano in base 2 il numero decimale
nell'intervallo da 0 a 3 ( binario 00-11 ) . Chiamiamo questo numero 'i'. I 4 bit nel mezzo di B
rappresentano in base 2 un numero decimale compreso tra 0 e 15 ( binario 0000-1111 ) . Chiamiamo
questo numero 'j' . Ora basta cercare nella tabella il numero nella riga i-esima e colonna j -esima . Si
tratta di un numero compreso tra 0 e 15 ed rappresentato unicamente da un blocco di 4 bit . Tale
blocco l'uscita S1 ( B ) di S1 per l' ingresso B. Ad esempio , per il blocco ingresso B = 011011 il
primo bit " 0 " e l'ultimo bit " 1 " da 01 come riga . Questa la riga 1 . I 4 bit nel mezzo sono"
1101 " . Questo l'equivalente binario del decimale 13 , quindi la colonna il numero di colonna 13
. In fila 1 , e colonna 13 c' 5 . Questo determina l'output ; 5 in binario 0101. Quindi S1 ( 011011 )
= 0101 .
Le tabelle che definiscono le funzioni S1 , ... , S8 sono i seguenti :

Esempio : Per il primo turno , si ottiene come output delle otto caselle S :
K1 + E ( R0 ) = 011000 010001 011110 111010 100001 100110 010100 100111 .
S1 ( B1 ) S2 ( B2 ) S3 ( B3 ) S4 ( B4 ) S5 ( B5 ) S6 ( B6 ) S7 ( B7 ) S8 ( B8 ) = 0101 1100 1000
0010 1011 0101 1001 0111
La fase finale nel calcolo di f di fare una permutazione P dell'uscita S -box per ottenere il valore
finale di f :
f = P ( S1 ( B1 ) S2 ( B2 ) ... S8 ( B8 ) )
La permutazione P viene definite nella seguente tabella. P produce in uscita 32 bit da un ingresso di
32 bit permutando i bit del blocco di input.

Esempio : Dalla uscita delle otto S-box :


S1 ( B1 ) S2 ( B2 ) S3 ( B3 ) S4 ( B4 ) S5 ( B5 ) S6 ( B6 ) S7 ( B7 ) S8 ( B8 ) = 0101 1100 1000
0010 1011 0101 1001 0111
otteniamo
f = 0010 0011 0100 1010 1010 1001 1011 1011
R1 = L0 + f ( R0 , K1 )

= 1100 1100 0000 0000 1100 1100 1111 1111


+ 0010 0011 0100 1010 1010 1001 1011 1011
= 1110 1111 0100 1010 0110 0101 0100 0100
Nel prossimo turno , avremo L2 = R1 , che il blocco che abbiamo appena calcolato , e quindi
dobbiamo calcolare R2 = L1 + f ( R1 , K2 ) , e cos via per 16 giri . Alla fine del sedicesimo turno
abbiamo i blocchi L16 e R16 . Dobbiamo poi invertire l'ordine dei due blocchi nel blocco 64 bit
R16L16
e applicare una permutazione finale IP - 1 come definito nella tabella seguente :

Cio , l'uscita dell'algoritmo ha il bit 40 del pre-output blocco come primo bit, il bit 8 come secondo
bit , e cos via , fino a 25 bit del blocco pre-output che l'ultimo bit dell'uscita .
Esempio : Se noi trattiamo tutti i 16 blocchi utilizzando il metodo definito in precedenza , si
ottiene , al 16 turno:
L16 = 0100 0011 0100 0010 0011 0010 0011 0100
R16 = 0000 1010 0100 1100 1101 1001 1001 0101
Invertiamo l'ordine di questi due blocchi e applichiamo la permutazione finale
R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100
IP -1 = 10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101
che in formato esadecimale
85E813540F0AB405 .
Questa la forma cifrata di M = 0123456789ABCDEF : vale a dire , C = 85E813540F0AB405 .
La decriptazione semplicemente l'inverso di crittografia , seguendo la stessa procedura come
sopra , ma invertendo l'ordine in cui vengono applicate le sotto-chiavi.