Sicurezza dei Sistemi Informatici II

C.d.L. in Informatica Applicata
Università degli Studi di Catania

Emilio Pavia
Matr. A40/000107

Vulnerabilità del protocollo WEP
 Colui al quale confidate il vostro segreto, diventa padrone della vostra libertà.
(François de La Rochefoucauld)

Introduzione

Negli   ultimi   anni   la   mobilità   è   stata   la   protagonista   indiscussa   nello   sviluppo   delle   tecnologie 
informatiche   e  delle telecomunicazioni;  basti  pensare alla  diffusione  dei  telefoni cellulari  e   dei 
computer portatili. Inoltre nell'era di Internet la condivisione delle informazioni ha assunto un ruolo 
centrale,   sia   nell'ambito   economico­lavorativo,   che   in   quello   socio­culturale.   Nonostante   le   reti 
informatiche   esistano   da   diversi   anni,   l'avvento   dei   dispositivi   portatili   ha   messo   un   crisi   le 
tradizionali   tecnologie   di   rete,   le   quali   presuppongono   una   postazione   fissa   all'interno   di   una 
struttura   preventivamente   cablata.   Per   superare   questo   limite   l'industria   ha   presentato   diverse 
soluzioni per la realizzazione di reti senza fili che alla fine hanno portato alla definizione dello 
standard IEEE 802.11 meglio noto con il nome di WLAN o WiFi.
Le wireless LAN hanno il grande vantaggio di offrire connettività a tutti i dispositivi che si trovano 
nel raggio d'azione delle onde radio (che nel caso di reti 802.11 è comunque limitato ad una decina 
di metri) indipendentemente dalla loro posizione. Tuttavia questa rappresenta anche la più grande 
debolezza   di   questa   tecnologia   poiché   espone   più   facilmente   gli   utenti   a   delle   violazioni   nella 
riservatezza delle comunicazioni da parte di attaccanti esterni. Infatti, mentre nelle LAN tradizionali 
è possibile impedire fisicamente l'accesso al mezzo trasmissivo, nel caso di reti wireless chiunque si 
trovi nelle vicinanze può intercettare le onde radio attraverso un'antenna.
Per rendere più sicure le comunicazioni che avvengono tramite reti wireless sono stati ideati dei 
protocolli   di   sicurezza.   L'idea   è   semplice:   utilizzare   dei   sistemi   crittografici   per   rendere 
indecifrabile ai non autorizzati ciò che per la natura stessa del mezzo trasmissivo non può essere 
nascosto. Il primo tentativo ha portato alla definizione del sistema WEP (Wired Equivalent Privacy) 
incluso nello standard IEEE 802.11 e ratificato nel 1999. Tuttavia già nel 2001 Fluher, Mantin e 
Shamir presentarono un attacco al cifrario RC4 utilizzato dal WEP. Per porre rimedio a questa falla 
di sicurezza nacque un nuovo sistema che venne incluso nello standard IEEE 802.11i e ratificato nel 
2004. Questo nuovo sistema è stato implementato in parte nel protocollo WPA (Wi­Fi Protected 
Access) e completamente nella sua versione successiva WPA2.
Nonostante   ne  sia  stata  dimostrata  l'inadeguatezza  e  siano state  sviluppate  delle  alternative  più 
sicure, il WEP è ancora oggi il sistema di protezione più utilizzato [1]. Questo può essere attribuito 
sia all'incompetenza degli utenti che nella maggior parte dei casi sono ignari dei rischi che corrono, 
sia al fatto che non si vuole investire per acquistare i dispositivi conformi al nuovo standard.

Regione WEP WPA WPA2

Londra 76 20 4
Seattle 85 14 1
Tabella 1. Percentuale dei sistemi di sicurezza utilizzati nelle reti wireless protette.

