Este blog ya no está activo, sigue informándote aquí:

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

domingo, 15 de mayo de 2016

Slides.- Detectando Rootkits a través de volcados de memoria.

Supongo que ya sabréis por mi blog lo que me gusta hacer de perito e investigar en volcados de memoria. Pero si algo tengo pendiente y es básico es aprender a ver procesos en ese volcado que correspondan al comportamiento inusual del sistema que se esté analizando. Así que estas slides me parecen un buen comienzo para retomar el tema.



En estas slides que os recomiendo donde se destripan los siguientes tipos de rootkits:

  • Ring 3 (User-mode) 
  • Ring 0 (Kernel-mode) 
  • Basados en Hardware/Firmware based 
  • Basados en Virtualization.

Enlace a las slides:

Sed buenos ;) 

viernes, 15 de abril de 2016

Paper.- Analisis de Neutrino Exploit Kit

Siempre mola analizar un Exploit kit a ver que nuevas vulnerabilidades contienen o para ver de que manera estaban dando caña a los usuario. Así que, encontrar un paper donde han diseccionado al Exploit Kit Neutriono casi paso a paso es normal que os lo recomiende.


"Estas amenazas no son nuevas y han existido durante los últimos 10 años. No obstante, han evolucionado y ahora son más sofisticados que nunca. Los autores de malware detrás de ellos utilizan diferentes técnicas para evadir su detención y frustrar así la obtención de evidencias. Este paper demuestra un conjunto de herramientas y técnicas para llevar a cabo el análisis de Neutrinos Exploit Kit. El objetivo principal es hacer crecer la experiencia y el conocimiento acerca de la seguridad este tipo de amenazas. Las personas habilitadas para defender a los usuarios y empresas, deben no sólo estudiar estas amenazas, sino que también debe estar profundamente involucrados en su análisis."

Enlace al paper:
Sed Buenos ;)

domingo, 19 de enero de 2014

Canal Pirata de Snifer II - The Rootkit Arsenal

Hola otra semana que venimos la segunda esta vez mas que todo es un regalo al señor dueño del blog, ya que por mucho tiempo andaba con una serie de entradas relacionadas a los Rootkits, lo cual no es porque quiera idolatrarse :$ me encanta este mundo con decirles que ando preparando entradas relacionados a ello para el blog, pero no serán muy extendidas ya que me falta mas que todo tiempo para realizar pero si o si son y estarán realizadas por algo, pero que nos va para que y porque Rootkits simple un paquete para obtener mantener acceso Root!!!!!!..

Se que la explicación no tiene nada que ver, para ello si quieren saber mas del tema dense una vuelta por las siguientes entradas:

Peleándonos con los RootKits
Herramientas

Y para terminar con todo ello, ahora si la recomendación es el libro The Rootkit Arsenal lastimosamente solo vi un capitulo :(, mas que todo por la vagues.. y antes tenia la primera edición recién di con esta segunda  la cual tienen que descargar y darle una mirada.
:) Albert te agradara!!!
Descargar

Regards,
Snifer


lunes, 30 de diciembre de 2013

Pack.- Peleándonos con los RootKits + Algunas Herramientas

A lo largo de estos últimos meses le he dado un repaso chulo a todo el tema de los Root Kits se que faltan muchísimas cosas y que podría haber hecho ejemplos de como hacerlo aunque hubiera muchísimos blogs con ese tipo de entradas. Pero creo, que ya es hora ponerse con otro tipo de cosas así que, os dejo todo el pack y os anexo tres herramientas, las cuales ya he explicado por aquí y van bastante relacionadas con el tema. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
Herramientas
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Sed Buenos ;) 

viernes, 20 de diciembre de 2013

WinDbg.- Interceptar Rutinas A Través De SSDT

Me encanta aprender cada día mas sobre el tema de los Rootkits y su detección. La verdad es que cada vez que me pongo con esta serie de entradas aprendo mucho y la verdad es que me divierto intentándolo entender todo. Hoy entraremos un poco en el mundo de la interceptar de rutinas a través del SSDT. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


