[pillola] criptaggio più sicuro delle password

[andrea.paiola]

Ormai tutti sapete ( vero? ) che si devono criptare le password quando le salvate da qualche parte ( per esempio un db )

Molti di voi useranno md5 o sha1, le funzioni native di PHP per farlo... beh sappiate che per password semplici ( le più usate ) questo non è affatto sicuro come pensate!

Si può per esempio usare Google per cercare l'hash e quindi avere la probabile password in chiaro: esempio con "Alex"

Molto di voi quindi useranno un salt, un qualcosa in più che permetta di ovviare ai problemi derivanti dall'usare password sempici... mi son voluto spingere un pochino oltre.

Ho quindi pensato di scrivere 2 righe di PHP per avere un sistema molto più sicuro utilizzando un sistema di cifratura poco usato: il prodotto tra matrici.

Dati in input password e salt ( due stringhe fatte come vi pare ) la funzione esegue una serie di operazioni più o meno complesse ( l'unico limite è la fantasia ) tra cui il prodotto delle due matrici quadrate ( 8 x 8 ) generate dall'elaborazione della password e del salt e si ha quindi in uscita un'altra stringa che per comodità può essere di nuovo un hash se volete.

Vi invito a personalizzarla, anche semplificarla perchè no.

Ecco il codice:

<?php

/** Setting error reporting */
error_reporting(E_ALL | E_STRICT);
ini_set('display_startup_errors', 1);
ini_set('display_errors', 1);



function cripta($pass,$salt){    
    /* variabili */
    $array_pass = Array();
    $array_salt = Array();
    $array_ris = Array();
    $ris=Array();
    $n=0;
    $i=0;
    $j=0;
    $y=0;

    /* converto in array le due stringhe così da avere le due matrici 8 x 8  */
    $hex_md5_pass = bin2hex(md5($pass));
    $hex_md5_salt = bin2hex(md5($salt));

    
    // riempo l'array pass
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            $array_pass[$i][$j] = substr($hex_md5_pass,$n,1);
            $n++;
        }
    }
    
    $n=0;
    // riempo l'array salt
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            $array_salt[$i][$j] = substr($hex_md5_salt,$n,1);
            $n++;
        }
    }    


    /* moltiplico i due array */
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            //prodotto riga per colonna
            $array_ris[$i][$j]=0;
            for($y=0;$y<8;$y++){
                $array_ris[$i][$j] = $array_ris[$i][$j]+$array_pass[$i][$y]*$array_salt[$y][$j];
            }
        }
    }    

    for($i=0;$i<8;$i++){
        $ris[$i]=array_sum($array_ris[$i]);
    }

    return md5(implode($ris));
}
echo(cripta('bella_password','passami_il_sale'));

[andr3a]

partito male col titolo ... criptaggio ed md5 o sha1 che siano, non c'entrano niente.

hash e crypt sono operazioni completamente differenti ... ma a parte questo, la pillola non spiega come salvare il tutto in database o come fare poi le opportune verifiche.

magari aggiungi altre informazioni poichè così si ha solo una funzione che ha un nome sbagliato e di dubbia utilità ... dove il dubbio, una volta scelto di usare una salt, sta nel fatto di quanto sia utile fare 3 cicli quando md5 o sha1 ne fanno molti di più per ottenere un risultato comunque sempre a rischio di collisioni ... in pratica non ho capito dov'è la maggiore sicurezza.

esempio, io ho pass qualunque ... nel momento in cui la invio in chiaro al server, se non sono quindi in SSH, qualunque cosa faccio dietro serve a niente perchè il man in the middle avrà sempre dati in chiaro.

Ammesso questo non sia vero, se qualcuno riesce a leggere il database e non ci sono controlli sulla lunghezza della password, e/o eventuali caratteri da usare, mettere tutto questo giro di array in mezzo tra pass e salt e il dato in unscita, un hash md5, è esattamente come non fare niente.

Quello che voglio dire è che leggendo il database ed usando una pass vuota, saprò già come accedere ai dati ... e con un update posso accedere a tutti i dati.

Quello che mi sfugge quindi è perchè secondo te questo metodo è migliore rispetto qualcosa tipo:

