Discussione Hacking Challenges #1: risoluzione sfide (3/3)

0xbro

Moderatore
24 Febbraio 2017
3,539
137
2,203
1,360

Hacking Challenges #1: risoluzione sfide (3/3)​

Nel seguente topic verranno spiegate le metodologie, i procedimenti e i tools necessari per risolvere il terzo e ultimo gruppo di sfide della prima edizione delle Hacking Challenges (le sfide le potete trovare al link qua sotto).​




[Reversing] Cos'è uno scienziato senza il suo telescopio? (Easy)​

"Telescopio (s.m.). Strumento che sta all'occhio come il telefono sta all'orecchio, e che permette a oggetti remoti di infastidirci con una quantità eccessiva di dettagli inutili e irrilevanti." - cit. Ambrose Bierce
Hint: A volte basta fermarsi all'apparenza, altre volte è necessario osservare il funzionamento interno delle cose

La sfida in questione comincia mettendoci a disposizione solamente un file eseguibile, chiamato TheBiggerPicture.elf. Eseguendolo otteniamo solo due righe di output:

Bash:
$ ls
TheBiggerPicture.elf

$ chmod +x TheBiggerPicture.elf; ./TheBiggerPicture.elf
What is happening...?
It seems nothing

Come lascia intendere la sfida, probabilmente succederà qualcosa in memoria tale per cui sarà possibile ottenere la flag. Poichè non abbiamo accesso al codice sorgente dell'eseguibile, l'unico modo che abbiamo per vedere staticamente le istruzioni eseguite a run-time è utilizzare un decompilatore. Utilizziamo quindi objdump assieme ai parametri -d per decompilare il binario e -M intel per utilizzare il formato assembly Intel:

5_1.png


Siccome l'output è molto verboso, concentriamoci solamente sulla ricerca della sezione che ci interessa: il main.

Bash:
$ objdump -d -M intel TheBiggerPicture.elf | awk -v RS= '/^[[:xdigit:]]+ <main>/'
000000000000119f <main>:
    119f:       55                      push   rbp
    11a0:       48 89 e5                mov    rbp,rsp
    11a3:       48 8d 3d 5a 0e 00 00    lea    rdi,[rip+0xe5a]        # 2004 <_IO_stdin_used+0x4>
    11aa:       e8 81 fe ff ff          call   1030 <[email protected]>
    11af:       e8 81 ff ff ff          call   1135 <doThings>
    11b4:       48 8d 3d 5f 0e 00 00    lea    rdi,[rip+0xe5f]        # 201a <_IO_stdin_used+0x1a>
    11bb:       e8 70 fe ff ff          call   1030 <[email protected]>
    11c0:       b8 00 00 00 00          mov    eax,0x0
    11c5:       5d                      pop    rbp
    11c6:       c3                      ret
    11c7:       66 0f 1f 84 00 00 00    nop    WORD PTR [rax+rax*1+0x0]
    11ce:       00 00

Osservando il codice possiamo notare come il programma faccia riferimento a un'altra funzione "particolare": <doThings>. Cerchiamo di capire quale sia il suo scopo:

Bash:
$ objdump -d -M intel TheBiggerPicture.elf | awk -v RS= '/^[[:xdigit:]]+ <doThings>/'
0000000000001135 <doThings>:
    1135:       55                      push   rbp
    1136:       48 89 e5                mov    rbp,rsp
    1139:       48 b8 44 41 76 3f 6a    movabs rax,0x706a546a3f764144
    1140:       54 6a 70
    1143:       48 ba 47 64 66 60 4f    movabs rdx,0x3d60634f60666447
    114a:       63 60 3d
    114d:       48 89 45 b0             mov    QWORD PTR [rbp-0x50],rax
    1151:       48 89 55 b8             mov    QWORD PTR [rbp-0x48],rdx
    1155:       48 b8 64 62 62 60 6d    movabs rax,0x5e644b6d60626264
    115c:       4b 64 5e
    115f:       48 89 45 c0             mov    QWORD PTR [rbp-0x40],rax
    1163:       c7 45 c8 6f 70 6d 60    mov    DWORD PTR [rbp-0x38],0x606d706f
    116a:       66 c7 45 cc 3a 78       mov    WORD PTR [rbp-0x34],0x783a
    1170:       c7 45 fc 00 00 00 00    mov    DWORD PTR [rbp-0x4],0x0
    1177:       eb 1c                   jmp    1195 <doThings+0x60>
    1179:       8b 45 fc                mov    eax,DWORD PTR [rbp-0x4]
    117c:       48 98                   cdqe
    117e:       0f b6 44 05 b0          movzx  eax,BYTE PTR [rbp+rax*1-0x50]
    1183:       83 c0 05                add    eax,0x5
    1186:       89 c2                   mov    edx,eax
    1188:       8b 45 fc                mov    eax,DWORD PTR [rbp-0x4]
    118b:       48 98                   cdqe
    118d:       88 54 05 d0             mov    BYTE PTR [rbp+rax*1-0x30],dl
    1191:       83 45 fc 01             add    DWORD PTR [rbp-0x4],0x1
    1195:       83 7d fc 1d             cmp    DWORD PTR [rbp-0x4],0x1d
    1199:       7e de                   jle    1179 <doThings+0x44>
    119b:       90                      nop
    119c:       90                      nop
    119d:       5d                      pop    rbp
    119e:       c3                      ret