Nella prossima sezione verranno analizzati i principi che stanno alla base del WEP e del cifrario in 
esso utilizzato: RC4. Nelle due successive invece verranno trattati i due attacchi più importanti 
messi   in   atto   contro   il   cifrario   RC4   (Fluhrer,   Mantin   e   Shamir,   e   Klein),   e   ne   verrà   discussa 
l'applicabilità al protocollo WEP. Infine verrà introdotto l'attacco attualmente più performante (in 
termini di tempo di esecuzione) contro il protocollo WEP e la tecnica dell'ARP re­injection.
Il presente lavoro non ha la pretesa di essere esaustivo sugli aspetti crittografici dei vari attacchi (per 
eventuali approfondimenti si rimanda alla lettura dei riferimenti bibliografici). Tuttavia si vuole dare 
un'idea di quali siano le debolezze intrinseche di RC4 e del WEP, e in che modo sia possibile 
sfruttarle.

RC4 e WEP

Alla base del protocollo di sicurezza WEP c'è RC4, uno stream cipher ideato da Ron Rivest nel 1987 
e tenuto segreto fino al 1994, anno in cui venne pubblicato su internet in forma anonima. Uno 
stream cipher è un cifrario simmetrico in cui i byte del testo in chiaro vengono combinati (con una 
operazione di OR esclusivo) con una sequenza pseudo­casuale di byte generata dal cifrario.
RC4 si compone quindi di due parti: la prima prende come parametro una chiave k (che farà da seed 
per   il   generatore)   e   inizializza   il   cifrario;   la   seconda   genera   pseudo­casualmente   un   byte 
modificando lo stato interno del cifrario.

RC4KeySetup(K) RC4GeneratePseudorandomByte()
for i = 0 to 255 do i = i + 1 mod 256
S[i] = i j = j + S[i] mod 256
j = 0 swap(S[i], S[j])
for i = 0 to 255 do return S[S[i] + S[j] mod 256]
j = j + S[i] + K[i mod len(K)] mod 256
swap(S[i], S[j])
i = j = 0

Nel dettaglio lo stato del cifrario è dato da un array S e da due indici i e j. L'inizializzazione crea in 
funzione della chiave k una permutazione S della sequenza ordinata {0,1,...,255} e imposta a 0 gli 
indici i e j. Il generatore incrementa di volta in volta l'indice i di 1 e calcola j in funzione di S[i], 
scambia in S i valori alle posizioni i e j, quindi restituisce il valore S[S[i] + S[j]]. Tutte le operazioni 
descritte vengono ovviamente eseguite in mod N (dove N è la dimensione dell'array S, tipicamente 
256).

Il protocollo WEP funziona nel modo seguente: tutti gli host della rete wireless condividono una 
chiave segreta k di 104 bit (in una prima versione era di 40 bit a causa delle restrizioni imposte dal 
governo   degli  Stati Uniti  sui  sistemi  crittografici)  usata  per cifrare e  decifrare  il  contenuto  dei 
pacchetti.
Il protocollo prende il  plaintext  M  che deve essere spedito, ne calcola il checksum  c(M) (usato 
solamente   per   rilevare   eventuali   errori   di   trasmissione)   e   concatena   le   due   quantità,   ottenendo 
M∙c(M). Quindi genera un vettore di inizializzazione IV (“unico”1 per ogni pacchetto) di 24 bit e gli 
concatena la chiave  k, ottenendo la quantità  IV∙k  di 128 bit. Questa quantità viene utilizzata per 

1 Molto spesso si tratta di un semplice contatore che potrebbe essere resettato (ad esempio) a seguito di un crash o 
ogni  volta  che  viene  reimpostata  una  connessione.  L'unicità  non è  intesa  come  assenza di   duplicati,  ma  come 
condizione per cui viene generato un nuovo IV per ogni pacchetto.
inizializzare il cifrario RC4 e il crittotesto viene ottenuto facendo l'OR esclusivo del messaggio con 
i byte generati dal cifrario:

C = M⋅c M XOR RC4IV⋅k 

Infine nel pacchetto viene spedita la quantità  IV∙C. Notare che è necessario inviare in chiaro il 
vettore di inizializzazione per permettere al ricevente di inizializzare il cifrario e quindi di decifrare 
il messaggio eseguendo la stessa procedura.

L'attacco di Fluhrer, Mantin e Shamir

