Alice AGPF: l’algoritmo!

Ricordiamo che l’accesso abusivo ad un sistema informatico o telematico è un reato perseguibile a termine di legge (art. 615-ter c.p.). Inoltre ricordiamo che la detenzione e la diffusione abusiva di codici di accesso a sistemi informatici o telematici è un reato penale perseguibile secondo
la legge 615-quater c.p.

Pertanto l’utilizzo di quanto esposto è da riferirsi a un test di sicurezza sulla propria rete o su una rete la quale il proprietario abbia espressamente dato il libero consenso al fine di giudicarne la sicurezza e porre rimedio ad eventuali vulnerabilità.

Gli Autori di questo Blog non potranno essere ritenuti responsabili di eventuali violazioni derivanti da un uso proprio o improprio delle tecniche esposte in questo articolo aventi uno scopo prettamente informativo e didattico. Qualsiasi implementazione dell’algoritmo di seguito riportato è illegale secondo gli articoli sopracitati.

Premessa

Dopo il precedente articolo abbiamo deciso di espandere le nostre ricerche verso altri tipi di router. Quello che andrete a leggere fra poco tratta di un modello molto diffuso di router rilasciati da Telecom Italia (Alice).

Come al solito ribadiamo che il nostro obiettivo è quello di tutelare l’utente che utilizza questi dispositivi per navigare in internet. Per le notazioni di base rimandiamo alla pubblicazione precedente. Inoltre si avvisa che l’articolo risulta essere parzialmente incompleto. Non si escludo aggiornamenti successivi alla pubblicazione.

Con il precedente ci siamo accorti conto che alcuni individui con obiettivi molto lontani dai nostri hanno sfruttato il nostro lavoro per scopi prettamente personali e lucrativi. Teniamo a precisare, per chi non l’avesse notato, che le nostre ricerche sono rilasciate sotto licenza Creative Commons 3.0, ciò significa che i nostri articoli non possono essere utilizzati per fini commerciali e chi vorrebbe riportarli in blog, riviste ecc., è tenuto ad attribuirne la paternità dell’opera. Vi consigliamo di prendere visione di tutte le clausole della licensa.

Nonostante la scoperta di questo algoritmo sia avvenuta alcuni mesi fà abbiamo preferito pubblicare solo adesso la full disclosure per un motivo molto importate secondo la nostra etica. La tecnica che vedrete esposta più avanti ci permette di risalire alla WPA di default conoscendo solo SSID e MAC Address della rete in considerazione. La cosa più grave però fino a qualche mese fà era l’impossibilità di cambiare la chiave preassegnata, ciò rappresentava effettivamente un grave rischio per moltissimi utenti, considerando che Alice copre circa il 70% dei servizi per la fornitura dell’ADSL nel nostro Paese. Ciò significa che non ci si poteva difendere facilemte da questa grave vulnerabilità. Per fortuna però gli ingegneri di Telecom sono riusciti a progettare un nuovo firmware, per la precisione l’AGPF 4.5.0sx, che dà la possibilità all’utente di poter cambiare (finalmente) la chiave WPA di default preassegnata. Alla fine di questo articolo trovere alcuni utili consigli per aumentare la sicurezza nelle vostre reti, qualora avreste un router come quello descritto in questo articolo.

Introduzione

Tra gli operatori ADSL italiani, Telecom Italia si distingue per l’enorme varietà degli apparati hardware che fornisce ai propri clienti, con nomi commerciali spesso così simili tra loro che neanche si distinguono. Inoltre, altrettanto spesso, a oggetti esteticamente identici corrispondono architetture totalmente eterogenee. Siccome il lavoro del reverse engineer si concentra molto sull’architettura e poco o nulla sull’estetica e sul marketing, abbiamo imparato a riconoscere i router con i nomi dei rispettivi firmware. In questo caso, l’algoritmo qui discusso è relativo al router commercialmente denominato “PIRELLI Alice Gate VoIP 2 Plus Wi-Fi” in dotazione con l’abbonamento “Alice tutto incluso” e con firmware AGPF, di seguito lo chiameremo per comodità router AGPF.

Come è evidente, il primo problema da considerare è capire se dal semplice SSID (nome) della rete è possibile riconoscere un router con firmware AGPF, questo sarà il primo problema che andremo ad affrontare. Successivamente, ci occuperemo dell’algoritmo che viene usato dai router AGPF per calcolare la chiave WPA di default.

Riconoscere un router AGPF