A primo impatto sembra essere la funziona che crea la flag, come posso farci intuire le righe 1139, 1143, 1155, 1163 e 116a che sembrano contenere delle stinghe. Per verificare la nostra teoria abbiamo due possibili strade: cercare di convertire i vari valori esadecimali in ASCII e comprendere l'algoritmo per riprodurlo a mano oppure, siccome la funzione è richiamata nel main del programma, lasciare che il pc lo faccia al posto nostro.

Siccome la pigrizia è una virtù, lasceremo che il programma lo faccia al posto nostro. Ci basterà eseguire il programma all'interno di un debugger per poter ispezionare la memoria subito prima che il programma termini ed estrarre così la flag. Per farlo useremo un noto debugger per linux chiamato edb

5_2.png


Per approfondire il funzionamento della memoria, dei registri e dello stack invito a documentarsi su altre guide, per il momento ci basterà sapere che la flag, siccome viene generata in memoria, potrà essere recuperata dallo stack alla fine del processo (possiamo utilizzare il registro RSP per far riferimento all'area di stack interessata).
Per intercettare l'esecuzione e stopparla prima che questa termini dobbiamo utilizzare i break poit. Per trovare facilmente la posizione della funzione doThings all'interno della memoria possiamo utilizzare invece i plugin di edb.

5_3.png


Ora che abbiamo identicato la funziona nella memoria, inseriamo un breakpoint prima che l'esecuzione della funzione termini (prima quindi dell'istruzione ret) e avviamo il programma:

5_4.png


A questo punto con l'esecuzione stoppata, utilizziamo il valore di RSP per posizionarci all'interno dello stack e trovare la flag:

5_5.png




[Stego] Nel cimitero digitale di Elliot (Medium)​

È passato solo un mese e credo che nel grande disegno universale non sia molto. La nostra vita in fondo è solo un blip nel calendario cosmico. Come Sheila: è stata un lampo, forse neanche quello. E comunque si va avanti. Mi odio se penso che mi sono già abituato all’idea che lei non c’è più. Tra un anno penserò a lei solo ogni tanto, poi diventerà un aneddoto, una storia da raccontare.. “Conoscevo una ragazza che è morta..” e potrò aggiungere “.. È morta per colpa mia”. Forse dovrei odiarmi davvero.
Hint: Se tu fossi Elliot Alderson, dove nasconderesti i tuoi ricordi?

La sfida si presenta propronendoci due file: un archizio zip protetto da password e un'immagine. Iniziamo analizzando i dati contenuti all'interno dell'immagine, alla ricerca di qualche informazione importante. Per farlo possiamo utilizzare diversi strumenti tra cui exiftool, il comando strings oppure tools online come CyberChef:

Bash:
$ exiftool TheCure.jpg            
ExifTool Version Number         : 12.16
File Name                       : TheCure.jpg
Directory                       : .
File Size                       : 29 KiB
File Modification Date/Time     : 2021:01:14 21:48:05+01:00
File Access Date/Time           : 2021:02:05 14:15:53+01:00
File Inode Change Date/Time     : 2021:03:04 10:09:15+01:00
File Permissions                : rw-r--r--
File Type                       : JPEG
File Type Extension             : jpg
MIME Type                       : image/jpeg
JFIF Version                    : 1.01
Resolution Unit                 : inches
X Resolution                    : 96
Y Resolution                    : 96
Comment                         : Password = v1ew-s0urce.flv
Image Width                     : 640
Image Height                    : 360
Encoding Process                : Baseline DCT, Huffman coding
Bits Per Sample                 : 8
Color Components                : 3
Y Cb Cr Sub Sampling            : YCbCr4:2:0 (2 2)
Image Size                      : 640x360
Megapixels                      : 0.230

