Archivo de la categoría: Seguridad

Debian: Como correr un daemon en el arranque del sistema (Ej. Reglas de iptables)

pacamanfirewallPruebas realizadas desde: GNU/Linux Debian “Wheezy” (7.4)

Objetivo: En este tutorial trataremos de crear un script que se ejecute al arrancar nuestro sistema GNU/Linux, el script consiste en (aunque podemos hacer scripts que hagan otras cosas) reglas de iptables de un firewall stateful que acepta de ENTRADA: ICMP echo-request, peticiones a puerto 80 (servidor web) y de SALIDA: ICMP echo-request, con peticiones a servicios de uso común para poder navegar sin muchas restricciones (puerto 80, 53, 21, 22, 443).

Bueno, habrá veces que queramos ejecutar un script cuando arranca nuestro sistema Linux, por ejemplo, si queremos cargar reglas para nuestro firewall (iptables). El primer programa que corre Linux al arrancar es “init”, su archivo de configuración se encuentra en /etc/inittab, las primeras líneas del archivo serían algo como lo siguiente:

# The default runlevel.
id:2:initdefault:

# Boot-time system configuration/initialization script.
# This is run first except when booting in emergency (-b) mode.
si::sysinit:/etc/init.d/rcS

Cada “runlevel” describe un estado de la máquina, por decir 0 es para halt (cuando se detiene), 1 es para single-user, de 2 a 5 es el multiusuario y 6 es cuando se reinicia. Los scripts que se ejecutan por cada runlevel se encuentran ubicados en rutas específicas, por ejemplo para el runlevel 0, en /etc/rc0.d … de manera genérica sería algo como /etc/rc#.d donde # sería el número del runlevel (0 a 6)… si queremos conocer nuestro runlevel podemos ejecutar en la terminal:

root:~# runlevel

Ahora bien, los demonios (daemons) que se ejecutan al inicio se encuentran ubicados en /etc/init.d, si queremos crear un script propio que se ejecute al arranque deberemos crearlo en esa ruta, por decir:

root:~# cd /etc/init.d
root:/etc/init.d# touch fw
root:/etc/init.d# chmod +x fw

Si lo queremos editar desde consola podemos usar nano, vi, etc:

root:/etc/init.d# nano fw

El script propiamente podría ejecutar cualquier cosa, por ejemplo:

#! /bin/bash
echo "Script que se ejecuta al arranque..."

Para habilitar daemons (con configuración default) usaremos el comando “insserv”, ejecutariamos en la terminal algo como:

root:/etc/init.d# insserv fw

Nos manda el siguiente mensaje:

insserv: warning: script 'fw' missing LSB tags and overrides

El problema es que nuestro script debe tener ciertos encabezados “LSB” para que el sistema lo reconozca y sepa que hacer con él. Nuestro script con encabezados quedaría algo como lo siguiente:

#! /bin/bash
### BEGIN INIT INFO
# Provides: fw
# Required-Start: $all
# Required-Stop: $all
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Daemon que carga reglas de fw
# Description: Daemon que carga nuestras reglas de iptables.
### END INIT INFO
echo "Script que se ejecuta al arranque..."

+ Descripción de los encabezados

Ahora si lo volvemos a cargar con insserv:

root:/etc/init.d# insserv fw

Tenemos que si nuestros encabezados están bien ya no marcará error, y la próxima vez que reiniciemos se empezará a ejecutar nuestro demonio (considerando los encabezados LSB).

Para remover un daemon de la ejecución al inicio ejecutamos insserv con -r y el nombre del demonio:

root:/etc/init.d# insserv -r fw

Buscaremos programar nuestro script para que acepte cierto control, por decir, algunos daemons aceptan parámetros, del tipo start|stop|restart … por ejemplo el daemon de apache o del network-manager:

root:~# /etc/init.d/apache2 status
Apache2 is running (pid 2812).
root:~# /etc/init.d/network-manager status
[ ok ] NetworkManager is running.

Volviendo a nuestro script, si lo dejáramos como está se ejecutaría lo mismo independientemente de si se apaga o se inicia la computadora… lo que buscaríamos sería más bien que por decir, al iniciar el ordenador se cargaran las reglas del FW y al apagar se borraran las reglas.