Le reti WiFi di Alice vengono contraddistinte dalle altre per l’SSID avente la forma: “Alice-xxxxxxxx“, quindi  costiuite da un prefisso Alice- seguito da una serie numerica di 8 cifre. La parte numerica è necessaria a rendere univoci gli SSID tra tutti i clienti gestiti dall’ISP. Inoltre attraverso confronti e ricerche abbiamo notato che, come avveniva similmente per gli HAG Fastweb, le prime (2-3) cifre individuano la serie del router. La serie è un parametro cruciale: ci dà informazioni sul di tipo di router (quindi il firmware che monta), e aiuta nella determinazione del numero seriale del router. A differenza del caso Fastweb Pirelli, in cui la parte variabile dell’SSID è l’unica informazione necessaria, nei router Telecom sono necessari dei codici non direttamente intercettabili via etere dal wardriver, ma tuttavia spesso calcolabili algoritmicamente conoscendo l’SSID della rete e il MAC della scheda WiFi interna al router: si tratta di un seriale anch’esso univoco associato al router. Il seriale (SN) di un router AGPF è formato da una parte variante per serie, un simbolo fisso e una parte variante per singolo apparato: 12345X1234567. Le cinque cifre prima della X variano per serie di router, iniziano per 6790 o 6910 (almeno dai dati fino adesso analizzati). La X è un simbolo costante, e separa le due parti del SN. Le altre cifre cambiano da router a router secondo un particolare meccanismo che abbiamo dedotto, li abbiamo denominati numeri magici (altri modelli di router usano un formato analogo per i seriali ma non è chiaro se rispettano lo stesso meccanismo di generazione).Verificare se un router è AGPF (o di un altro tipo, AGIF, da cui non è a priori possibile distinguerlo) richiede l’emulazione  dell’algoritmo usato dal router per generare l’SSID a partire dal MAC WiFi e verificare la coincidenza del risultato calcolato con quello che effettivamente si riscontra dal tool di sniffing. Siccome nè l’SSID nè il MAC sono parametri variabili nelle reti Alice, l’esito positivo della verifica dirà al 100% se si tratta di un modello AGPF (o AGIF).

L’algoritmo di questa parte, estratto e commentato dal reverse del firmware, è il seguente:

.text:004C70F0
la $t9, atomac // Ottiene il puntatore al mac e lo mette in v0
lbu $v1, 2($v0) // Prende il 3° byte
move $s0, $v0 // Copia il putnatore perchè gli serve il registro
lbu $v0, 3($v0) // Carica il 4° byte
lbu $a0, 4($s0) // Carica il 5°
andi $v1, 0xF // Prende solo un nibble dal 3° byte
lbu $a1, 5($s0) // Carica il 6° ed ultimo byte
sll $v0, 16
sll $v1, 24
or $v1, $v0
sll $a0, 8
or $v1, $a0
lui $v0, 0x55E6 // Questa non serve a niente
or $v1, $a1 // Le funzioni fino quì servono a prendere una parte del mac e convertirla in un int

Come al solito chiariamo tutto con un semplice esempio: supponiamo che 00238e5e5f68 sia il nostro mac.
L’algoritmo fino a questo punto punto avrà in v1 il valore e5e5f68 che, come si può notare, è una parte del mac  stesso.

li $v0, 0x55E63B89 // Carica il valore in v0
mult $v1, $v0 // Lo moltiplica per la parte del mac
li $a3, 0x5F5E100 /// Carica il valore in a3
mfhi $v0 // solita storia della hiword dopo la moltiplicazione
srl $v0, 25 // Shift della hiword
mul $t0, $v0, $a3 // moltiplica il valore 0x5F5E100 per quello ottenuto dal precedente shift
subu $a3, $v1, $t0 // sottrae alla parte del mac il nuovo valore ottentuo dalla precedente moltiplicazione

Adesso, con quest’altra parte dell’algoritmo avremo finalmente in a3 il nostro ssid generato. Quindi se dal mac non ricavo un ssid uguale a quello noto deduco che non sia AGPF/AGIF. Come si vede, è un semplice algoritmo basato su operazioni logico-aritmetiche, banalmente implementabile da chiunque abbia minime conoscenze di programmazione.

Seriali, Serie e Numeri Magici

Come detto in precedenza, ogni router oltre ad avere un proprio firmware ha anche una serie, corrispondente alla prima parte del seriale (SN) riportato su ogni router. Da un’accurata analisi del tutto statistica siamo riusciti a trarre alcune conclusioni in merito solo per alcune serie. Siamo però convinti che deve esistere un algoritmo universale in grado di individuarli tutti. Non essendo il nostro interese di natura statistica abbiamo limitato le nostre ricerche sui dati a cui abbiamo avuto la possibilità di analizzare.