function hash($pass,$salt){
    return sha1(sha1($salt).$pass);
}

in quale caso il tuo sistema è più sicuro? puoi portare qualche esempio? grazie


P.S. piccola nota sull'implode ... così funziona lostesso ma the bad prototype would be used

[andrea.paiola]

Originariamente inviato da andr3a
bla bla bla

Quello che mi sfugge quindi è perchè secondo te questo metodo è migliore rispetto qualcosa tipo:

function hash($pass,$salt){
    return sha1(sha1($salt).$pass);
}

in quale caso il tuo sistema è più sicuro? puoi portare qualche esempio? grazie

inizialmente hai parlato d'altro... io l'ho scritta solo per chiarire che non basta mettere md5 o sha1 per sentirsi al sicuro e ho portato l'esempio google che mi pare lampante

il prodotto tra matrici è più sicuro perchè è irreversibile, in linea generale ( e tra l'altro fare sha1(sha1($salt).$pass) non è più sicuro che fare sha1($salt . $pass): anche se hash sempre una stringa fissa è e avendo un buon numero di password permette di fare l'analisi e quindi trovare il salt ( hashato o meno ) relativamente facilmente )

ps: lo so che hash è diverso da criptare, ma appunto aggiungo il criptaggio tramite prodotto tra matrici al mero hash... così forse ti è più chiaro? ovvio che volendo si possono implementare altri algoritmi di criptaggio e infatti invito a farlo, creando varianti... implementare IDEA però mi sembrava un po' eccessivo, invece trovavo carino provare il prodotto tra matrici, visto che avevo appunto la possbilità di avere facilmente 2 matrici usabili

'notte

ah la cosa sull'implode me la devi spiegare
nel database la metti come vuoi che vuol dire

[andr3a]

Originariamente inviato da andrea.paiola
il prodotto tra matrici è più sicuro perchè è irreversibile, in linea generale

quindiu è un hash, non un crypt ... per l'appunto, poichè anche sha1 e md5 sono hash one way

Originariamente inviato da andrea.paiola
e tra l'altro fare sha1(sha1($salt).$pass) non è più sicuro che fare sha1($salt . $pass): anche se hash sempre una stringa fissa è e avendo un buon numero di password permette di fare l'analisi e quindi trovare il salt ( hashato o meno ) relativamente facilmente

la salt non la invii .. e se hashata, puoi analizzare quello che ti pare ma si da il caso che la salt è la stringa scelta dallo sviluppatore sul server, ergo non sarà la stringa "Alex", bensì qualcosa tipo "sj8(%$_34/8_321aAFTA,sac.:" ... ecco questa è una salt, non è in pasto agli utenti e adesso cerca su google il suo hash e dimmi quanti ne trovi (per altro in sha1, che non è md5) ... vero è che puoi trovare collisioni, quindi con questa stai ancora più sicuro?
return sha1(sha1($salt).$salt.$pass);

ammesso trovi la collisione con questa ne devi trovare due in una e mi sembra alquanto improponibile come casistica ... ma è un argomento già trattato non so quante volte sul forum ... il punto è che aggiungere un hash one way sopra un hash one way mi sembra ridondante, poco performante, inutile se non si sta in SSH, e per concludere altrettanto poco utile se qualcuno è entrato nel database e la paura è quindi: oddio può vedermi le password hashate ... più che altro oddio, adesso fa quello che gli pare???!!!

Se invece il tutto è per evitare che in output venga mostrato il risultato di questa operazione ... beh, l'errore è a monte, non sul database, ma a quel punto di crateri ce ne sono già troppi.

Insomma, non ho capito dov'è la maggiore sicurezza ... tu mi dici: faccio questo perchè è irreversibile, io ti dico: guarda che quello che facevi prima lo era altrettanto ... ergo come google trova l'md5, non per magia, io posso ciclarmi nel tempo varie combinazioni e farmi un db di risultati "cript paiola", è la stessa cosa, no? ... si