SSDT (System Service Descriptor Table) es una mesa de atención de servicios del sistema que contiene las direcciones del punto de entrada de los servicios del núcleo NT. De esta manera, un rootkit puede controlar las rutinas del sistema, la filtración de datos "no deseados".

El flujo de código mediante la rutina de escritura de archivo del SSDT puede ser modificado. Esto puede conducir a la activación de rootkit.

Todos los punteros se hace referencia en SSDT deben hacer referencia a las rutinas implementadas en cualquiera "nt" o biblioteca "win32k". Por lo tanto, al comprobar estos punteros para intercepciones, se debe verificar si los punteros SSDT se refieren en realidad a una de esas áreas de memoria. La secuencia de comandos devuelve una lista de todos los punteros SSDT, así como los módulos de memoria que se refieren. Si el script detecta una biblioteca de terceros en lugar de un sistema de una sola, que marcará estos hechos con la palabra "Hook".

Espero que lo hayáis entendido todo y espero ya yo tambien xD Sed Buenos ;) 

martes, 17 de diciembre de 2013

WinDbg e IDT

Hoy seguimos peleándonos contra RootKits y buceando un poco mas en WinDbg que, como ya dije,  es una de las tantas áreas que no había tocado y tenia ganas de aprender muchísimo mas. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Las aplicaciones en modo de usuario que solicita la ejecución de una función a nivel del sistema tendrán que elevar su nivel de privilegios.Esto se implementa a través de las interrupciones del programa.

En Windows NT, una petición del sistema se inicializa ejecutando el comando "int 2e". El comando "int" hace que la CPU genere una interrupción del programa, en referencia al índice de IDT "2e" y la lectura de los datos de esa dirección. El procesador establece valor del puntero a la desviación de la rutina de servicio de interrupción almacenada en la tabla. (uffff eh xDD ya os dije que las entradas que venían eran duras) Las llamadas al sistema estarán utilizando KiSystemService.

En WinDbg, el "idt! 2e" es el comando muestra el valor del puntero de rutina. Normalmente, el puntero de rutina se establece en la dirección de KiSystemService. Si este no es el caso, la rutina ha sido interceptada.

viernes, 13 de diciembre de 2013

Introducción a WinDbg.

Como sabéis llevo una semana dándole duro al tema de los RootKits y después de haber dado un [rápido repaso por los tipos de volcado de memoria] es el momento de introducirnos en el mundo de WinDbg. Esta sera una serie mas de entradas pero es una parte que yo no había tocado en absoluto y ahora veo que es de lo mas fundamental para pelearnos contra RootKits.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


WinDbg es una herramienta de depuración multifuncional proporcionado por Microsoft con Microsoft Windows. Se puede utilizar para depurar aplicaciones, controladores o el propio sistema operativo en modo kernel. WinDbg ofrece una cómoda (no es todo lo que me gustaría, pero cómoda lo es) interfaz gráfica de usuario. 

WinDbg trabaja exclusivamente con los volcados del tipo crash dump. Aunque, cualquier otro tipo de volcado de memoria se puede convertir a ese formato con [Memory MoonSols].

Enfocando un poco el uso de WinDbg para detectar rootkits en volcados de memoria debemos saber que Windows contiene varias tablas de puntero para manejar petición redirecciones. Estas tablas incluyen IDT (Interrupt descriptor table), SSDT (System Service Descriptor Table) y IAT (Import Address Table). Aunque un rootkit puede modificar cualquier puntero en estas tablas, o cambiar la propia tabla.

Creo que hasta aquí esta bien para todos, Sed Buenos ;) 

miércoles, 11 de diciembre de 2013

Tipos de Volcados De Memoria