Fluhrer, Mantin e Shamir hanno descritto un attacco passivo contro il cifrario RC4 [2]. Essi hanno 
mostrato   come   sia   possibile   ricavare   l'intera   chiave   utilizzata   per   inizializzare   il   cifrario 
conoscendone soltanto una parte. Il WEP è vulnerabile a quest'attacco in quanto una porzione della 
chiave (il vettore di inizializzazione) è spedita in chiaro al destinatario.
In   particolare  questo attacco per ogni  IV∙k  sfrutta soltanto il primo byte di output del cifrario: 
analizzando il codice di  RC4GeneratePseudorandomByte() mostrato precedentemente si nota  che il 
primo byte generato   dipende solo da tre valori: prima della chiamata alla funzione sia  i  che  j 
valgono 0, quindi dopo la prima esecuzione si avrà i = 1, j = S[1] e il valore ritornato sarà S[S[1] + 
S[S[1]]].

1 X X+Y
X Y Z
Figura 1. Rappresentazione del vettore di stato S; Z è il primo byte di output.

Inoltre è stato dimostrato dagli autori che se in fase di inizializzazione l'algoritmo raggiunge uno 
stato in cui i è maggiore o uguale a 1, a X e a X+Y, allora con una probabilità maggiore di e­3 ≈ 0.05 
nessuno di questi tre elementi prenderà parte ad ulteriori scambi. Gli autori definiscono questa 
situazione una resolved condition.
Sebbene sembri improbabile, è abbastanza semplice procurarsi il primo byte di output del cifrario. 
Le reti wireless infatti utilizzano il protocollo LLC [3] (definito dallo standard IEEE 802.2) a livello 
data link, che prevede l'incapsulamento dei pacchetti IP in un ulteriore frame con un header SNAP 
(subnetwork access protocol) che ha sempre il valore 0xAA come primo byte. Facendo quindi uno 
XOR tra il primo byte del crittotesto e il valore 0xAA si ottiene il primo byte di output del cifrario. 
Inoltre,   poiché   il   vettore   di  inizializzazione   è  per   packet,  il   cifrario   verrà   inizializzato  ad  ogni 
pacchetto inviato, il quale quindi conterrà sempre il primo byte generato da RC4.
Nell'articolo   vengono   definiti  deboli  quegli  IV  che   lasciano   trasparire   informazioni   utili   ad 
individuare parte della chiave contenuta nel primo byte di output del cifrario. Essi sono nella forma 
(A+3,  N­1,  X)2,   dove  A  è   il   byte   della   chiave   segreta   che   si   vuole   individuare,  N  è   il   modulo 
utilizzato dall'algoritmo (nel caso del WEP uguale a 256) e X è un valore arbitrario compreso tra 0 e 
255.

2 In realtà anche altri IV che non sono in questa forma possono essere utilizzati ai fini dell'attacco. E' sufficiente per 
ogni IV ricevuto effettuare un test per verificare se quel valore determina una resolved condition.
Sia K la chiave in cui i primi 3 byte sono formati dall'IV e i restanti dalla chiave segreta. Supposto 
che   si   conoscano   i   primi  A  byte   della   chiave   segreta   (con  A  inizialmente   uguale   a   0),   ovvero 
K[3]...K[A+2],   si   vuole   individuare   il   valore  K[A+3].   Vediamo   come   si   comporta   l'algoritmo 
RC4KeySetup()3 con un IV del tipo (A+3, N­1, X): alla prima iterazione del secondo ciclo vengono 
impostati i = 0 e j = K[0] e viene fatto lo swap dei valori in S alle posizioni i e j.

0 1 2 3 A+3
A+3 N­1 X k[3] k[A+3]
i0 j0
A+3 1 2 0
Figura 2. Sopra è rappresentata la chiave di inizializzazione K, mentre sotto è rappresentata la 
permutazione S dopo la prima iterazione del ciclo for nella funzione di inizializzazione.

All'iterazione successiva i viene incrementato di 1, mentre

j = K [0]  S[1]  K [1] = A3  1  N−1 = A3

e quindi viene fatto lo swap tra S[1] e S[A+3].

0 1 2 3 A+3
A+3 N­1 X k[3] k[A+3]
i1 j1
A+3 0 2 1
Figura 3. Sopra è rappresentata ancora la chiave di inizializzazione k, mentre sotto è rappresentata 
la permutazione S dopo la seconda iterazione del ciclo for.