(in soldoni proponi di fare md5(md5($qualcosa)) invece di md5($qualcosa), aggiungendo solo un'altro strato one way sopra)

P.S. implode ... primo argomento $glue, e poi array ... oggi funziona anche senza glue, domani non ne siamo sicuri, ergo perchè rischiare?

[andrea.paiola]

Originariamente inviato da andr3a
quindiu è un hash, non un crypt

bah se vogliamo fare i precisini: se togliessi da

return md5(implode($ris)); 

l'md5, non sarebbe un hash perchè non avrebbe lunghezza costante

se proprio ci tieni alle definizioni eh

ho aggiunto l'md5 lì solo perchè magari qualcuno pensa di integrarla in un prodotto già pronto e usare md5 per le password ormai è uno standard ( chessò Drupal per esempio lo fa e mi pare anche wordpress )


e comunque sì: esistono metodi di analisi crittografica per cercare collisioni md5 ( nel 2006 è stato pubblicato un algoritmo che riesce a trovare collisioni in meno di un minuto )

SHA1 è decisamente più resistente sia agli attacchi a forza bruta che all'analisi, anche perchè si hanno pochi dettagli sul funzionamento, mi pare

ma il fatto che son stati creati SHA2 e altri mi fa ben poco sperare sulla sua solidità... e infatti http://punto-informatico.it/p.aspx?i=1078348

dovrei fare delle prove e non ne ho il tempo e in gran parte le conoscenze e le risorse ma penso che l'usare il salt "semplice" piuttosto che il prodotto tra matrici ( anche se è stato più che altro un esercizio accademico ) renda più vulnerabile all'analisi differenziale... anche perchè il prodotto tra matrici è poco usato e quindi l'attaccante non se lo aspetta

madò che sonno e domattina sveglia presto

Originariamente inviato da andr3a
P.S. implode ... primo argomento $glue, e poi array ... oggi funziona anche senza glue, domani non ne siamo sicuri, ergo perchè rischiare?

ok grazie.. se avete voglia mod modificate, altrimenti pazienza

[mtx_maurizio]

Ormai tutti sapete ( vero? ) che si devono criptare le password quando le salvate da qualche parte ( per esempio un db )

Premetto che sì, lo so, lo faccio, e sono assolutamente convinto della necessità di farlo.
Quello che forse non sapete é che esiste una norma della commisione europea che impone a chi gestisce siti di offrire la possiliblità ai propri utenti che hanno dimenticato la loro password di recuperarla. Non di ottenerne una nuova ne la possibilità di rimuoverla e crearne un'altra, ma di avere la loro password. Ovviamente é una norma da burocrati tra l'altro mal consigliati, ma tant'é. Vi assicuro che le grandi aziende europee la applicano. Ho un amico che lavora nel web della borsa tedesca e mi ha detto che, a fronte di questa norma, le password dei loro utenti sono archiviate in chiaro così come in molte altre aziende. Ovviamente tutta la sicurezza sarà poi concentrata nella protezione del db ed in un codice più elaborato.
Comunque era solo una precisazione, continuerò a passare md5 le mie password come spero farete anche voi.

[andrea.paiola]

Originariamente inviato da mtx_maurizio
Premetto che sì, lo so, lo faccio, e sono assolutamente convinto della necessità di farlo.
Quello che forse non sapete é che esiste una norma della commisione europea che impone a chi gestisce siti di offrire la possiliblità ai propri utenti che hanno dimenticato la loro password di recuperarla. Non di ottenerne una nuova ne la possibilità di rimuoverla e crearne un'altra, ma di avere la loro password. Ovviamente é una norma da burocrati tra l'altro mal consigliati, ma tant'é. Vi assicuro che le grandi aziende europee la applicano. Ho un amico che lavora nel web della borsa tedesca e mi ha detto che, a fronte di questa norma, le password dei loro utenti sono archiviate in chiaro così come in molte altre aziende. Ovviamente tutta la sicurezza sarà poi concentrata nella protezione del db ed in un codice più elaborato.
Comunque era solo una precisazione, continuerò a passare md5 le mie password come spero farete anche voi.

beh non c'è bisogno di immagazzinare in chiaro: si possono usare sistemi crittografici che permettono di risalire alla password usando però sistemi robusti... anche crittografia a chiave pubblica perchè no... certo che non userei password immesse dagli utenti però

[andr3a]

andrea, e' un errore comune pensare che md5 e sha1 siano operazioni di crypt, per questo il mio intervento sul topic e l'inizio della pillola:

Ormai tutti sapete ( vero? ) che si devono criptare le password quando le salvate da qualche parte

quante volte anche tu hai letto "decrypt" o "crypt" e l'argomento era sempre e solo md5?

Il tuo bel giro conduce ad un hash, ergo stai overhashando la stringa tramite un operazione che non ha lunghezza fissa ma che e' one way, ha lunghezza fissa per dato in input, e alla fine e' ridotta nuovamente ad hash dall'md5

Personalmente uso sha1 da una vita e non ho mai avut problemi, sia perche' non mi sono mai sognato di selezionare user e pass, sia perche' se qualcuno entra nel db o riesce a iniettare query via web, i problemi sono ben piu' gravi della sola operazione di login.

Riguardo il discorso crypting, invece, blowfish ed altri fanno egregiamente il loro lavoro e se si sta su SSH non si hanno problemi di invio in chiaro.

Quindi gira e rigira, questo tuo metodo, magari interessante dal punto di vista della conversione usata, non aumenta di un solo punto la sicurezza rispetto una funzione che ritorna sha1(sha1($salt).$salt.$pass) ... e come pillola manca di contorno, ovvero come sfruttare eventualmente la funzione o altro. Opinione personale

[piero.mac]

Originariamente inviato da andr3a

Riguardo il discorso crypting, invece, blowfish ed altri fanno egregiamente il loro lavoro e se si sta su SSH non si hanno problemi di invio in chiaro.

ma anche gestire la password come si fa in mysql per la connessione del Client, dopo aver ricevuto l'identificativo dell'utente o almeno qualcosa di simile. Dal manuale mysql:

Password functions

The Server Initialization Packet and the Client Authentication Packet both have an 8-byte field, scramble_buff. The value in this field is used for password authentication. It works thus:

The server sends a random string to the client, in scramble_buff.
The client encrypts the scramble_buff value using the password that the user
enters. This happens in sql/password.c:scramble() function.
The client sends the encrypted scramble_buff value to the server.
The server encrypts the original random string using a value in the mysql
database, mysql.user.Password.
The server compares its encrypted random string to what the client sent
in scramble_buff.
If they are the same, the password is okay.

Relevant MySQL Source Code:
libmysql/password.c comments at start of file.

a chi potesse interessare: http://forge.mysql.com/w/index.php?t...&printable=yes

[andrea.paiola]

Originariamente inviato da andr3a
Il tuo bel giro conduce ad un hash

questa funzione NON produce un hash, essendo che l'output ha lunghezza variabile

<?php

/** Setting error reporting */
error_reporting(E_ALL | E_STRICT);
ini_set('display_startup_errors', 1);
ini_set('display_errors', 1);



function cripta($pass,$salt){    
    /* variabili */
    $array_pass = Array();
    $array_salt = Array();
    $array_ris = Array();
    $ris=Array();
    $n=0;
    $i=0;
    $j=0;
    $y=0;

    /* converto in array le due stringhe così da avere le due matrici 8 x 8  */
    $hex_md5_pass = bin2hex(md5($pass));
    $hex_md5_salt = bin2hex(md5($salt));

    
    // riempo l'array pass
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            $array_pass[$i][$j] = substr($hex_md5_pass,$n,1);
            $n++;
        }
    }
    
    $n=0;
    // riempo l'array salt
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            $array_salt[$i][$j] = substr($hex_md5_salt,$n,1);
            $n++;
        }
    }    


    /* moltiplico i due array */
    for($i=0;$i<8;$i++){
        for($j=0;$j<8;$j++){
            //prodotto riga per colonna
            $array_ris[$i][$j]=0;
            for($y=0;$y<8;$y++){
                $array_ris[$i][$j] = $array_ris[$i][$j]+$array_pass[$i][$y]*$array_salt[$y][$j];
            }
        }
    }    

    for($i=0;$i<8;$i++){
        $ris[$i]=array_sum($array_ris[$i]);
    }

    return implode($ris);
}