Como ya vimos en entradas anteriores los volcados de memoria serán una de las herramientas mas efectivas a la hora de pelarnos con los RootKits.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Los volcados de memoria
Hay cuatro tipos de volcados de memoria:
  • Crash dumps: Son archivos creados cuando el ordenador se bloquea. Todo el contenido de la memoria del sistema se guardan en un archivo.
  • Raw dumps: Son instantáneas completas de la memoria del sistema operativo.
  • hiberfil.sys: Es un archivo utilizado por el sistema operativo para permitir la hibernación. Cuando está en hibernación el sistema operativo, el contenido de la memoria volátil del ordenador se almacena en este archivo. El tamaño de este archivo será igual al tamaño de la memoria RAM del ordenador. Tenemos que tener en cuenta que las zonas asignadas en memoria que se almacenan en el disco duro no se guardan en hiberfil.sys.
  • Vmem: Es un archivo creado por VMware. Este archivo contiene toda la memoria volátil de una máquina virtual (incluido el contenido del archivo de paginación).
Sed Buenos ;) 

martes, 10 de diciembre de 2013

Como Trabajan Algunos Rootkits

Esta entrada viene a colación de la de ayer. Prefiero hacer las entradas mas pequeñas así nos enteramos todo de todo y me sirve para aprender mucho mas. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Rootkits de modo usuario: Este tipo ejecuta su código en el "lease privileged" del modo de usuario. Estos rootkits utilizan extensiones y plugins (por ejemplo, extensiones de explorador de Windows o Internet Explorer) del programa. Los cuales, pueden interceptar las interrupciones o usar un depurador, explotar fallos de seguridad y el uso de la función de enganche "Hook" de API utilizado en los conjuntos de datos de todos los procesos.

Rootkits en modo kernel: Estos se ejecutan en los modos del kernel más privilegiados del sistema. Los cuales pueden incrustarse en los controladores de un dispositivo, modificar directamente los objetos del núcleo (directly modify kernel objects (DKOM)), y/o afectar a la interacción entre los modos de usuario y kernel. 

Gestores de arranque: Este tipo de rootkits modifican el registro de inicio maestro. Master Boot Record (MBR). 

Modo Hypervisor: Algunas CPUs recientes ofrecen un modo de funcionamiento adicional conocida como el modo de hipervisor. Hypervisor es un pequeño núcleo que controla la distribución de recursos entre múltiples sistemas operativos. Funciona un nivel más bajo que los sistemas operativos. En términos x86, este modo se conoce como. En este nivel, los rootkits pueden interceptar las peticiones de hardware del sistema operativo host. En este momento, no hay rootkits conocidos de aplicación de este enfoque en la naturaleza, sólo existen algunas versiones de demostración.

Firmware: Estos rootkits modifican el firmware de ciertos dispositivos, como tarjetas de red, discos duros o el BIOS de la computadora.

Sed Buenos ;) 

domingo, 8 de diciembre de 2013

Clasificación De Rootkits

Hoy vuelvo a la carga con la serie de entrada para entender mejor a nuestros amigos los Rootkits. La entreda de hoy será un poco corta porque, hablando claro, seria demasiado larga para un domingo por la noche. Así que espero que os guste y si queréis mas información os recomiendo mis entradas anteriores donde si que hay bastante chicha. 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Peleándonos con los RootKits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////



En Windows, los rootkits trabajan mediante la modificación de los datos y el código ejecutable en la memoria volátil del ordenador (RAM). Desde este punto de vista, hay dos grupos de rootkits:
  • Los rootkits que modifican la ruta de ejecución;
  • Los rootkits que realizan la manipulación de objetos kernel directa.
Otra clasificación se refiere a las áreas de memoria afectados por rootkits:
  • Rootkits de modo usuario
  • Rootkits en modo kernel
  • Gestores de arranque
  • Modo Hypervisor
  • Firmware
Explicaré una por una en las entradas que vienen, pero creo que esto es lo justo para un domingo por la noche. (xD)

Sed Buenos ;) 

jueves, 5 de diciembre de 2013

Rootkits.- Métodos de Análisis y la Detección

Hoy vamos a echar un vistazo a algunas técnicas de detección de rootkit basados ​​en el análisis de volcado de memoria y otros métodos, va a ser una entrada bastante teórica así que voy a ponerme un poco profe con todo esto. 


Análisis del volcado de memoria