De manera genérica, los pasos ya descritos nos servirán para que se ejecute cualquier script que programemos en el runlevel deseado … sin embargo pongo el código de como quedaría mi firewall gestionando los status de “start, stop y restart”. En otro post explicaré un poco más sobre iptables y firewalls pero por ahora espero con éste código se ejemplifique mejor el concepto de como correr daemons al arranque del sistema:

#! /bin/bash
### BEGIN INIT INFO
# Provides:	fw
# Required-Start: $all
# Required-Stop: $all
# Default-Start: 2 3 4 5
# Default-Stop:	0 1 6
# Short-Description: Carga Reglas de IPTABLES
# Description: Carga reglas de fw
### END INIT INFO

start() {
echo "CONFIGURANDO FIREWALL"

echo "[+] Limpiando reglas"
# Limpiar reglas
iptables -X
iptables -F
iptables -t nat -F

echo "[+] Definiendo politica dura"
# Politica dura
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

# Reglas de entrada
echo "[+] Configurando cadenas de ENTRADA"
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
iptables -A INPUT -p tcp --dport 80 --syn -m state --state NEW -j ACCEPT

# Reglas de salida
echo "[+] Configurando cadenas de SALIDA"
iptables -A OUTPUT -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT

iptables -A OUTPUT -p tcp --dport 80 --syn -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p tcp --dport 21 --syn -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p tcp --dport 53 --syn -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 22 --syn -m state --state NEW -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 --syn -m state --state NEW -j ACCEPT
}

stop() {
echo "[+] Borrando reglas de iptables"
iptables -F
iptables -X

echo "[+] Quitando politica dura"
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
}

#Revisamos permisos de root
if [ "$(id -u)" != "0" ]; then
	echo "Necesarios permisos de root..." 1>&2
	exit 1
fi

# En un case gestionamos start|stop|restart
case "$1" in
	start)
		start
		exit 0
	;;
	stop)
		stop
		exit 0
	;;
	restart)
		stop
		start
		exit 0
	;;
	**)
		echo "Uso: $0 {start|stop|restart}" 1>&2
		exit 1
	;;
esac

Espero sea de utilidad, se puede encontrar más información en el wiki de Debian, dejo los enlaces 🙂

Enlaces de interés:
https://wiki.debian.org/Daemon
http://www.debian.org/doc/debian-policy/ch-opersys.html#s-sysvinit
https://wiki.debian.org/LSBInitScripts/DependencyBasedBoot?highlight=%28\bCategoryBootProcess\b%29
https://wiki.debian.org/LSBInitScripts

Anuncios

Nmap: Primeros pasos y consejos útiles

nmap

Pruebas realizadas desde: GNU/Linux Debian “Wheezy” (7.2)

Definitivamente Nmap es de las herramientas consagradas cuando se habla de temas de seguridad, utilizada por millones de personas para la administración de redes, inventarios y auditorías de seguridad, es tan popular que incluso ha aparecido en varias películas (The Matrix Reloaded, Die Hard 4, etc).

Como dato histórico, la herramienta fue desarrollada por Gordon “Fyodor” Lyon, y fue liberada en la revista Phrack ed. 51 art. 11, el 1ero de septiembre de 1997. Ver artículo: http://phrack.org/issues.html?issue=51&id=11#article

Podemos descargarlo desde la página oficial: http://nmap.org/download.html

Si estamos en Windows, bastaría con bajar el instalador (en el apartado Microsoft Windows Binaries) y ejecutarlo. Si estamos en un sitema tipo Debian, podemos instalarlo desde los repositorios ejecutando:

# aptitude install nmap

O bien, podemos bajarnos los archivos fuente de Nmap y compilarlo nosotros mismos.

Para correr un escaneo en Nmap bastaría con ejecutar desde la terminal (Ojo! la mayoría de escaneos interesantes requieren permisos de root/Administrador):

# nmap x.x.x.x

x.x.x.x -> Dirección IP, ej: 192.168.1.10

En la IP, Nmap también soporta notación CIDR, ej.:

# nmap 192.168.1.0/24

Un escaneo de éste tipo realizaría un SYN scan a 255 direcciones (de 0 a 255)

Otro formato soportado es el siguiente:

# nmap 192.168.1.1-254

Realiza el escaneo del host 1 al 254.

Con Nmap tendremos una gran cantidad de posibilidades para el análisis de una red, de manera genérica, podemos definir los pasos de un escaneo (3) de la siguiente manera y que podemos llevar a cabo con Nmap:

Paso 1: Identificar los sistemas activos