Da   questo   punto   in   poi   l'algoritmo   di   inizializzazione   proseguirà   differentemente   in   base   al 

particolare IV in quanto i verrà ancora incrementato di 1 e j dipenderà dal valore X:

j = A3  S [2] K [2 ] = A3  2  X

Tuttavia l'attaccante conosce  X  (perché fa parte del vettore di inizializzazione) e conosce anche i 

valori k[3]...k[A+2] (per l'ipotesi sopra formulata), quindi eseguendo l'algoritmo ne può prevedere il 
comportamento fino al passo  A+3. A questo punto l'attaccante conoscerà il valore  jA+2  e il valore 
della permutazione  SA+2. Se i primi due valori di  S  saranno diversi da  A+3 e 0 (cioè se sono stati 
coinvolti in ulteriori swap) allora l'attaccante scarterà quel pacchetto e ne proverà un altro, altrimenti 
si avrà:

j A3 = j A2  S A2 [ A3]  K [ A3]

3 Anche se non specificato d'ora in avanti tutte le operazioni verranno considerate in modulo N.
ovvero

K [ A3 ] = j A3 − j A2 − S A2 [ A3]

Poiché i e j verranno scambiati in SA+2, si avrà che SA+3[A+3] = SA+2[jA+3], ovvero jA+3 sarà la posizione 
in  SA+2  in  cui appare il valore  SA+3[A+3].  Inoltre  iA+3  (uguale a  A+3)  avrà raggiunto la  resolved  
condition  (con riferimento alla figura 1 abbiamo infatti  X  = 0 e  X+Y  =  A+3) e quindi, con una 
probabilità p > e­3  ≈  0.05, SA+3[A+3] sarà proprio il primo byte di output del cifrario. Analizzando 
circa 60 IV questa probabilità sale già a 0.5. A questo punto si hanno tutti gli elementi per calcolare 
k[A+3], e iterando questo procedimento per tutti i valori di A l'attaccante è in grado di ricostruire 
l'intera chiave segreta.

L'attacco di Klein

Per recuperare un'intera chiave con l'attacco precedentemente descritto occorrono da 1.000.000 a 
5.000.000 di pacchetti [4], in quanto non tutti i pacchetti contengono un  IV   che determina una 
resolved condition. Un netto miglioramento si è avuto a seguito degli studi di Andreas Klein su RC4 
[5]. Egli ha dimostrato l'esistenza di una forte correlazione tra i valori osservabili i e S[S[i]+S[j]] e i 
valori j, S[i] e S[j] relativi allo stato interno del cifrario. Per semplicità di notazione indichiamo con 
k il valore S[i]+S[j], cosicché l'output del cifrario sarà dato dal valore S[k], mentre con K indichiamo 
la chiave di inizializzazione del cifrario.

Klein ha dimostrato4 che fissato un valore i minore di n:

2
P S [ j ]  S[k ] ≡n i =
n

Per   capire   come   sfruttare   questa   probabilità   analizziamo   i   primi   due   passi   dell'algoritmo   di 
inizializzazione di RC4. Inizialmente S[i] = i per ogni valore di i; al primo passo dell'algoritmo si ha 
i = 0 e j = K[0], e lo scambio di S[i] con S[j].

i0 K[0]
K[0] 1 2 0
Figura 4. Lo stato dell'array S dopo il primo ciclo dell'algoritmo di inizializzazione.

Al secondo passo j viene incrementato della quantità S[1] + K[1], e viene fatto lo scambio tra S[1] e 
S[j]. Poiché inizialmente S[i] = i, possiamo affermare che con il secondo scambio (dato che fino a 
quel momento sono stati cambiati solo due valori in S0) otteniamo S[1] = S[j] = j = K[0] + 1 + K[1], 
tranne nei seguenti casi:

a) K[0] = 1 e K[1] = 0
In questo caso al primo passo j = 1, quindi viene fatto lo scambio tra S[0] e S[1], ovvero si 
4 La dimostrazione prende il nome di Teorema 1 nell'articolo originale.
 avrà S[0] = 1 e S[1] = 0. Al secondo passo j = K[0] + S[1] + K[1] = 1 + 0 + 0 = 1, quindi 
