Perché non dovrei usare il 23esimo carattere in una funzione di crypt() salt?

Sto imparando la funzione di crypt() di PHP e ho eseguito alcuni test con esso. Secondo this post, dovrei usare un sale lungo 22 caratteri. Tuttavia, posso usare una stringa lunga 23 caratteri con alcune limitazioni. Quando uso una stringa lunga 22 caratteri, ottengo sempre un risultato di "$ 2y $ xxStringStringStringStri.HashHashHashHashHashHashHashHas". So che il periodo è solo una parte del sale.Perché non dovrei usare il 23esimo carattere in una funzione di crypt() salt?

Sembra che se utilizzo 23 caratteri anziché solo 22, posso generare correttamente diversi hash, ma ci sono solo 4 risultati diversi per tutti i 64 caratteri. Il carattere 23 "arrotonda" con l'approssimazione di 1/4 ° dell'alfabeto 64 caratteri (ad esempio, il carattere 23 è "W" e arrotonda fino a "O" o qualsiasi numero giri fino a "u")

v---------------v---------------v---------------v--------------- 
./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890

Tutti e quattro di queste funzioni cripta generano lo stesso sale:

crypt('Test123','$2y$09$AAAAAAAAAAAAAAAAAAAAAq'); 
crypt('Test123','$2y$09$AAAAAAAAAAAAAAAAAAAAAr'); 
crypt('Test123','$2y$09$AAAAAAAAAAAAAAAAAAAAAs'); 
crypt('Test123','$2y$09$AAAAAAAAAAAAAAAAAAAAAt');

Ma questo è diverso:

crypt('Test123','$2y$09$AAAAAAAAAAAAAAAAAAAAAu');

Allora, perché non dovrei utilizzare il carattere 23, quando in grado di generare con successo esiti diversi? C'è qualche tipo di comportamento glitch in PHP che dovrebbe essere evitato non utilizzandolo?

Per chiarimenti su come io sto contando il personaggio 23 nel sale:

crypt('Test123','$2y$08$ABCDEFGHIJKLMNOPQRSTUV'); 
//  The salt is '$ABCDEFGHIJKLMNOPQRSTUV' 
//  Which will be treated as '$ABCDEFGHIJKLMNOPQRSTUO'

fonte

2013-03-05 Andrew

C'è una buona spiegazione su questa domanda: http://security.stackexchange.com/questions/20862/php-crypt-trims-the-salt-as-it-would-be-too-long –

Grazie per questa risposta Anche se questo risolve solo ciò che accade al 23 ° carattere in quanto viene abbreviato solo a causa delle dimensioni dei bit consentiti nella funzione crypt(). La mia domanda, in un altro modo di chiedere, è "Dovrei usare il 23 ° carattere anche se verrà tagliato a pezzi in due bit?" o un altro modo è "C'è un problema nell'algoritmo di PHP che genera hash errati ogni volta che viene usato il 23 ° carattere?" – Andrew

ha a che fare con le collisioni hash. Una volta superati i 22 caratteri, gli hash generati non sono più univoci a seconda dello NAMESPACE dell'algoritmo. Per dirlo in un altro modo, più di 22 caratteri non comportano alcun aumento della sicurezza e possono effettivamente ridurre il livello di sicurezza.

fonte

2013-03-05 16:43:06

Mi sembra che aggiunga altri 2 bit di sicurezza. Posso ancora generare diversi hash cambiando altri personaggi in tutto il sale lasciando il 23esimo come, diciamo "a". C'è un articolo su traboccare il sale? Anche su [php.net] (http://php.net/manual/en/function.crypt.php) usano un esempio di sale con più di 22 caratteri. – Andrew

Ovviamente genererà risultati diversi ma se usi 23 caratteri c'è un'altra stringa che risulterà nello stesso identico hash. Questo si chiama collisione e non lo vuoi quando stai cercando di mantenere tutto unico. –

Hmmm .... Non sono sicuro di come spiegarlo, ma posso garantire che l'uso di 23 caratteri in una salata (anche se ci sono collisioni salate come hai detto tu) è più sicuro dell'utilizzo 22. Spiegazione: Diciamo abbiamo una forma più piccola di pesce palla. In questo mini aragosta, possiamo inserire un sale di lunghezza 1 carattere, come "a" o "4" o "I".Ci sono 64 combinazioni diverse che possiamo fare con questo prima di iniziare a ottenere collisioni salate. Tuttavia, possiamo aggiungere solo altri 2 bit (".", "O", "e" e "u") e trasformare una combinazione di 64 sali unici in 256. Anche quando non è l'alfabeto completo, è più sicuro. – Andrew

$ non fa parte del sale effettivo. È un separatore.

Per la crittografia Blowfish, il formato è $ 2 [axy] $ log2Rounds $ [salt] [hash]. Lo descrivi aggiungendo a. - Questo perché ti manca l'ultimo personaggio. Il sale di Blowfish è di 128 bit. Potresti usare solo 126, sì, ma stai solo indebolendo inutilmente il sale.

fonte

2013-05-10 15:03:02 Zer

Se in realtà usi troppi caratteri, tra l'altro, stai bene con crypt() perché è progettato per essere usato come crypt (password, salt) per crypt, cryptedPassword == crypt (password, cryptedPassword) per la verifica, e lo fa aggiungendo l'hash a the salt in output e usando solo i relativi salt byte in input. Quindi vedi, i personaggi extra non saranno usati. – Zer

Perché non dovrei usare il 23esimo carattere in una funzione di crypt() salt?

risposta

Problemi correlati