Por decir, podríamos hacer un Ping Sweep, ésto es, un barrido de pings, a un rango de IPs. Para hacerlo podemos ejecutar desde la terminal:

# nmap -sP 192.168.1.0/24

El resultado arrojaría la lista de dispositivos que responden al ping (activos). Sin embargo, un escaneo de éste tipo es algo ruidoso y no es 100% confiable (por la capacidad de los equipos para deshabilitar los pings). Hay una segunda opción que podemos considerar, el List Scan, el cual solo hace una resolución DNS inversa para obtener los nombres de hosts de las IPs haciendo la petición al servidor DNS default o alguno especificado por nosotros, ejemplo:

# nmap -sL 192.168.1.0/24

Haría una resolución DNS de 255 hosts en la red de máscara natural. Toma el servidor DNS default de nuestra máquina, si estamos en un GNU/Linux como Debian, podemos revisar cuál es el valor default en el archivo resolv.conf :

$ cat /etc/resolv.conf
# Generated by NetworkManager
domain lan
search lan
nameserver 192.168.1.254

Si queremos especificar un servidor DNS podríamos hacer algo como:

# nmap -sL yahoo.com --dns-server 8.8.8.8

Lo cual es una resolución del nombre de dominio yahoo.com (si, Nmap no solo acepta IPs, si no también nombres de host/dominio) a través del servidor DNS de Google (8.8.8.8).

nmap0

Paso 2: Descubrir puertos abiertos

Una vez que conocemos qué dispositivos están activos en nuestra red, podemos proceder a hacer un análisis más detallado de cada host, en el segundo paso del escaneo intentaremos obtener la lista de puertos que tiene activos un host, lo podemos hacer ejecutando:

# nmap -sS -v -T4 x.x.x.x

x.x.x.x -> Dirección IP (192.168.1.10), rango de red (192.168.1.0/24), nombre de host (yahoo.com) y variantes

-sS -> Cuando pasamos el parámetro -sS especificamos que el escaneo a realizar es un SYN Scan, ésto es, recordando el Three-Way-HandShake, que Nmap mandará un paquete TCP con la bandera SYN activada, si el puerto está abierto recibirá como respuesta del host un SYN+ACK y si está cerrado un RST, es un escaneo Half-Open por que se corta en éste punto la comunicación y no se termina de completar el Three-Way-HandShake. Otros tipos de escaneos disponibles son: -sT (Full TCP Connect), -sX (XMAS Scan), -sF (FIN Scan), -sA (ACK Scan), etc.

-v -> Opción “verbose”, con este parámetro le indicamos que nos arroje en pantalla más información de los proceso que realiza durante el escaneo, podemos utilizar -vv para indicar que sea “very verbose”

-T4 -> La opción -T# nos permite aumentar o disminuir el tiempo de espera entre el envío de cada sonda (paquete) que manda Nmap al host, las opciones van de 0 (paranoid, cuando estamos en redes muy lentas o queremos evitar activar sistemas IDS, un escaneo de éste tipo es muy tardado) a 5(insane, útil cuando estamos en redes de alta velocidad), podemos dejarlo en -T4 (aggressive) cuando estamos en una red relativamente rápida.

nmap1

Paso 3: Identificar el Sistema Operativo y los servicios

Nmap utiliza técnicas como banner grabbing y OS Fingerprinting para lograr éste objetivo. La técnica para obtener banners puede ser tan sencilla como tratar de ejecutar una sesión telnet a una ip y puerto específico y revisar que mensaje (banner) nos regresa. El OS Fingerprinting, lo realiza observando el comportamiento y las respuestas del host analizado y relacionando ésto con una digamos “base de datos” de comportamiento particular que tienen los diferentes Sistemas Operativos existentes.

Si queremos saber qué servicios (y versiones) corre el host que estamos analizando en los puertos que tiene abiertos, podemos hacer un Version Scan (-sV) con OS detection (-O) activado:

# nmap -sV -O x.x.x.x

x.x.x.x -> Dirección IP, de red, etc.

nmap2

Como podemos ver en la imágen, dentro de mi red local, al escanear mi computadora, vemos que tengo el puerto 80 y el 111 abiertos, con los servicios de http (Apache 2.2.22 en Debian) y rcpbind respectivamente. Sin embargo, tuvo problemas para definir exactamente el tipo de Sistema Operativo.