$ strings -n7 TheCure.jpg
Password = v1ew-s0urce.flv
, #&')*)
-0-(0%()(
((((((((((((((((((((((((((((((((((((((((((((((((((
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz
&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz
C4aDdm=Cg
SVeFN/F|a
>cZ]B7
YKmsk68|
L,Fy',A
y`[email protected]
R#w;F[#?
j&a*n'N
OT52_Fz
Q^Y[[email protected]
KgD Z}h
P2d?5YJ
.Pth][?
+]8TbMx?
                \SON*
MS]{o5O
?mAyyib
^,H[!F;
jV;-7Ue+
[email protected]
a$t"~}*
N;dQGj`
9OAHF)45"

Siamo così riusciti a estrarre la password che, se cercata online, è un chiaro riferimento a un episodio della serie tv Mr. Robot (così come la stessa immagine che abbiamo analizzato).
Estraendo i file contenuti all'interno dell'archivio notiamo che sono tutte canzoni dell'album Disintegration dei TheCure. Facendo riferimento all'episodio della serie TV (e all'hint "Se tu fossi Elliot Alderson, dove nasconderesti i tuoi ricordi?") scopriamo che è possibile nascondere delle informazioni all'interno di vari file audio tramite varie tecniche steganografiche. Uno dei programmi in grado di inserirle (ed estrarle) è DeepSound, utilizzato proprio dal protagonista della serie per nascondere dei dati all'interno dello stesso album.

Non ci resta altro da fare quindi che scaricare ed installare il programma ed estrarre la flag da uno dei file audio.

1614935281831.png




[Crypto] A mali estremi, bevi e rimedi (Medium)​

"Se succede qualcosa di brutto si beve per dimenticare;
se succede qualcosa di bello si beve per festeggiare;
e se non succede niente si beve per far succedere qualcosa."
- cit. Charles Bukowski
1024px-Fernet%2BCoke.jpg


La sfida inizia mettendoci a disposisione il seguente file di testo:
Bash:
$ cat A\ mali\ estermi.txt
CmoRShUqZyeYOTiK6dgLsV3cVM3AcosOBnxFpHwrJTs=
gAAAAABgA3OslB2OyZHWImoQFAA05imkr0BU-lvdJl5IyFsZTV9NKGReSbNSY-3ob8vl7JhD3IRQ3SHR8DJS6VmEGSAgnPAvSSeDnvTfCPlqRydMPGeSZaU=

A primo impatto sembra si stratti di due stringhe encodate in base64, ma provando a decodificarle non otteniamo nulla di utile. Senza far riferimento all'hint possiamo ipotizzare si tratti di un messaggio cifrato e della sua chiave, ma senza altre informazioni è difficile venir a capo dell'algoritmo utilizzato.

Partiamo così all'estenuante ricerca di ulteriori informazioni online, fin quando tramite le keyword "base64 symmetric encryption suite" ci imbattiamo in un sito a riguardo di Fernet, un'implementazione che ha lo stesso nome di un noto amaro (ecco il perchè dei riferimenti alcolici). Utilizzando l'hint tutto il processo di ricerca non sarebbe stato necessario poichè sarebbe stato sufficiente cercare "Fernet crypto" su un qualsiasi motore di ricerca.

Scoperta l'implementazione adottata, non ci resta altro da fare che implementare il meccanismo di decodifica in python o utilizzare uno dei tools online

9_1.png
 

Kiddo

Utente Iron
4 Maggio 2021
2
1
0
9
certo, l'unico modo che abbiamo per vedere staticamente le istruzioni eseguite a run-time è utilizzare un decompilatore, come objdump, assieme ai parametri -d per decompilare il binario e -M intel per utilizzare il formato assembly Intel... perchè non ci avevo pensato prima? xD

ora potreste aiutarmi con la mia unica domanda, che non sta cagando nessuno? GRAZIE :D