dopo lo scambio si avrà S[1] = S[j] = S[1] = 0.
b) K[0] = 1 e K[1] != 0, n­1
Dopo il primo passo ci troviamo nello stesso stato del caso precedente. Al secondo passo 
però j = K[0] + S[1] + K[1] = K[0] + K[1], e poiché questa quantità è diversa da 0 e da 1 
avremo S[1] = S[j] = K[0] + K[1] (perché tutti per tutti i valori di j > 1 S[j] = j).
c) K[0] != 1 e K[1] = n­1
In questo caso dopo il primo passo avremo S[0] = K[0], S[K[0]] = 0 e S[1] = 1. Al secondo 
passo j = K[0] + S[1] + K[1] = K[0] + 1 + n­1 = K[0] (perché operiamo in modulo n), e 
quindi S[1] = S[j] = S[K[0]] = 0.
d) K[0] != 1 e K[0] + K[1] = n­1
Dopo il primo passo siamo nella stessa configurazione del caso precedente. Al secondo 
passo j = K[0] + S[1] + K[1] = K[0] + 1 + K[1] = n­1+1 = 0, e quindi S[1] = S[j] = S[0] = 
K[0]5.

In ogni caso il valore di S[1] dopo il secondo passaggio è una funzione di K[0] e K[1]. Inoltre Klein 
ha dimostrato che S[1] non verrà modificato nei passi successivi dell'inizializzazione (ovvero che j 
non raggiungerà mai più il valore 1) con probabilità ≈ 1/e.
Quando viene generato il primo byte dal cifrario abbiamo i = 1, j = S[1] e lo scambio tra S[1] e S[j]. 
Visto che noi siamo interessati a S[1] (per trovare K[1]) dobbiamo recuperare il valore di S[j]. Allo 
scopo ci viene in aiuto il teorema 1 il quale afferma che con probabilità pari a 2/n, S[j] = 1 – S[k], 
dove S[k] è il primo byte di output di RC4. Mettendo assieme le due probabilità otteniamo:

1.36
P S [1] = 1 −S [k ] ≈
n

