script di attacco di overflow del buffer

In realtà è codice byte .

Bytecode, also known as p-code (portable code), is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecodes are compact numeric codes, constants, and references (normally numeric addresses) which encode the result of parsing and semantic analysis of things like type, scope, and nesting depths of program objects. They therefore allow much better performance than direct interpretation of source code.

È un programma compilato che è composto da istruzioni che la CPU comprende direttamente. Viene spesso utilizzato per sfruttare le vulnerabilità facendo in modo che il programma in esecuzione vulnerabile esegua questo programma facendo traboccare il suo buffer e rendendo l'indirizzo di ritorno l'indirizzo che è la prima istruzione del programma di codice byte. Spesso si tenta di generare una shell interattiva con, in questo caso si chiama shellcode .

In computer security, a shellcode is a small piece of code used as the payload in the exploitation of a software vulnerability. It is called "shellcode" because it typically starts a command shell from which the attacker can control the compromised machine, but any piece of code that performs a similar task can be called shellcode. Because the function of a payload is not limited to merely spawning a shell, some have suggested that the name shellcode is insufficient.1 However, attempts at replacing the term have not gained wide acceptance. Shellcode is commonly written in machine code.

C'è un buon libro sull'argomento chiamato Manuale dello Shellcoder .

Sfondo:

Quello che vedi è il codice del linguaggio macchina. Sono i valori dei dati che sono istruzioni reali per un chip della CPU.

Quando un programmatore scrive un programma in un linguaggio di livello superiore come C o C ++, gli strumenti chiamati compilatori prendono quelle istruzioni e le trasformano nel linguaggio macchina. Normalmente, i programmatori non si preoccupano di quelle istruzioni in linguaggio macchina. Ma i programmatori che scrivono questi compilatori si preoccupano molto delle istruzioni della macchina, ovviamente, e così anche le persone che stanno scrivendo una versione ottimizzata di una routine (qualcosa che potrebbe essere inefficiente in un linguaggio di alto livello). Lo stesso fanno gli hacker.

Anche quando i programmatori hanno un motivo per preoccuparsi delle istruzioni della macchina, non scrivono il loro codice in valori di byte grezzi di difficile lettura come questo. Invece, i programmatori useranno un set di istruzioni mnemoniche chiamato un linguaggio assembler. I mnemonici sono solo nomi abbreviati che rappresentano i numeri che vedi qui. Un semplice esempio è MOV CL,0x38 che sposta il valore byte 38 nella metà bassa del registro denominato C. Sotto i coperchi, "MOV CL" è un byte di linguaggio macchina con il valore di b1.

Uno strumento chiamato disassemblatore ti aiuterà a tradurre dalle cifre che vedi nel linguaggio assembly che gli umani possono leggere più facilmente. Puoi inserire questi byte nel link e dare un'occhiata alle istruzioni che causeranno l'esecuzione della CPU. Il tuo campione conteneva queste istruzioni:

.data:0x00000006    b879c464b7  mov eax,0xb764c479
.data:0x0000000b    33c9        xor ecx,ecx
.data:0x0000000d    b138        mov cl,0x38
.data:0x0000000f    5d          pop ebp
.data:0x00000010    83c504      add ebp,0x4
.data:0x00000013    314513      xor DWORD PTR [ebp+0x13],eax
.data:0x00000016    033cd7      add edi,DWORD PTR [edi+edx*8]
.data:0x00000019    864242      xchg BYTE PTR [edx+0x42],al
.data:0x0000001c    3f          aas
.data:0x0000001d    cf          iret

(Puoi vedere le istruzioni di assembler mnemoniche sopra includono mov, xor, pop, ecc.)

Tuttavia, preparatevi ad altre delusioni. Hai selezionato un attacco molto sofisticato che utilizza una tecnica chiamata Return Oriented Programming (ROP), quindi la maggior parte dei byte non ha senso per noi perché non sono istruzioni della CPU. Sono per lo più dati che contengono parametri e indirizzi di altre routine. Ciò rende particolarmente difficile il reverse engineering di questo exploit senza molto lavoro.

Più vicino alla tua risposta:

Più alla tua domanda, un buffer overflow funziona a causa del modo in cui la memoria viene utilizzata sull'architettura x86. Quando un programmatore consente alla memoria di essere sovrascritta, i dati extra vanno proprio sopra a qualcos'altro. Se scrivi il numero corretto di byte, qualcos'altro è il puntatore di ritorno della funzione. Se fornisci una routine di linguaggio macchina nei dati del buffer, quindi sovrascrivi il puntatore di ritorno per tornare al tuo buffer (invece della sua normale posizione di ritorno), quando la CPU lo restituirà eseguirà il tuo codice invece del codice che intendeva eseguire.

Il codice macchina che inganna il puntatore dell'istruzione per andare dove l'hacker ha bisogno di andare è indicato come codice di exploit. Il codice exploit è scritto in modo personalizzato per sfruttare ogni bug specifico.

Il codice che fa qualcosa di utile per l'hacker è chiamato payload. I payload sono generalmente pre-pensati da qualcun altro e sono spesso una copia e incolla dell'hacker. Un payload molto comune è chiamato "shellcode", che è un'istruzione della macchina che fornisce una shell di comando all'attaccante.

Un exploit ha bisogno di entrambi. Una volta che l'exploit ha il controllo, invoca lo shellcode, fornendo all'hacker l'accesso che desidera.

Una buona risorsa:

C'è un tutorial on-line ben documentato di un simile exploit qui: link Attenzione, questo è cose piuttosto profonde e l'autore di quella pagina presuppone che tu capisca i fondamenti del funzionamento della CPU, stack, puntatori, linguaggi di assemblaggio, lingue della macchina, ecc.