Los volcados de memoria [contienen instantáneas estáticas de la memoria volátil del ordenador] (RAM). Es posible crearlo para un solo proceso, núcleo del sistema o todo el sistema. Mediante el análisis de estos volcados, los examinadores pueden garantizar un entorno de trabajo limpio y sin resistencia activa desde el rootkit. Las técnicas utilizadas en el análisis de volcado de memoria también pueden ser desplegados en un sistema vivo, con restricciones. Normalmete la extracción se offline para evitar cualquier conexión que pueda interferir en nuestro análisis. 

Técnicas de detección de rootkits

Hay varias técnicas disponibles para detectar rootkits.

Análisis basado en firmas

Este método utiliza firmas características (una secuencias de bytes fija) de rootkits conocidos. La mayoría de las herramientas anti-virus utilizan firmas extraídas de muestas de rootkit (por ejemplo, de archivos o de paquetes de red). Además, hay modelos heurísticos y de comportamiento sobre la base de ciertas actividades típicas de un rootkits (por ejemplo, un uso agresivo de un determinado puerto de red en el equipo).

Detección Intercepciones

Windows utiliza tablas de puntero para redirigir las solicitudes del sistema, por ejemplo, IDT (Interrupt Descriptor Table), SSDT (System Service Descriptor Table), IAT (Import Address Table). Rootkits pueden sustituir o modificar estas tablas para especificar sus propios controladores para ciertas interrupciones. Como resultado, las solicitudes de determinadas funciones del sistema operativo siempre se entregarán al rootkit, lo que permite que el rootkit para detectar y contrarrestar los esfuerzos de detección. 

Comparando datos de distintas fuentes

Con el fin de enmascarar su presencia, los rootkits pueden alterar ciertos datos que son devueltos al examinador. Por ejemplo, mediante la sustitución de la API de alto nivel con sus propios controladores. Por lo tanto, es posible detectar su presencia mediante la comparación de resultados devueltos con llamadas del sistema de alto nivel y  de bajo nivel.

Otra variación de este método se basa en la comparación de la memoria de procesos cargados en la memoria volátil del ordenador con el contenido del archivo almacenado en el disco duro (herramientas como [RootkitRevealer]  están utilizando este enfoque).

Comprobación de integridad

Una firma digital (por ejemplo, con una función hash criptográfica) se calcula para cada biblioteca del sistema en el comienzo mismo (cuando el sistema está limpio, que no suele ser siempre xD). Después de eso, las bibliotecas se pueden comprobar por alteración código. Herramientas como [Tripwire]  están utilizando este método.

Se que es una entrada algo pesada pero me apetecía. Sed Buenos ;) 

miércoles, 4 de diciembre de 2013

Introducción A Los RootKit

El término rootkit se refiere, originariamente, a un grupo de pequeñas herramientas practicas que permiten a los desarrolladores mantener el root (el modo administrador) en las  funciones del sistema operativo. 

En esencia, los rootkits son herramientas que utilizan ciertas técnicas a los mecanismos de protección del sistema de derivación y algoritmos para enmascarar su presencia en el sistema. Como casi cualquier tecnología, los rootkits pueden ser utilizados con fines maliciosos y legítimas. Por mucho que sufrir la asociaciones con malware, todavía se utilizan rootkits (aunque de una manera bastante polémica) por empresas legítimas. Por ejemplo, Sony utiliza para incrustar la tecnología basada en rootkit en varios títulos de CD de audio en un intento de evitar la duplicación no autorizada. Al final resultó que, utilizando rootkits no era la mejor idea después de todo, y después de varias demandas de la compañía se vio obligada a recordar títulos de CD afectados


la mayoría de los rootkits se utilizan en combinación con los virus, troyanos y gusanos informáticos con fines maliciosos de forma explícita. Por lo tanto, los desarrolladores de antivirus crean una variedad de herramientas para el descubrimiento de rootkits. Hay varios tipos de herramientas anti-rootkit basado en varios principios.
  • Firewalls el tráfico de red de filtrado y la detección de las actividades de red sospechosas;
  • Sistemas de detección de intrusiones (IDS)  
  • Sistemas de prevención de intrusiones (IPS) 
en otras entradas aprenderemos a analizarlos y a entenderlos. Sed Buenos ;)