Riprendendo il discorso dei numeri magici siamo riusciti, tramite confronti tra due o più seriali, ad individuare dei valori costanti che si ripeteno. Il seriale è calcolabile mediante un’equazione tutto sommato abbastanza semplice  conoscendo solamente la parte numerica dell’SSID della rete. E’ stato infatti scoperto che la relazione che sussiste tra SN e SSID è di aritmetica modulare: esistono due costanti, che definiremo con  k e Q, dipendenti dalla serie del router, tale che SSID=k*SN+Q (dove con SN indicheremo la seconda parte del seriale, quella dopo la X, la prima parte è fissa per ogni serie), da questa formula ricaviamo la formula finale SN=(SSID-Q)/k. Naturalmente un’equazione e due incognite non ammette un’unica soluzione, per questo abbiamo impostant un sistema che prende in considerazione i dati di due router della stessa serie.

Supponiamo ad esempio di avere questi due dati:

1. SSID: Alice-96154825 SN: 69102X0010598
2. SSID: Alice-96140044 SN: 69102X0009461

Dalla precedente formula impostiamo un sistema lineare di due equazioni in due incognite:

ottenendo così le seguenti soluzioni:

Da questa soluzione ricaviamo che, per i dati di esempio, otteniamo Q=96017051 e k=13. Una volta ottenuti questi “numeri magici” siamo ingrado di calcolare il SN completo di qualsiasi router facente parte della stessa serie, conoscendo solamente l’SSID. Le serie fino adesso indviduate sono:

• Alice-96xxxxxx  Serie: 69102X*******   k=13   Q=96017051
• Alice-93xxxxxx  Serie: 69101X*******   k=13   Q=92398366
• Alice-56xxxxxx  Serie: 67902X*******   k=13   Q=54808800
• Alice-55xxxxxx  Serie: 67904X*******   k=8     Q=55164449
• Alice-54xxxxxx  Serie: 67903X*******   k=8    Q=52420689
• Alice-48xxxxxx  Serie: 67903X*******   k=8    Q=47896103
• Alice-46xxxxxx  Serie: 67902X*******   k=13   Q=39015145

Analisi dell’algoritmo di generazione WPA

La generazione della WPA dipende sostanzialmente da tre parametri: due variabili e uno costante, quest’ultimo  utilizzato in una procedura analoga descritta nell’algoritmo Pirelli Fastweb: calcolo dell’hash con input MAC del router e SN del router. Come noto, il MAC è ottenibile mediante i più comuni strumenti di sniffing WiFi, è un dato appena un pò meno plateale del SSID.  Ammettendo tuttavia di aver reperito le tabelle note, e di saper quindi calcolare il SN e conoscendo il MAC, l’operazione di generazione è molto simile a quella descritta in precedenza. Si usa, stavolta, un algoritmo di hashing diverso dall’MD5, l’SHA256. In particolare, si inizializza un vettore di calcolo dell’SHA256, e si forniscono in sequenza i seguenti tre elementi:

• Mac Address delle scheda WiFi del router (considerato in byte)
• Seriale completo del router (considerato come stringa)
• Sequenza speciale (costante, in byte)

Procedura

1. Si inizializza una SHA256
2. Si aggiorna la SHA con i 32 byte della sequenza speciale
3. Si aggiorna la SHA con il SN
4. Si aggiorna la SHA con i 6 byte del MAC
5. Si finalizza l’hash SHA di tutti questi dati
6. Si usa una tabella di encoding speciale che a ciascun byte dell’hash fa corrispondere un altro simbolo
7. I primi 24 byte della trasformazione così ottenuta rappresentano la WPA

I punti dell’algoritmo dall’1 al 5 equivalgono sostanzialmente ad effettuare l’ash utilizzando l’algoritmo SHA256 della concatenazione di Hash=SHA256(MagicN+SN+MAC). Dove il primo e l’ultimo argomento devono essere trattati come sequenza di byte, mentre il serial viene inserito come “stringa”.

Il codice speciale utilizzato nell’algoritmo e ricavato per ispezione nel disassemblato è il seguente:

unsigned char ALIS[32] = {
 0x64,0xC6,0xDD,0xE3,0xE5,0x79,0xB6,
 0xD9,0x86,0x96,0x8D,0x34,0x45,0xD2,
 0x3B,0x15,0xCA,0xAF,0x12,0x84,0x02,
 0xAC,0x56,0x00,0x05,0xCE,0x20,0x75,
 0x91,0x3F,0xDC,0xE8
};