La probabilità che S[1] sia un altro valore è minore di 1/n (per ogni valore degli altri n­1). L'attacco 
quindi avviene nel seguente modo: per un certo numero di pacchetti con IV distinti viene catturato il 
primo byte di output del cifrario S[k] e viene calcolato S[1] = 1 – S[k]. Di tutti i possibili n valori 
che otteniamo, quello che si ripeterà con più frequenza sarà il valore corretto. La complessità di 
questa procedura è stata calcolata da Klein ed è   ≈  17nln(n) che (per  n  = 256) equivale a  circa 
25.000 pacchetti (di gran lunga inferiore alla complessità dell'attacco di FMS).
Si noti che in questo attacco è previsto che l'attaccante indovini K[0] affinché possa recuperare K[1] 
(infatti  S[1]   è   funzione   di   entrambi).  Nel   caso   del   WEP   però   questa   condizione   è   facilmente 
raggiungibile in quanto i primi 3 byte della chiave vengono sempre mandati in chiaro.

Estendiamo adesso l'attacco a tutti i byte della chiave: dopo aver ottenuto K[0] e K[1] supponiamo di 
voler recuperare K[2]6. Analogamente a prima abbiamo che nella fase di inizializzazione del cifrario 
S[2] =  f(K[0],  K[1],  K[2]) e che con probabilità ≈  1/e  non verrà più modificato negli n – 3 passi 

5 L'articolo originale riporta a pagina 6 punto  d  S[1] =  K[1], ma seguendo la logica dell'algoritmo sembra essere 

un'inconguenza.
6 In realtà nel caso del WEP anche K[2] è già disponibile, me per analogia questo ragionamento può essere esteso a 
tutti i K[i].
successivi. Osservando il secondo byte di output del generatore (grazie al teorema 1) possiamo 
procurarci S[j], che al secondo passo sarà uguale a S[2] e quindi, grazie a f (poiché abbiamo già i 
primi   due   byte   della   chiave)   possiamo   calcolare   K[2].   Iterando   questo   procedimento   possiamo 
recuperare l'intera chiave K con una complessità totale pari a O((k­1)nln(n)).

L'attacco di Tews, Weinmann e Pyshkin

Con l'attacco di Klein abbiamo visto come sia possibile ricavare in maniera iterativa l'intera chiave 
segreta. Lo svantaggio di questo approccio però è che se il byte  K[i] che abbiamo recuperato è 
sbagliato,   tutti   gli   gli   altri  K[j]   (j  >  i)   saranno   errati   e   devono   quindi   essere   ricalcolati.   Tews, 
Weinmann e Pyshkin hanno presentato un attacco che permette di ricavare ogni byte della chiave 
indipendentemente dagli altri [6].
Con Sk viene indicato lo stato dell'array S dopo k iterazioni dell'algoritmo RC4. Analogamente jk è il 
valore della variabile j dopo k iterazioni. Con S­1[j] si indica la posizione in S in cui si trova il valore 
j, ovvero se S[i] = j allora S­1[j] = i. Infine con X indichiamo l'output del generatore.
Facendo delle sostituzioni e sviluppando la formula ottenuta da Klein, gli autori di questo attacco 
hanno determinato la seguente formula:

i 3
σ i ≈n S −1
3i
[3i− X [2i ]] −  j 3 ∑ Sl [l ] = A i
l =3

i 3

dove σ i = ∑ K [ l] ovvero la somma dei primi  i  byte della chiave segreta (i primi 3 byte di  K 

l =3

sono l'IV). La probabilità che questo valore trovato sia quello corretto (come dimostrato da Klein) 
abbiamo visto essere  ≈  1.36/n. Come si può notare però  σi  dipende  dai  valori  S3, ...,  Si+3.   Tews, 
Weinmann e Pyshkin hanno dimostrato che sostituendo ogni occorrenza di S con S3 la probabilità di 
prendere   il   valore   corretto   diminuisce   meno   dello   0.2%   rispetto   a   quella   originale.   Questa 
approssimazione ha però il vantaggio di portare alla seguente:

i3
σ i ≈n S−1
3
[3i−X [2i]] −  j 3 ∑ S3 [l] = Ai
l=3

Come si può notare adesso σi dipende solamente da S3, il quale a sua volta dipende solamente da 
K[0],  K[1]   e  K[2]  che nel  caso del WEP  sono valori  spediti in chiaro  e  quindi a disposizione 
dell'attaccante senza alcuno sforzo.

L'attacco avviene nel seguente modo: per ogni σi viene calcolato Ai con la formula appena descritta. 
Ogni volta che troviamo il valore Ai diremo che esso ha ricevuto un voto. In tabelle separate (una per 
ogni σi ) vengono conservati tutti i valori calcolati, e alla fine del processo come valore corretto di 
σi   verrà preso quello che ha ottenuto il maggior numero di voti. Infine verrà calcolato K[3] = σ0 e 
K[i+3]   =    σi  –  σi­1    (i  >   3).   E'   necessario   fare   un'osservazione:   la   formula   appena   descritta 
presuppone la conoscenza dei primi 16 byte (per tutti i 128 bit della chiave) di output del cifrario (il 
vettore X), il che equivale a conoscere i primi 18 byte del plaintext del pacchetto per poter fare lo 
XOR con il crittotesto. Questo attacco non è quindi applicabile a tutti i pacchetti, ma solo a quelli 
con un determinato header noto, come ad esempio i pacchetti del protocollo ARP (come spiegato 
nella sezione successiva).

I risultati sperimentali forniti dagli autori di quest'attacco mostrano come con soli 40.000 pacchetti 
sia possibile raggiungere un tasso di successo nel ritrovamento della chiave del 50%.

Incrementare il traffico dei pacchetti utilizzabili

Per incrementare il traffico dei pacchetti da sfruttare nell'attacco, Tews, Weinmann e Pyshkin hanno 
proposto  la tecnica dell'ARP re­injection. Quando  un host A  vuole mandare un messaggio  a  B 
specifica nel pacchetto in uscita l'indirizzo IP di quest'ultimo. Tuttavia gli indirizzi IP hanno senso 
soltanto a livello network, quindi affinché il frame ethernet possa raggiungere lo strato data link del 
destinatario è necessario conoscere il suo indirizzo fisico (detto anche MAC address). A tale scopo è 
stato   ideato   il   protocollo  ARP  (Address   Resolution   Protocol):   quando   un   host   vuole   conoscere 
l'indirizzo   fisico   di   un   altro   host   manda   in   broadcast   a   tutta   la   sottorete   una   ARP  request  
specificando l'indirizzo IP del destinatario e il proprio indirizzo fisico. Tutti gli host ascolteranno 
questa richiesta ma soltanto l'host con l'indirizzo IP specificato invierà una ARP  response  con il 
proprio   indirizzo   fisico.   Poiché   nella   request   è   già   incluso   l'indirizzo   fisico   del   mittente,   il 
destinatario della richiesta avrà tutte le informazioni necessarie per inviare la propria risposta.
Sia le request che le response ARP sono dei pacchetti di dimensione fissa, e quindi sono facilmente 
riconoscibili nel traffico in quanto il WEP non nasconde le dimensioni originali dei pacchetti. I 
pacchetti ARP hanno un header LLC (Logical Link Control) fisso di 8 byte uguale a “AA AA 03 
00 00 00 08 06” e i primi 8 byte del payload sono uguali a “00 01 08 00 06 04 00 
01” per le richieste e “00 01 08 00 06 04 00 02” per le risposte (cambia solo l'ultimo 
byte). Inoltre poiché WEP non nasconde l'indirizzo fisico del destinatario e facile distinguere le 
richieste (mandate in broadcast) dalle risposte (mandate in unicast), quindi è possibile riconoscere 
tutti i pacchetti ARP in transito nella sottorete e di questi se ne conoscono i primi 16 byte del 
plaintext.
In definitiva catturando ogni pacchetto ARP e facendo lo XOR tra i primi 16 byte del pacchetto e 
questi valori noti si hanno a disposizione i primi 16 byte generati dal cifrario. In più è disponibile il 
vettore di inizializzazione perché è mandato in chiaro.

L'ARP re­injection consiste nel rispedire tutte le richieste ARP così come sono state intercettate. 
Ogni re­injection generalmente produce 3 nuovi pacchetti a causa dei relay effettuati dall'access 
point,   e   poiché  ognuno  di   essi   ha  un  vettore  di  inizializzazione  diverso  il   numero  di   pacchetti 
utilizzabili   ai   fini   dell'attacco   aumenta   considerevolmente.   Tuttavia   questa   tecnica   trasforma 
l'attacco da passivo ad attivo rendendo possibile l'utilizzo di sistemi anti intrusione.
Implementazioni

NOTA
Gli strumenti descritti in questa sezione sono stati inseriti come esempi di implementazione degli 
attacchi analizzati finora, e hanno un fine esclusivamente didattico. Essi non devono in alcun modo 
essere utilizzati per violare reti wireless senza autorizzazione.

Aircrack­ng (http://www.aircrack­ng.org) è una raccolta di strumenti utili per recuperare le chiavi 
di   cifratura   delle   reti   protette   con   i   protocolli   di   sicurezza   WEP/WPA.   E'   multipiattaforma 
(Unix/Linux, Windows, Mac OS X) ed è rilasciato con licenza GNU GPL 2. Tuttavia per poter 
essere utilizzato occorre avere una scheda di rete in grado di mettersi in modalità passiva (detta 
anche  monitor mode) per catturare il traffico e in grado da fare l'inject dei pacchetti qualora si 
volesse   utilizzare   questa   tecnica   (l'elenco   delle   schede   di   rete   compatibili   è   reperibile   nel   sito 
internet del progetto).

Questo prodotto comprende una serie di strumenti che è possibile utilizzare per eseguire i  vari 
attacchi:

● Airmon­ng: questo script viene utilizzato per attivare la modalità monitor in una scheda di 
rete compatibile.

utilizzo: airmon-ng <start|stop> <interface> [channel]

Tra i parametri si può specificare se attivare o disattivare la modalità monitor, l'interfaccia di 
rete da utilizzare ed eventualmente il canale su cui sintonizzarsi.

● Airodump­ng: questo tool viene utilizzato per catturare i frame 802.11 e salvare il risultato 
all'interno di un file.

utilizzo: airodump-ng <options> <interface>[,<interface>,...]

E' possibile specificare più interfacce di rete da cui intercettare i pacchetti, mentre tra le 
opzioni è possibile specificare:

--ivs
Per catturare solamente i vettori di inizializzazione
--netmask <netmask>
Per catturare solamente i pacchetti relativi ad una particolare sottorete
--bssid <bssid>
Per catturare solamente i pacchetti relativi alla rete con un particolare BSSID
--encrypt <suite>
Per catturare solamente i pacchetti relativi alle reti che utilizzano una particolare 
suite crittografica

● Aircrack­ng: questo tool utilizza i pacchetti catturati da Airodump per recuperare le chiavi. 
 Come   attacco   predefinito   utilizza   il   PTW   (Pyshkin,   Tews,   Weinmann),   ma   è   possibile 
selezionare   anche   altri   attacchi   tra   cui   il   FMS   (Fluhrer,   Mantin,   Shamir)   o   quello   a 
dizionario.   Per   avere   ulteriori   dettagli   sull'utilizzo   di   questo   tool   e   sulle   opzioni   che   è 
possibili specificare si consulti la relativa pagina di manuale.

Quello che si ottiene eseguendo il programma è la seguente schermata (per brevità viene 
considerato un esempio in cui viene attaccata una chiave WEP da 40 bit):

Aircrack-ng 0.9

[00:01:18] Tested 0/140000 keys (got 30680 IVs)

KB depth byte(vote)
0 0/ 1 12( 170) 35( 152) AA( 146) 17( 145) 86( 143) F0( 143) AE( 142) C5( 142) D4( 142) 50( 140)
1 0/ 1 34( 163) BB( 160) CF( 147) 59( 146) 39( 143) 47( 142) 42( 139) 3D( 137) 7F( 137) 18( 136)
2 0/ 1 56( 162) E9( 147) 1E( 146) 32( 146) 6E( 145) 79( 143) E7( 142) EB( 142) 75( 141) 31( 140)
3 0/ 1 78( 158) 13( 156) 01( 152) 5F( 151) 28( 149) 59( 145) FC( 145) 7E( 143) 76( 142) 92( 142)
4 0/ 1 90( 183) 8B( 156) D7( 148) E0( 146) 18( 145) 33( 145) 96( 144) 2B( 143) 88( 143) 41( 141)

KEY FOUND! [ 12:34:56:78:90 ]

Decrypted correctly: 100%

Nella colonna di sinistra sono elencati i byte della chiave segreta a cui si riferisce la riga. 
Nella matrice di destra sono elencati per ogni riga i candidati per quel particolare byte della 
chiave, ordinati per voto.

● Aireplay­ng: questo tool può essere utilizzato per fare l'inject dei pacchetti all'interno di una 
sottorete (necessita una scheda di rete compatibile).
Bibliografia

1. Andrea Bittau, Mark Handley, and Joshua Lackey. The final nail in WEP's coffin. In IEEE  
Symposium on Security and Privacy, pages 286­400. IEEE Computer Society, 2006.
2. Scott R. Fluhrer, Itsik Mantin and Adi Shamir. Weakness in the key scheduling algorithm of 
RC4. In Serge Vaudenay and Amr M. Youssef,  editors,  Selected Areas in Cryptography  
2001, volume 2259 of Lecture Notes in Computer Science, pages 1­24. Springer, 2001.
3. Andrew S. Tanenbaum. Reti di calcolatori. Quarta edizione. Pearson – Prentice Hall, 2003.
4. Adam   Stubblefield,   John   Ioannidis   and   Aviel   D.   Rubin.   A   key   recovery   attack   on   the 
802.11b wired equivalent protocol (WEP).  ACM Transactions on Information and System  
Security, 7(2):319­332, May 2004.
5. Andreas   Klein.   Attacks   on   the   RC4   stream   cipher.  submitted   to   Designs,   Codes   and  
Cryptography, 2007.
6. Erik Tews, Ralf­Philipp Weinmann, and Andrei Pyshkin. Breaking 104 bit WEP in less than 
60 seconds.