Newsgroup: it.comp.sicurezza.unix
Titolo: crypt()

Avrei una domandina sull'uso del salt che viene fatto in crypt().
In pratica char *crypt(const char *key, const char *salt)
funziona prendendo due argomanti, la password e il salt, accoda il
salt alla password e cripta il tutto con il DES spuntando una stringa
in base 64. I primi 2 caratteri sono il salt in _chiaro_ e i restanti
11 la password cifrata. Vi prego di correggermi se sbaglio.
Ora il mio dubbio e' questo:
Si dice che l'uso del salt serve a rendere piu' problematico il
dictionary-attack perche' moltiplica per 4096 i modi possibili di
crittare una password. Questo perche' la stessa pw crittata con
salt diversi porta a diverse pw crittate, esempio:
crypt("fred","am") = "amLH9TiZZkscc"
crypt("fred","an") = "anvepwCPZQ2Z6"
Tuttavia dico, se il salt e' in _chiaro_ non ho bisogno di fare
4096 crypt() per ogni parola nel dizionario, mi basta provare
una crypt() con il valore di salt che conosco.
Se e' cosi' a cosa servirebbe questo salt?
-- 
Lorenzo
"Given enough eyeballs, all bugs are shallow", Linus'Law
(Please rot13 my email address to reply)

Pape' Satan, pape' Satan aleppe, comincio' Lorenzo con voce chioccia:
LA> Tuttavia dico, se il salt e' in _chiaro_ non ho bisogno di fare
LA> 4096 crypt() per ogni parola nel dizionario, mi basta provare
LA> una crypt() con il valore di salt che conosco.
LA> Se e' cosi' a cosa servirebbe questo salt?
se hai 200 utenti nel tuo passwd, con 200 salt diversi, ogni parola
del dizionario va crittata 200 volte :-)
-- 
ciao,
Claudio

Se e' cosi' a cosa servirebbe questo salt?
Come dicevi anche prima, lo scopo del salt e' quello di fare in modo che due
password uguali non vengano codificate in maniera analoga. Solitamente come salt
io metto due caratteri generati casualmente, perche' se usi sempre lo stesso
salt, non serve a nulla.
Ciao,_
    /_)
   /ier
                   +---------------------------------+
                   |     Piergiorgio Ghezzo  [PJ]    |
                   |                                 |
                   | E-mail: 
P...@piggei.com
           |
                   |   Fido: 2:333/
70...@fidonet.org
 |
                   |    IRC: PJ on #AMIGAITA         |
                  /)    Web: 
www.piggei.com
          (\
                 / )                                 ( \
             (\ ( (+---------------------------------+) ) /)
              \(\\ \   / )                      / )  / //)/
               \\\\ \_/ /                       \ \_/ ////
                \      /                         \      /
                 \    /                           \    /

 del dizionario va crittata 200 volte :-)
scusa, ma io guardando nelle sorgenti di login.c (util-linux-2.9) ho
visto che i salt sono sempre "xx" (e xx non e' la variabile, ma proprio
il valore che ha quella char)
anche xke', siccome l'autenticazione funziona in confronto (essendo il
des one-way) il programma login o chi x esso, non puo' provare tutti i
4096 possibili salt x poter crittare la password inserita x poi
confrontarla con quella del file  di passwd.
ciao
Vecna.

> del dizionario va crittata 200 volte :-)
V> scusa, ma io guardando nelle sorgenti di login.c (util-linux-2.9) ho
V> visto che i salt sono sempre "xx" (e xx non e' la variabile, ma proprio
mmmmh... fammi controllare...
        if ((pwd = getpwnam(username))) {
[...]
            salt = pwd->pw_passwd;
        } else
          salt = "xx";
in realta' il salt e' messo a xx solo se l'utente in questione non
esiste nel file delle password. Se invece esiste, getpwnam ritorna un
puntatore alla struttura 'passwd' che contiene tutti i dati relativi 
a quella entry:
              struct passwd {
                      char    *pw_name;       /* user name */
                      char    *pw_passwd;     /* user password */
                      uid_t   pw_uid;         /* user id */
                      gid_t   pw_gid;         /* group id */
                      char    *pw_gecos;      /* real name */
                      char    *pw_dir;        /* home directory */
                      char    *pw_shell;      /* shell program */
              };
quindi nel caso che l'utente esista, salt punta alla password stessa.
Questo perche' i primi due caratteri della password crittata sono
proprio il salt in chiaro! Ad esempio crypt("pippo", "xx") ritorna
xxgfyCar8mcIc.
^^
Piu' avanti nei sorgenti di login trovi infatti
        p = crypt(pp, salt);
in cui la password immessa viene criptata per essere confrontata con
quella nel file delle password. (nota che salt punta a tutta la
password crittata, ma crypt ne usa solo i primi due caratteri)
V> anche xke', siccome l'autenticazione funziona in confronto (essendo il
V> des one-way) il programma login o chi x esso, non puo' provare tutti i
V> 4096 possibili salt x poter crittare la password inserita x poi
come gia' detto il salt e' in chiaro nel file delle password...
questo risolve il problema.
-- 
ciao,
Claudio