Alla fine di quest’operazione otterremo un hash costituito da una sequenza di 32 byte (64 caratteri HEX).
A questo punto, è stata prevista nell’algoritmo alcune trasformazioni sui singoli byte memoryless (ovvero, ciascun byte viene trasformato in modo  indipendente dagli altri e secondo lo stesso identico algoritmo). Sarebbe possibile replicare in qualsiasi linguaggio il codice ASM MIPS (non si tratta di altro che di shift, trasformazioni aritmetiche, …) ma da un’attenta osservazione si è arrivati a costruire un vettore che contiene tutte le possibili combinazioni dalla conversione. Bisogna partire dal presupposto che ogni byte della sequenza dell’hash può assumere 16^2 (256) combinazioni possibili quindi da 0x00 a 0xFF o in decimale da 0 a 255. Il charset utilizzato in una generica WPA è costituito dalle cifre da 0 a 9, e da tutte le lettere dell’alfabeto in minuscolo. Replicando questa sequenza su un vettore a 256 elementi si ottiene lo spazio di varizione di tutti i byte. Ciò significa che ogni byte verrà convertito grazie a questo vettore in un carattere corrispondente. Tra poco vedremo un esempio che ci chiarirà le idee.
Questo è il vettore che andremo ad utilizzare:

 unsigned char preInitCharset[] = {
'0','1','2','3','4','5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l','m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2','3'
};

Ogni byte dell’hash ottenuto dall’algoritmo viene inizialmente convertito in decimale, questo numero può essere  utilizzato come indice nel vettore appena descritto ottenendo man mano tutte le lettere o cifre che compongo la WPA. Quindi ad esempio CharSet[37] = ‘1’, CharSet[19] = ‘j’, CharSet[200] = ‘k’,  ecc..
Naturalmente questo non è l’unico modo per effettuare la conversione, ma è sicuramente molto semplice da implementare ed efficace nell’utilizzo.

Esempio pratico

Come al solito i dati che vedrete in seguito sono di pura fantasia avente solamente lo scopo di confermare il corretto procedimento dell’algoritmo.

Supponiamo di avere una rete WiFi Alice avente i seguenti dati:

• SSID: Alice-12345678
• MAC: 00:23:8E:01:02:03
• SN:    67902X0587411

Applicando l’algoritmo sopra spiegato otteniamo con questi dati un hash sha256 di questo tipo: b1d5d0dc8f3a2132d7872641250f998d53e58824ecb9118e046a943239bf1220

Adesso considerando un byte per volta dobbiamo effettuare le conversioni per ottenere la WPA nella forma che conosciamo.

0xB1 = 177 –> ‘x’
0xD5 = 213 –> ‘x’
0xD0 = 208 –> ‘s’
0xDC = 220 –> ‘4’
0X8F = 143 –> ‘z’
………
ottenendo alla fine la seguente WPA: xxs4zmxezr2t1f9xbds0k5hy
Naturalmente per l’estrazione della WPA interessano solo i primi 24 byte dell’hash.

Coclusioni

Inizialmente il progetto di Alice Telecom Italia è stato studiato principalemente per scoraggiare ogni tentativo di bruteforce sulla chiave di crittazione della rete. Disporre di una WPA costituita da 24 simboli tra cifre e numeri scoraggia ogni vano tentativo di “indovinarla”. Infatti se ci pensiamo le combinazioni possibili sono “appena” 36^24 un numero di inimmaginabile grandezza. Nonstante ciò, Telecom però ha pensato di disabilitare la modifica della chiave di default preassegnata per evitare magari che gli utenti mettessero chiavi meno sicure. Questo però rappresenta una lama  a doppio taglio. E’ vero che quella preassegnata è una chiave molto robusta,  ma se si trova un modo (come quello appena descritto) di ricavare questa chiave è evidente che l’utente non può più difendersi da questa insicurezza.

Abbiamo già parlato nella premessa del modello successivo di AGPF (la variante sx), in cui apparentemente cambia il criterio di creazione dell’SSID e la WPA è configurabile, finalmente, dall’utente. finale Tuttavia l’algoritmo utilizzato è ugualmente reperibile operando attravero il reverse engineering. Ma rimane un problema fondamentale.
L’aggiornamento del nuovo firmware viene attuato attraverso la telegestione, in pratica, il router connesso ad internet si dovrebbe aggiornare in modo del tutto automatico. Questo è possibile verificarlo accedendo attravrso l’interfaccia di rete al router e controllando la sezione “Dettagli modem” dove sono riportate tutte le caratteristiche.
Il problema di fondo di cui acennavamo prima rimane sempre lo stesso. Quanti utenti cambieranno la chiave WPA di default? Quanti utenti vengono informati di questa possibilità?

Sperando di aver dato un contributo positivo alla sicurezza nelle reti da parte nostra vi consigliamo sempre di cambiare la WPA di default in una totalmente random, complessa  e non inferiore ai 24 caratteri. Qualora qualcuno si accertasse che la propria versione di firmware per il router in questione sia inferiore alla 4.5.0sx è possibile richiedere un aggiornamento contattando direttamente l’assistenza di Alice.

****  White Hats ****