Éstos son algunos puntos básicos sobre Nmap, espero hablar más a fondo en otras entradas del blog, por ahora lo dejaré en este punto para no hacer muy largo el post.

Debian: Instalar y configurar Wireshark

drivemeca-wireshark-logoDistro: GNU/Linux Debian “Wheezy” (7.2)

Wireshark es un analizador de protocolos muy importante, nos permite hacer el análisis de las tramas que corren por nuestra red, pero no solo nos permitirá ver el tráfico en vivo (o guardar las tramas para posterior análisis), si no que nos permitirá generar estadísticas, e inclusive, podreemos reensamblar flujos TCP, es una herramienta muy útil (y clásica) para administradores de red, al grado que hoy en día incluso existen libros completos y certificaciones del uso de la misma (Wireshark Certified Network Analyst).

Página Oficial: https://wireshark.org/

Pasos a seguir

Para instalar Wireshark en nuestro Debian, lo podremos hacer desde la terminal ya que el programa está disponible en los repositorios de Wheezy:

# su
# aptitude update
# aptitude install wireshark

Ok, ahora cabe hacer un señalamiento … cuando corremos Wireshark, es necesario tener permisos de administrador (root) para poder realizar la captura de paquetes, lo cual se logra al establecer nuestra la NIC (tarjeta de red, puede ser ethernet o wifi) en modo promiscuo. Podemos correr Wireshark desde la consola (aunque también se crea un enlace en eel menú de Aplicaciones > Internet):

# wireshark

Al correrlo por primera vez, es probable que nos encontremos con el siguiente error:

Running as user “root” and group “root”. This could be dangerous. If you’re running Wireshark this way in order to perform live capture, you may want to be aware that there is a better way documented at /usr/share/doc/wireshark-common/README.Debian

La razón es que correr un programa tan grande como lo es Wireshark, con permisos de root, no es una buena práctica y no es seguro. La solución la podemos encontrar si revisamos el manual al que nos enlaza el mensaje de error:

# pager /usr/share/doc/wireshark-common/README.Debian

La herramienta Wireshark en sí no es la que se encarga de hacer la captura de paquetes, lo hace a través de un programa aparte llamado dumpcap, el cual es un programa más ligero que Wireshark en sí.

———————

Método 1:

Entonces, la mejor práctica sería manejar permisos separados. Podemos ajustar ésta configuración ejecutando lo siguiente desde la terminal y como root:

# dpkg-reconfigure wireshark-common

Nos aparecerá un mensaje como el siguiente:

conf_paquetes

Seleccionamos <Sí> y tecleamos Enter, al hacer ésto se habrá creado el grupo de usuarios “wireshark”, el cual le brinda permisos de root a dumpcap, finalmente solo bastaría con asignar los usuarios que queramos puedan ejecutar Wireshark con éstos privilegios, para hacerlo desde la terminal ejecutamos:

# adduser wireshark nombreDeUsuario

ó

# usermod -a -G wireshark nombreDeUsuario

———————

Método 2:

Si queremos hacerlo un poco más manual (al final viene un enlace donde se analiza incluso un tercer método), podemos asignar los permisos y crear el grupo nosotros mismos, la idea es dar a dumpcap los permisos de root. Podemos hacer lo siguiente desde la terminal:

# groupadd wireshark

# usermod -a -G wireshark nombreDeUsuario

# chgrp wireshark /usr/bin/dumpcap

# chmod 4750 /usr/bin/dumpcap

Referencia: https://blog.wireshark.org/2010/02/running-wireshark-as-you/

———————

Una vez hechas éstas configuraciones, podemos correrlo como usuario normal ejecutando:

$ wireshark

Y listo, nuestro Wireshark ya está listo para utilizarse. Si queremos conocer nuestras interfaces de red, podemos ejecutar:

# ifconfig

Podríamos pasarle parámetros a Wireshark, por decir -i nos permitiría seleccionar la interfaz (tarjeta) que se utilizará para escuchar el tráfico, -k le indica a Wireshark que comience el escaneo inmediatamente y -f nos ayudaría a manejar filtros para el tráfico, digamos por decir, que queremos arrancar Wireshark en la interfaz wlan0 escuchando solamente el tráfico HTTP:

$ wireshark -i wlan0 -k -f "tcp port http"

wShar
Wireshark es una herramienta muy poderosa, en próximos posts espero escribir más sobre el uso de la misma. Por ahora dejaré el post hasta aquí 🙂