CryptKeeper Protege tus archivos de una manera segura

14 diciembre 2012

 


CryptKeeper Nuestra información segura con esta aplicación que permite proteger nuestras carpetas encriptando su contenido y así permanece seguro de mirones y al momento de ocultar las p0rn jeje 

La instalaremos dependiendo que distribución de GNU/Linux que usemos por ejemplo Ubuntu, Fedora y ArchLinux.

Para Ubuntu sera:

sudo apt-get install cryptkeeper

Para Fedora sera:

sudo yum install cryptkeeper

Para Archlinux sera:

sudo pacman -S cryptkeeper

Una vez instalada nos dirigimos abrir CryptKeeper > / Applications Menu / System / Cryptkeeper / y como ven en la imagen.

Damos clic izquierdo sobre el icono de cryptkeeper y seleccionamos “Encriptar Nueva Carpeta” como muestra la imagen de abajo.

Creamos una carpeta en el directorio home y le damos el nombre que queramos, yo use el nombre de “Personal” una vez hecho esto nos pedira que ingresemos el nombre de la carpeta que sera cifrada en mi caso “Privada” y damos clic en donde dice Forward.

Ahora nos pedira que ingresemos una contraseña misma que nos pedira mas adelante cuando quieramos abrir dicha carpeta cifrada para continuar damos clic nuevamente en Forward.

Aqui nos dice que nuestra carpeta cifrada ha sido creada y procedemos a darle clic en OK

Ahora solo tenemos que montar/desmontar la carpeta cifrada.

Al momento de montar la carpeta cifrada nos pedira que ingresemos la contraseña

En este último paso damos clic derecho sobre el icono cryptkeeper y damos en “Preferencias” para configurar el navegador de ficheros, si estamos usando Gnome entonces sera “nautilus” en mi caso uso XFCE así que sera “thunar 

NOTA:  El hecho de que sea encriptada no impide que se pueda borrar la carpeta asi como su contenido de la misma.

 

Fuente : http://ba-k.com/threads/3065003-CryptKeeper-Protege-tus-archivos-de-una-manera-segura

 

Avatar de Pinguinux


Instalar Ntop en Centos 6

10 abril 2012

Encontré un buen manual para la instalación de ntop en centos, solo le corregí algo en la ultima parte y también pongo la pagina de donde lo encontré

yum install cairo-devel libxml2-devel pango-devel pango libpng-devel
yum install freetype freetype-devel libart_lgpl-devel wget gcc make
yum install perl-ExtUtils-MakeMaker
cd /opt
wget 
http://oss.oetiker.ch/rrdtool/pub/rrdtool-1.4.5.tar.gz
tar -zxvf rrdtool-1.4.5.tar.gz
cd rrdtool-1.4.5
./configure -prefix=/usr/local/rrdtool
make
make install

cd ..

yum install libpcap libpcap-devel gdbm gdbm-devel
yum install libevent libevent-devel
wget 
http://geolite.maxmind.com/download/geoip/api/c/GeoIP-1.4.8.tar.gz
tar -zxvf GeoIP-1.4.8.tar.gz
cd GeoIP-1.4.8
./configure
make
make install

cd ..

yum install libtool automake autoconf
wget 
http://downloads.sourceforge.net/project/ntop/ntop/Stable/ntop-4.1.0.tar.gz
tar zxvf ntop-4.1.0.tar.gz
cd ntop-4.1.0
./autogen.sh -prefix=/usr/local/ntop
make
make install

cd ..

useradd -M -s /sbin/nologin -r ntop
chown ntop:root /usr/local/ntop
chown ntop:ntop /usr/local/ntop/share/ntop

###esto es para generar el password ######

/usr/local/ntop/bin/ntop -A

###Para correr la apliccion de ntop en demonio#####

/usr/local/ntop/bin/ntop -d -L -u ntop -P /usr/local/ntop –skip-version-check –use-syslog=daemon

Autor del manual: http://ryanwoon.wordpress.com/2011/08/20/install-ntop-in-centos-6/  como les comente hice correcciones niminas en el los ultimos parrafos donde se crea la contraseña y se corre el demonio de ntop



IPTABLES incluyendo para proxy transparente

2 septiembre 2009

Supongamos que este firewall tiene alguna función adicional: es un servidor proxy y además es un servidor de correo. Darle funcionalidades de este tipo a un firewall no es recomendable, porque si no se protegen bien esos puertos o si no está actualizado el software pueden entrar en el firewall a base de xploits comprometiendo TODA la red local. De todas formas muchas empresas no se pueden permitir o no quieren tener una máquina para cada cosa, bastante les cuesta a muchas poner un firewall. Por tanto: si se añaden servicios que deben estar abiertos al público en el propio firewall, nos la estamos jugando, y se recomienda pasar el servicio a otra máquina

#!/bin/sh
## SCRIPT de IPTABLES – ejemplo del manual de iptables
## Ejemplo de script para firewall entre red-local e internet
## con servicios abiertos de puerto 25, 110, y 1723
## Pello Xabier Altadill Izura
## http://www.pello.infopello@pello.info

echo -n Aplicando Reglas de Firewall…

## FLUSH de reglas
iptables -F
iptables -X
iptables -Z
iptables -t nat -F

## Establecemos politica por defecto
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT

## Empezamos a filtrar
## Nota: eth0 es el interfaz conectado al router y eth1 a la LAN
# El localhost se deja (por ejemplo conexiones locales a mysql)
iptables -A INPUT -i lo -j ACCEPT

# Al firewall tenemos acceso desde la red local
iptables -A INPUT -s 192.168.10.0/24 -i eth1 -j ACCEPT

# Puertos 80 redirigimos al 3128 del squid
# Para la clase 192.168.0.x 192.168.2.x
iptables -t nat -A PREROUTING -s 192.168.0.0/24 -i eth1 -p tcp –dport 80 -j REDIRECT –to-port 3128

# O podemos poner tambien esta regla

iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 80 -j DNAT –to 192.168.1.2:3128

## Abrimos el acceso a puertos de correo

# Abrimos el puerto 25, hay que configurar bien el relay del servidor SMTP
iptables -A INPUT -s 0.0.0.0/0 -p tcp –dport 25 -j ACCEPT
# Abrimos el pop3
iptables -A INPUT -s 0.0.0.0/0 -p tcp –dport 110 -j ACCEPT

# Y abrimos el puerto pptpd para la ip del adsl de casa del jefe
iptables -A INPUT -s 211.45.176.24 -p tcp –dport 1723 -j ACCEPT

## Ahora con regla FORWARD filtramos el acceso de la red local
## al exterior. Como se explica antes, a los paquetes que no van dirigidos al
## propio firewall se les aplican reglas de FORWARD

# Aceptamos que vayan a puertos 80
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp –dport 80 -j ACCEPT
# Aceptamos que vayan a puertos https
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp –dport 443 -j ACCEPT

# Aceptamos que consulten los DNS
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p tcp –dport 53 -j ACCEPT
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -p udp –dport 53 -j ACCEPT

# Y denegamos el resto. Si se necesita alguno, ya avisaran
iptables -A FORWARD -s 192.168.10.0/24 -i eth1 -j DROP

# Ahora hacemos enmascaramiento de la red local
# y activamos el BIT DE FORWARDING (imprescindible!!!!!)
iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -o eth0 -j MASQUERADE

# Con esto permitimos hacer forward de paquetes en el firewall, o sea
# que otras máquinas puedan salir a traves del firewall.
echo 1 > /proc/sys/net/ipv4/ip_forward

## Y ahora cerramos los accesos indeseados del exterior:
# Nota: 0.0.0.0/0 significa: cualquier red

# Cerramos el rango de puerto bien conocido
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp -dport 1:1024 -j DROP
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p udp -dport 1:1024 -j DROP

# Cerramos un puerto de gestión: webmin
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp –dport 10000 -j DROP

# Y cerramos el puerto del servicio PPTPD, solo abierto para el jefe.
iptables -A INPUT -s 0.0.0.0/0 -i eth0 -p tcp –dport 1723 -j DROP

echo ” OK . Verifique que lo que se aplica con: iptables -L -n”

# Fin del script


Seguridad IP (IPSec)

29 julio 2009
Tutorial creado por Kurt Seifried. Extraido de: http://es.tldp.org/Manuales-LuCAS/GSAL/gsal-19991128-htm/
16 de Febrero de 2006

Seguridad IP (IPSec) es el cifrado del tráfico de red. No se puede cifrar la información de la cabecera ni el trailer (p. ej. la dirección IP y puerto de donde viene el paquete y su destino, los checksums de CRC, etc.), pero se puede cifrar la carga útil. Esto permite asegurar protocolos como POP/WWW sin tener que cambiarlos de ninguna forma, puesto que el cifrado se hace en el nivel IP. También permite conectar de forma segura LANs y clientes entre sí, sobre redes inseguras (como Internet). En la actualidad, IPSec para Linux está en fase de pruebas, sin embargo ya se han lanzado varias versiones estables, y yo mismo he desarrollado servidores seguros basados en IPSec. IPSec es un standard, y parte el protocolo IPv6, de modo que ya se puede comprar software IPSec para Windows 95/98/NT, Solaris y otros Unix, que interoperarán con Linux IPSec.

Soporte IPSec del kernel

Para utilizar IPSec es necesario tener soporte IPSec en el kernel. Desafortunadamente, ninguna distribución Americana de Linux puede exportar criptografía robusta fuera de Norte América, de modo que en general, suelen escoger no incluirla en absoluto, de las distribuciones extranjeras de Linux, en la actualidad ninguna viene con soporte IPSec dentro del kernel. Es necesario conseguir el código fuente del kernel (recomiendo la 2.2.10, la más reciente a la hora de escribir esto), y el código fuente del Linux IPSec, disponible en: http://www.xs4all.nl/~freeswan/

Instala el fuente del kernel (generalmente en /usr/src/linux) y compila el nuevo kernel, instálalo, arráncalo y pruébalo. Asegúrate de que tus redes funcionan correctamente, si no funcionan, hacer que lo haga IPSec será imposible. Ahora hay que descargar la última instantánea de IPSec (la versión 1.0 NO funcionará con los kernels 2.2.x). Después ir a /usr/local/src (o dondequiera que hayas puesto el código fuente de tus programas), desempaquetar el fuente y ejecutar el programa de instalación (make menugo suele ser lo habitual para la configuración basada en ncurses). Lo cual parcheará los ficheros del kernel, luego ejecuta la configuración del kernel y después construye las herramientas IPSec y el kernel.

cd /usr/local/src/

tar –zvvxf /path/del/tarball/snapshot.tar.gz

chown –R root:root freeswan-snap1999Jun14b

cd freeswan-snap1999Jun14b

make menugo

asegúrate de guardar la configuración del kernel, incluso aunque se hayan elegido las opciones, no han sido guardadas. También tendrás que reconstruir el kernel, puesto que el comando “make menugo” ejecuta un “make zImage”, lo cual suele fallar, debido a los grandes tamaños del kernel de la 2.2.x. Una vez que se ha hecho la compilación, debería dar uno o dos mensajes de error, simplemente haz:

cd /usr/src/linux

make bzImage

cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.2.10-ipsec

Ahora hay que editar lilo.conf, ejecutar lilo de nuevo y reiniciar para hacer uso del nuevo kernel.

lilo.conf debería tener el siguiente aspecto:

boot=/dev/hda

map=/boot/map

install=/boot/boot.b

prompt

timeout=100

image=/boot/vmlinuz-2.2.10-ipsec

label=linux-ipsec

root=/dev/hda1

read-only

image=/boot/vmlinuz-2.2.10

label=linux

root=/dev/hda1

read-only

vuelve a ejecutar lilo y verás:

linux-ipsec *

linux

después reinicia y deberías estar ejecutando el kernel 2.2.10 con soporte IPSec. A medida que la máquina se reinicia y empieza el IPSec se verán varios errores, por defecto IPSec está configurado para utilizar el interfaz eth999, el cual por supuesto no existe. Deberías añadir /usr/local/lib/ipsec en la frase del path o si no tendrás que escribir el path completo un montón.

Configuración de redes IPSec

Tendrás que habilitar el TCP-IP forwarding en el servidor de enlace, en Red Hat Linux se hace cambiando la línea de /etc/sysconfig/network:

FORWARD_IPV4=”false”

por:

FORWARD_IPV4=”yes”

o se puede habilitar vía sistema de ficheros en /proc:

cat 1 > /proc/sys/net/ipv4/ip_forward

Puesto que la mayoría de la gente tiene por defecto políticas de denegación de paquetes de forwarding, tendrás que permitir que los paquetes atraviesen la rede remota / máquina de tu red / máquina y vice versa. Además de esto, cualquier regla de enmascaramiento para redes internas que también estén usando IPSec debe venir después de las reglas que permiten el tráfico IPSec, o la máquina intentará enmascarar los paquetes, en lugar de pasarlos al IPSec.

El siguiente ejemplo es para dos redes protegidas (usando direcciones IP no rutables, escondidas tras máquinas Linux haciendo enmascaramiento de IPs) conectadas vía Internet:

10.0.0.2 192.168.0.2

10.0.0.1 192.168.0.1

1.2.3.4 5.6.7.8

1.2.3.1 5.6.7.1

2.3.4.5 6.7.8.9

INTERNET

Conexión manual de llaves

Primero configuraremos un enlace utilizando la conexión manual de llaves (por simplicidad), hay que editar ipsec.conf, y las reglas del cortafuegos. La mayoría de las opciones por defecto del fichero ipsec.conf son correctas, pero hay que cambiar lo siguiente:

conn ejemplo

type=tunnel

left=

leftnexthop=

leftsubnet=

right=

rightnexthop=

rightsubnet=

spibase=0x200

esp=3des-md5-96

espenckey=

espauthkey=

reemplaza la espenckey y la espauthkey con las nuevas llaves (utilizando ranbits para generar un número, recuerda dejar el 0x por delante, que especifica que es un número hexadecimal) de modo que es algo así:

conn mi-tunel

type=tunnel

left=1.2.3.4

leftnexthop=1.2.3.1

leftsubnet=10.0.0.0/24

right=5.6.7.8

rightnexthop=5.6.7.1

rightsubnet=192.168.0.0/24

spibase=0x200

esp=3des-md5-96

espenckey=cualquier_llave_de_autentificación (ranbits 192)

espauthkey=cualquier_otra_llave (ranbits 128)

Una vez que has acabado, copia los ficheros ipsec.conf e ipsec.secrets desde la máquina en que los editaste hasta el otro servidor, de forma segura. Ahora, lo único que queda es añadir reglas al cortafuegos para que no se enmascaren los paquetes (en lugar de eso lo que queremos es redirigirlos, hacer un forward).

En el servidor 1.2.3.4 se deberían añadir las siguientes reglas:

ipchains –A forward –p all –j ACCEPT –s 10.0.0.0/24 –d 192.168.0.0./24

ipchains –A forward –p all –j ACCEPT –s 192.168.0.0/24 –d 10.0.0.0/24

asegúrate de que estas reglas aparecen antes de la regla de enmascaramiento, algo así:

#

# FORWARD RULES

#

ipchains –P forward DENY

#

ipchains –A forward –p all –j ACCEPT –s 10.0.0.0/24 –d 192.168.0.0/24

ipchains –A forward –p all –j ACCEPT –s 192.168.0.0/24 –d 10.0.0.0/24

ipchains –A forward –p all –j MASQ –s 10.0.0.0/24 –d 0.0.0.0/0

Y en el servidor 5.6.7.8 se repetiría el proceso:

ipchains –A forward –p all –j ACCEPT –s 192.168.0.0/24 –d 10.0.0.0/24

ipchains –A forward –p all –j ACCEPT –s 10.0.0.0/24 –d 192.168.0.0/24

asegúrate de que estas reglas aparecen antes de la regla de enmascaramiento, algo así:

#

# FORWARD RULES

#

ipchains –P forward DENY

#

ipchains –A forward –p all –j ACCEPT –s 192.168.0.0/24 –d 10.0.0.0/24

ipchains –A forward –p all –j ACCEPT –s 10.0.0.0/24 –d 192.168.0.0/24

ipchains –A forward –p all –j MASQ –s 192.168.0.0/24 –d 0.0.0.0/0

Ahora deberías ser capaz de establecer el túnel ipsec manualmente en ambas máquinas, y las máquinas de la Red A deberían ser capaces de hablar con las máquinas de la red B sin problemas.

ipsec manual –up mi-tunel

lo cual mostraría una salida similar a:

/usr/local/lib/ipsec/spi: message size is 36

/usr/local/lib/ipsec/spi: message size is 132

/usr/local/lib/ipsec/spi: message size is 132

Para probarlo, haz un ping a 192.168.0.2 desde el cliente 10.0.0.2. Si funciona, lo has configurado correctamente. Si no funciona, verifica tu red para asegurarte de que 1.2.3.4 puede ver 5.6.7.8 y que está habilitado el TCP-IP forwarding, y asegúrate de que no hay reglas del cortafuegos que estén bloqueando paquetes o intentando enmascararlos. Una vez que has establecido y probado la conexión con éxito, deberías pasar a la conexión automática de llaves (especialmente en entornos de producción).

Conexión automática de llaves

Si se intenta usar IPSec en un entorno de producción, la conexión manual de llaves es una mala idea, en términos generales. Con la conexión automática se tiene un secreto compartido de 256bit que se copia a ambos lados del túnel, el cual se utiliza durante el intercambio de llaves para asegurarse que no se dan ataques del tipo “man in the middle, hombre de por medio”. Con la conexión automática, la vida media de una llave es de 8 horas, lo cual se puede ajustar a cualquir intervalo, y si alguien se las arregla para atacar por fuerza bruta la llave, sólo será válida durante ese período de tráfico de 8 horas. El ejemplo siguiente se construye sobre el anterior:

ipsec.secrets contiene el secreto compartido. Este fichero debe ser puesto a salvo a toda costa. Para una conexión entre los servidores 1.2.3.4 y 5.6.7.8 se necesitaría una línea como:

1.2.3.4 5.6.7.8

“0xa3afb7e6_20f10d66_03760ef1_9019c643_a73c7ce0_91e46e84_ef6281b9_812392bf”

Esta línea necesita estar en ambos ficheros ipsec.secrets. Después se necesitaría editar la configuración del túnel en ipsec.conf por la siguiente:

conn mi-tunel

type=tunnel

left=1.2.3.4

leftnexthop=1.2.3.1

leftsubnet=10.0.0.0/24

right=5.6.7.8

rightnexthop=5.6.7.1

rightsubnet=192.168.0.0/24

keyexchange=ike

keylife=8h

keyingtries=0

Entonces se arrancaría el demonio pluto, intenta conectar al demonio Pluto desde el otro extremo del túnel, y establece una conexión. Una advertencia, Pluto se ejecuta en el puerto 500, udp, de modo que lo más probable es que tengas que abrir un hueco en el cortafuegos para permitirle pasar:

ipchains –A input –p udp –j ACCEPT –s 0.0.0.0/0 –i eth0 –d 0.0.0.0/0 500

Encuentro conveniente el uso de la clave “%search” en lugar de listar el túnel a arrancarse, añadiendo:

auto=start

para cada configuración del túnel y editar el ipsec.secrets:

plutoload=%search

plutostart=%search

Lo cual a la larga te hará la vida más fácil. Si todo va bien, deberías ver algo parecido a esto en /var/log/messages:

|| Jun 26 02:10:41 server ipsec_setup: Starting FreeS/WAN IPSEC… Jun 26 02:10:41 server ipsec_setup: /usr/local/lib/ipsec/spi: message size is 28 Jun 26 02:10:41 server ipsec_setup: KLIPS debug ‘none’ Jun 26 02:10:41 server ipsec_setup: KLIPS ipsec0 on eth0 1.2.3.4/255.255.255.0 broadcast 24.108.11.255 Jun 26 02:10:42 server ipsec_setup: Disabling core dumps: Jun 26 02:10:42 server ipsec_setup: Starting Pluto (debug ‘none’): Jun 26 02:10:43 server ipsec_setup: Loading Pluto database ‘mi-tunel’: Jun 26 02:10:44 server ipsec_setup: Enabling Pluto negotiation: Jun 26 02:10:44 server ipsec_setup: Routing for Pluto conns ‘mi-tunel’: Jun 26 02:10:45 server ipsec_setup: Initiating Pluto tunnel ‘mi-tunel’: Jun 26 02:10:45 server ipsec_setup: 102 “mi-tunel” #1: STATE_MAIN_I1: initiate Jun 26 02:10:45 server ipsec_setup: 104 “mi-tunel” #1: STATE_MAIN_I2: from STATE_MAIN_I1; sent MI2, expecting MR2 Jun 26 02:10:45 server ipsec_setup: 106 “mi-tunel” #1: STATE_MAIN_I3: from STATE_MAIN_I2;sent MI3, expecting MR3 Jun 26 02:10:45 server ipsec_setup: 003 “mi-tunel” #1: STATE_MAIN_I4: SA established Jun 26 02:10:45 server ipsec_setup: 110 “mi-tunel” #2: STATE_QUICK_I1: initiate Jun 26 02:10:45 server ipsec_setup: 003 “mi-tunel” #2: STATE_QUICK_I2: SA established Jun 26 02:10:46 server ipsec_setup: …FreeS/WAN IPSEC started ||

Y en el fichero /var/log/secure se debería ver algo parecido a esto:

|| Jun 26 02:10:42 server Pluto[25157]: Starting Pluto (FreeS/WAN Version snap1999Jun14b Jun 26 02:10:42 server Pluto[25157]: added connection description “mi-tunel” Jun 26 02:10:42 server Pluto[25157]: listening for IKE messages Jun 26 02:10:42 server Pluto[25157]: adding interface ipsec0/eth0 1.2.3.4 Jun 26 02:10:42 server Pluto[25157]: loading secrets from “/etc/ipsec.secrets” Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #1: initiating Main Mode Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #1: ISAKMP SA established Jun 26 02:10:42 server Pluto[25157]: “seifried-mosqueado” #2: initiating Quick Mode POLICY_ENCRYPT+POLICY_TUNNEL+POLICY_PFS Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #2: sent QI2, IPsec SA established Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #3: responding to Main Mode Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #3: sent MR3, ISAKMP SA established Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #4: responding to Quick Mode Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #4: IPSec SA established Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #5: responding to Main Mode Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #5: sent MR3, ISAKMP SA established Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #6: responding to Quick Mode Jun 26 02:10:42 server Pluto[25157]: “mi-tunel” #6: IPsec SA established ||

Además de esto se puede ver la salida de “eroute” para asegurarse de que los túneles están correctamente configurados:

10.0.0.0/24 -> 192.168.0.0/24 => tun0x114@1.2.3.4

Y si le echas un vistazo a tus rutas (“route”), deberías ver:

Kernel IP routing table

Destination Gateway Genmask Flags Metric Ref Use Iface

1.2.3.4 0.0.0.0 255.255.255.255 UH 0 0 0 eth0

10.0.0.1 0.0.0.0 255.255.255.255 UH 0 0 0 eth1

1.2.3.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0

1.2.3.0 0.0.0.0 255.255.255.0 UG 0 0 0 ipsec0

192.168.0.0 1.2.3.1 255.255.255.0 UG 0 0 0 ipsec0

10.0.0.0 0.0.0.0 255.255.255.0 U 0 0 0 eth1

127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo

0.0.0.0 1.2.3.1 0.0.0.0 UG 0 0 0 eth0

Productos IPSec comerciales

He pensado que sería interesante hacer un breve listado de los productos IPSec comerciales, por supuesto haciendo énfasis en los basados en Linux y FreeS/WAN

i-data

i-data desarrolla una línea de productos que incluyen un servidor VPN, basado en Linux y en FreeS/WAN. Están ubicados en Dinamarca, lo cual les permite que su producto esté disponible para todo el mundo. El sitio web está en: http://www.i-data.com/networks/

Productos IPSec para Windows

También existen paquetes de software que proporcionan capacidad de IPSec para Windows, uno de los cuales incluso es gratuito.

PGP VPN

Los autores de PGP (Network Associates) han creado un paquete de software “PGP VPN” (que tiene muy poco que ver con PGP). Soporta IPSec y se dice que también opera con Linux FreeS/WAN. Se puede conseguir en: http://www.nai.com/asp_set/products/tns/pgp_vpn.asp

IRE

[[http://www.ire.com/ http://www.ire.com%5D%5D


Aplicando Seguridad a una Distribución de Linux

18 julio 2009

Autor: Michael Jastremski, LinuxFocus
Traducido por Ruben Sotillo y revisado por Hugo Lastras
El articulo original fue escrito en ingles
Primera publicación: 1998-07-01
Copyright pertenece al autor

Introducción

Últimamente se están volviendo habituales los esfuerzos a gran escala para sabotear los ordenadores de internet. Los servidores con Linux y FreeBSD se han convertido en blanco de estos ataques, utilizando desbordamientos de buffer en los fuentes de imapd y BIND. Cada día, vulnerabilidades de todas formas y tamaños se reparten entre los casi 20.000 subscriptores de la lista de correo BUGTRAQ (si solo te subscribes a una lista de correo sobre seguridad, debería ser esta).

Sería sensato asumir que al menos uno de esos 19.305 subscriptores vaya a escribir un bucle for() y un poco de lógica alrededor de un ‘exploit’ cut+paste con las esperanza de lograr acceso ilegítimo a tantos ordenadores como sea posible.

Tarde o temprano, el bucle construirá la dirección de tu ordenador. Cuando llegue ese momento deberías estar preparado.

A pesar de lo que algunos “expertos” puedan hacerte creer, instalar y mantener un ordenador seguro no es algo díficil. Algunas prácticas bien conocidas en administración de sistemas sirven como protección de las amenazas de la red global. Este artículo describe algunas de las precauciones que generalmente tomo cuando configuro un sistema Linux RedHat conectado a la red. Aunque este artículo provee pautas para proteger tu ordenador de los intentos malvados de otros, no intenta ser una referencia completa.

Los siguientes son algunos pasos que evitarán que tu instalación caiga víctima del próximo hueco público en tu software de red.

ADVERTENCIA: Si no estás absolutamente seguro de lo que haces, no lo hagas. Algunos de estos pasos asumen un moderado grado de experiencia por tu parte. Al final daré la bibliografía recomendada.

Pasos para la seguridad

1. Quita todos lo servicios de red que no necesites. Menos maneras de conectarse a tu ordenador significan menos oportunidades de que un intruso penetre en él. Comenta todo lo que no necesites en /etc/inetd.conf. ¿No necesitas hacer telnet a tu sistema? Inhabilitalo. Lo mismo para ftpd, rshd, rexecd, gopher, chargen, echo, pop3d y similares. No olvides hacer un ‘killall -HUP inetd’ después de editar el fichero inetd.conf. Tampoco descuides el directorio /etc/rc.d/init.d. Algunos servicios de red (BIND, demonios de impresoras) son programas que se inician desde estos scripts.

2. Instala SSH. SSH es un sustituto para la mayoría de esos viejos comandos ‘r’ de Berkely. Lo siguiente está estraído de la página en http://www.cs.hut.fi/ssh:

Ssh (Secure Shell) es un programa para conectarse a otro ordenador en una red, para ejecutar comandos en una máquina remota, y para mover archivos de una máquina a otra. Proporciona autentificación fuerte y comunicaciones seguras sobre canales inseguros.

También realiza muchas otras cosas que cualquier aspirante a hacker encontrará interesantes. Bájate el SSH desde http://ftp.rge.com/pub/ssh.

3. Usa vipw(1) para bloquear las cuentas sin acceso a login. Fíjate que en RedHat Linux, las cuentas con un nombre de shell nulo inician sesión con la shell /bin/sh, que probablemente no es lo que quieres. También asegurate que ninguna de tus cuentas tenga password nulo. El siguiente es un ejemplo de como sería la parte de sistema de un fichero passwd correcto y seguro:

daemon:*:2:2:daemon:/sbin:/bin/sync
  adm:*:3:4:adm:/var/adm:/bin/sync
  lp:*:4:7:lp:/var/spool/lpd:/bin/sync
  sync:*:5:0:sync:/sbin:/bin/sync
  shutdown:*:6:0:shutdown:/bin:/sync
  halt:*:7:0:halt:/sbin:/bin:/sync
  mail:*:8:12:mail:/var/spool/mail:/bin/sync
  news:*:9:13:news:/var/spool/news:/bin/sync
  uucp:*:10:14:uucp:/var/spool/uucp:/bin/sync
  operator:*:11:0:operator:/root:/bin/sync
  games:*:12:100:games:/usr/games:/bin/sync
  gopher:*:13:30:gopher:/usr/lib/gopher-data:/bin/sync
  ftp:*:14:50:FTP User:/home/ftp:/bin/sync
  nobody:*:99:99:Nobody:/:/bin/sync

4. Quita los bits ‘s’ de los programas cuyo propietario sea el root y que no precisen de tal privilegio. Esto se hace ejecutando el comando ‘chmod a-s’ con el nombre o nombres de los archivos involucrados como argumentos.

Tales programas son (pero la lista no está completa):

  1. programs que nunca uses
  2. programas que no quieres que un usuario que no sea root los use
  3. programas que uses ocasionalmente, y no te importe tener que hacer un su(1) a root para ejecutarlos

He colocado un asterisco (*) al lado de cada programa que personalmente inhabilitaría. Recuerda que tu sistema necesita algunos programas con suid root para trabajar perfectamente, así que ten cuidado.

Alternativamente, podrías crear un grupo especial llamado ‘suidexec’, poner los usuarios en los que confías en este grupo, chgrp(1) el programa o programas dudosos que precisen del suid bit al grupo suidexec, y quitarle los permisos de ejecución global.

# find / -user root -perm "-u+s"
Comando Comentario
*/bin/ping

*/bin/mount sólo el root debería montar sistemas de ficheros
*/bin/umount idem
/bin/su ¡no toques este!
/bin/login
/sbin/pwdb_chkpwd
*/sbin/cardctl utilidad de control para tarjetas PCMCIA
*/usr/bin/rcp Usa ssh
*/usr/bin/rlogin idem
*/usr/bin/rsh
*/usr/bin/at usa cron, o inhabilitalo del todo
*/usr/bin/lpq instala LPRNG
*/usr/bin/lpr
*/usr/bin/lprm
*/usr/bin/mh/inc
*/usr/bin/mh/msgchk
/usr/bin/passwd ¡no tocar!
*/usr/bin/suidperl cada nueva versión de suidperl parece tener un desbordamiento del buffer
*/usr/bin/sperl5.003 úsalo solo si es necesario
/usr/bin/procmail
*/usr/bin/chfn
*/usr/bin/chsh
*/usr/bin/newgrp
*/usr/bin/crontab
*/usr/X11R6/bin/dga muchos desbordamientos de buffer como en X11
*/usr/X11R6/bin/xterm
*/usr/X11R6/bin/XF86_SVGA
*/usr/sbin/usernetctl
/usr/sbin/sendmail
*/usr/sbin/traceroute puedes soportar escribir el password de root de vez en cuando

5. Actualiza el sendmail. Baja el código fuente de ftp://ftp.sendmail.org/pub/sendmail. Desempaquetalo y lee las instrucciones. Instala el smrsh (empaquetado con sendmail) si tienes un par de minutos extras, este programa soluciona muchas de las cosas que interesan a la mayoría de la gente sobre el sendmail, tales como enviar emails a programas arbitrarios. Edita sendmail.cf y pon la opción ‘PrivacyOptions’ en ‘goaway’:

PrivacyOptions=goaway

Si no tienes previsto recibir correo de internet, ¡NO EJECUTES SENDMAIL EN EL MODO DE RECEPCIÓN (sendmail -bd)!. En este caso, deshabilita /etc/rc.d/init.d/sendmail.init y haz un ‘killall -TERM sendmail’. Con esto aún serás capaz de enviar email, pero no de recibir.

6. Actualiza BIND si lo usas. La última versión de BIND la puedes encontrar en http://www.isc.org . Si no lo usas deshabilitalo del todo.

7. Recompila el kernel. Generalmente lo hago para reducir el tamaño del kernel por defecto. CONSEJO: Activa todas las opciones de firewall incluso si tu ordenador no es un firewall.

CONFIG_FIREWALL=y
  CONFIG_NET_ALIAS=y
  CONFIG_INET=y
  # CONFIG_IP_FORWARD is not set
  # CONFIG_IP_MULTICAST is not set
  CONFIG_SYN_COOKIES=y
  CONFIG_RST_COOKIES=y
  CONFIG_IP_FIREWALL=y
  CONFIG_IP_FIREWALL_VERBOSE=y
  # CONFIG_IP_MASQUERADE is not set
  # CONFIG_IP_TRANSPARENT_PROXY is not set
  CONFIG_IP_ALWAYS_DEFRAG=y
  CONFIG_IP_ACCT=y
  # CONFIG_IP_ROUTER is not set
  # CONFIG_NET_IPIP is not set
  CONFIG_IP_ALIAS=m

8. Aplica los parches: Cualquier problema conocido con el software de RedHat se puede encontrar en las páginas de Errata de RedHat. (ver http://www.redhat.com/support/docs/errata.html para saber qué parches puedes aplicar a tu versión). RedHat hace un excelente trabajo de mantenimiento para mantener estas páginas actualizadas. Estas páginas incluyen también enlaces a los archivos RPM que necesitarás, junto con instrucciones de instalación.

9. Configura tcp_wrappers: Los tcp_wrappers son un método para controlar qué ordenadores en la red tienen permiso para hablar con el tuyo. Este paquete, escrito por el gurú en seguridad Wieste Venema, se coloca en frente de los programas que se ejecutan desde el inetd (o aquellos enlazados con su biblioteca) consultando sus archivos de configuración para determinar si deben negar o permitir una trasancción en la red. Por ejemplo, para permitir telnet y ftp desde tu casa vía un ISP, no permitiendo nada más, coloca lo siguiente en /etc/hosts.allow:

 in.ftpd : .dialup.tu-isp.com : allow
  all : all : deny

SSH, sendmail y otros paquetes pueden construirse con soporte para tcp_wrappers. Lee la página tcpd(1) del manual para más información.

Bibliografía

Parches de seguridad para Linux por Solar Designer:
http://www.false.com/security/linux/

Páginas de cryptografía para RedHat de replay.com:
http://www.replay.com/redhat/

Mejora la Seguridad de tu Site introduciéndote en él:
http://www.alw.nih.gov/Security/Docs/admin-guide-to-cracking.101.html

Slashdot es una buena fuente de noticias actualizadas:
http://www.slashdot.org

Para estar al tanto en actualizaciones de software, visita FreshMeat regularmente:
http://www.freshmeat.net

Extraordinario:
http://reality.sgi.com/nate/machines/security/P49-14-Aleph-One


Sistema de Detección de Intrusos

18 julio 2009

El término IDS (Sistema de detección de intrusiones) hace referencia a un mecanismo que, sigilosamente, escucha el tráfico en la red para detectar actividades anormales o sospechosas, y de este modo, reducir el riesgo de intrusión.

Existen dos claras familias importantes de IDS:

  • El grupo N-IDS (Sistema de detección de intrusiones de red), que garantiza la seguridad dentro de la red.

  • El grupo H-IDS (Sistema de detección de intrusiones en el host), que garantiza la seguridad en el host.

Un N-IDS necesita un hardware exclusivo. Éste forma un sistema que puede verificar paquetes de información que viajan por una o más líneas de la red para descubrir si se ha producido alguna actividad maliciosa o anormal. El N-IDS pone uno o más de los adaptadores de red exclusivos del sistema en modo promiscuo. Éste es una especie de modo “invisible” en el que no tienen dirección IP. Tampoco tienen una serie de protocolos asignados. Es común encontrar diversos IDS en diferentes partes de la red. Por lo general, se colocan sondas fuera de la red para estudiar los posibles ataques, así como también se colocan sondas internas para analizar solicitudes que hayan pasado a través del firewall o que se han realizado desde dentro.

El H-IDS se encuentra en un host particular. Por lo tanto, su software cubre una amplia gama de sistemas operativos como Windows, Solaris, Linux, HP-UX, Aix, etc.
El H-IDS actúa como un daemon o servicio estándar en el sistema de un host. Tradicionalmente, el H-IDS analiza la información particular almacenada en registros (como registros de sistema, mensajes, lastlogs y wtmp) y también captura paquetes de la red que se introducen/salen del host para poder verificar las señales de intrusión (como ataques por denegación de servicio, puertas traseras, troyanos, intentos de acceso no autorizado, ejecución de códigos malignos o ataques de desbordamiento de búfer).

Técnicas de detección

El tráfico en la red (en todo caso, en Internet) generalmente está compuesto por datagramas de IP. Un N-IDS puede capturar paquetes mientras estos viajan a través de las conexiones físicas a las que está sujeto. Un N-IDS contiene una lista TCP/IP que se asemeja a los datagramas de IP y a las conexiones TCP. Puede aplicar las siguientes técnicas para detectar intrusiones:

  1. Verificación de la lista de protocolos: Algunas formas de intrusión, como “Ping de la muerte” y “escaneo silencioso TCP” utilizan violaciones de los protocolos IP, TCP, UDP e ICMP para atacar un equipo. Una simple verificación del protocolo puede revelar paquetes no válidos e indicar esta táctica comúnmente utilizada.

  2. Verificación de los protocolos de la capa de aplicación: Algunas formas de intrusión emplean comportamientos de protocolos no válidos, como “WinNuke”, que utiliza datos NetBIOS no válidos (al agregar datos fuera de la banda). Para detectar eficazmente estas intrusiones, un N-IDS debe haber implementado una amplia variedad de protocolos de la capa de aplicación, como NetBIOS, TCP/IP, etc.

Esta técnica es rápida (el N-IDS no necesita examinar la base de datos de firmas en su totalidad para secuencias de bytes particulares) y es también más eficiente, ya que elimina algunas falsas alarmas. Por ejemplo, al analizar protocolos, N-IDS puede diferenciar un “Back Orifice PING” (bajo peligro) de un “Back Orifice COMPROMISE” (alto peligro).

  1. Reconocimiento de ataques de “comparación de patrones”: Esta técnica de reconocimiento de intrusión es el método más antiguo de análisis N-IDS y todavía es de uso frecuente.

Consiste en la identificación de una intrusión al examinar un paquete y reconocer, dentro de una serie de bytes, la secuencia que corresponde a una firma específica. Por ejemplo, al buscar la cadena de caracteres “cgi-bin/phf”, se muestra un intento de sacar provecho de un defecto del script CGI “phf”. Este método también se utiliza como complemento de los filtros en direcciones IP, en destinatarios utilizados por conexiones y puertos de origen y/o destino. Este método de reconocimiento también se puede refinar si se combina con una sucesión o combinación de indicadores TCP.

Esta táctica está difundida por los grupos N-IDS “Network Grep”, que se basan en la captura de paquetes originales dentro de una conexión supervisada y en su posterior comparación al utilizar un analizador de “expresiones regulares”. Éste intentará hacer coincidir las secuencias en la base de firmas byte por byte con el contenido del paquete capturado.

La ventaja principal de esta técnica radica en la facilidad de actualización y también en la gran cantidad de firmas que se encuentran en la base N-IDS. Sin embargo, cantidad no siempre significa calidad. Por ejemplo, los 8 bytes “CE63D1D2 16E713CF”, cuando se colocan al inicio de una transferencia de datos UDP, indican un tráfico Back Orifice con una contraseña predeterminada. Aunque el 80% de las intrusiones utilicen la contraseña predeterminada, el 20% utilizarán contraseñas personalizadas y no serán necesariamente reconocidas por el N-IDS. Por ejemplo, si la contraseña se cambia a “evadir”, la serie de bytes se convertirá en “8E42A52C 0666BC4A”, lo que automáticamente la protegerá de que el N-IDS la capture. Además, la técnica inevitablemente conducirá a un gran número de falsas alarmas y falsos positivos.

Existen otros métodos para detectar e informar sobre intrusiones, como el método Pattern Matching Stateful, y/o para controlar el tráfico peligroso o anormal en la red.

En conclusión, un perfecto N-IDS es un sistema que utiliza las mejores partes de todas las técnicas mencionadas anteriormente.

Qué hacen los IDS

Los principales métodos utilizados por N-IDS para informar y bloquear intrusiones son:

  • Reconfiguración de dispositivos externos (firewalls o ACL en routers): Comando enviado por el N-IDS a un dispositivo externo (como un filtro de paquetes o un firewall) para que se reconfigure inmediatamente y así poder bloquear una intrusión. Esta reconfiguración es posible a través del envío de datos que expliquen la alerta (en el encabezado del paquete).

  • Envío de una trampa SNMP a un hipervisor externo: Envío de una alerta (y detalles de los datos involucrados) en forma de un datagrama SNMP a una consola externa como HP Open View Tivoli, Cabletron, Spectrum, etc.

  • Envío de un correo electrónico a uno o más usuarios: Envío de un correo electrónico a uno o más buzones de correo para informar sobre una intrusión seria.

  • Registro del ataque: Se guardan los detalles de la alerta en una base de datos central, incluyendo información como el registro de fecha, la dirección IP del intruso, la dirección IP del destino, el protocolo utilizado y la carga útil.

  • Almacenamiento de paquetes sospechosos: Se guardan todos los paquetes originales capturados y/o los paquetes que dispararon la alerta.

  • Apertura de una aplicación: Se lanza un programa externo que realice una acción específica (envío de un mensaje de texto SMS o la emisión de una alarma sonora).

  • Envío de un “ResetKill: Se construye un paquete de alerta TCP para forzar la finalización de una conexión (sólo válido para técnicas de intrusión que utilizan el protocolo de transporte TCP).

  • Notificación visual de una alerta: Se muestra una alerta en una o más de las consolas de administración.

Desafíos de IDS

En la prensa especializada, cada vez resuena más el término IPS (Sistema de prevención de intrusiones) que viene a sustituir al IDS “tradicional” o para hacer una distinción entre ellos.

El IPS es un sistema de prevención/protección para defenderse de las intrusiones y no sólo para reconocerlas e informar sobre ellas, como hacen la mayoría de los IDS. Existen dos características principales que distinguen a un IDS (de red) de un IPS (de red):

  • El IPS se sitúa en línea dentro de la red IPS y no sólo escucha pasivamente a la red como un IDS (tradicionalmente colocado como un rastreador de puertos en la red).

  • Un IPS tiene la habilidad de bloquear inmediatamente las intrusiones, sin importar el protocolo de transporte utilizado y sin reconfigurar un dispositivo externo. Esto significa que el IPS puede filtrar y bloquear paquetes en modo nativo (al utilizar técnicas como la caída de una conexión, la caída de paquetes ofensivos o el bloqueo de un intruso).


Aplicaciones tanto comercial y libremente para la detección de código de malicioso

17 julio 2009

He extraido de internet las herramientas de seguridad mas utilizadas. Es una encuesta echa por Insecure.com, se encuentran agrupadas desde las menos populares y usadas hasta las mejores y eficaces.

GPG/PGP (http://www.gnupg.org/ y http://www.ogo.com/): substituto del PGP con licencia GNU desarrollado en Europa que no utiliza ni el algoritmo RSA ni IDEA y que por ello no tiene ningún tipo de restricción.
PGP o Pretty Good Privacy es el famoso sistema de encriptación que ayuda a asegurar y codificar la información contra posibles “escuchas”.

QueSO (http://www.apostols.org/projects/queso): utilidad para averiguar qué Sistema operativo corre en una máquina remota analizando las respuestas TCP.
Funciona bajo Unix (Linux) y algunas de sus pruebas de detección han sido incluidas al famoso programa NMAP.

Fragrouter (http://www.anzen.com/research/nidsbench)

IPLog (http://ojnk.sourceforge.net/): logger del tráfico TCP/IP, UDP e ICMP que detecta scanneos y posibles ataques para sistemas Unix.

IPTraf (http://www.mozcom.com/riker/iptraf): monitor de red que genera multitud de estadísticas como información TCP, contador UDP, información ICMP y OSPF, estado de los nodos, errores IP, etc.

LIDS (http://www.turbolinux.com.cn/lids): este es un sistema de detección/defensa para Linux contra intrusiones de root deshabilitando algunas llamadas del sistema al kernel.

LSOF (http://vic.cc.purdue.edu/pub/tools/unix/lsof): herramienta de diágnostico de sistemas Unix que lista la información de cualquier archivo que es abierto por un proceso que se esté ajecutando. Muy útil para detectar troyanos y sniffers.

Nemesis (http://www.packetninja.net/nemesis)

OpenBSD (http://www.openbsd.org/): OpenBSD es una distribución libre de sistemas Unix multiplataforma basada en 4.4BSD. OpenBSD incluye emulación de binarios para la mayoría de los programas de los sistemas SVR4 (Solaris), Linux, SunOS, HP-UX, etc e incluye también OpenSSH con soporte para SSH1 y SSH2.

Swatch (http://www.stanford.edu/~atkins/swatch): utilidad para monitorizar los mensajes de los archivos log de Unix mediante el comando syslog lanzando eventos con múltimples métodos de alarma.

Cerberus Internet Scanner (http://www.cerberus-infosec.co.uk/cis.shtml): CIS es otro scanner de seguridad destinado a ayudar a los administradores de red de Windows a detectar y corregir agujeros de seguridad.

Crack (ftp://ftp.cerias.purdue.edu/pub/tools/unix/pwdutils/crack/): este programa es un password cracker.

Libnet (http://www.packetfactory.net/libnet): conjunto de rutinas para la construcción y guía de una red.

Retina (http://www.eeye.com/html/Products/Retina.html): este programa es un conocido scanneador de vulnerabilidades que es comercial y que incluye la forma de arreglar todos los agujeros de seguridad que encuentre. Es para Windows.

Vetescan (http://www.self-evident.com/): es un scanneador de vulnerabilidades que contiene programas para comprobar y/o explotar exploits conocidos de redes para Windows y Unix y corregirlos.

Cheops (http://www.marko.net/cheops): sirve para mapear redes locales o remotas y muestra qué Sistema Operativo (SO) tienen las máquinas de la red.

Ngrep (http://www.packetfactory.net/Projects/ngrep): herramienta sensible a pcap que permite especificar expresiones regulares extendidas contra la carga de datos de los paquetes. Actualmente reconoce TCP, UDP e ICMP sobre ethernet a través de PPP, SLIP e interfaces nulos.

Perl (http://www.perl.org/): Practical Extraction and Report Language es un lenguaje de scripts que corre en cualquier sistema operativo y que sirve, entre otras múltiples cosas, para crear exploits y explotar las vulnerabilidades de los sistemas.

Logcheck (http://www.psionic.com/abacus/logcheck): es parte del proyecto Abacus de utilidades de seguridad que ayuda a mostrar los problemas y violaciones de seguridad en los archivos log del sistema, analizando cada línea y clasificándola según diferentes niveles de alerta (ignorar, actividad inusual, violación de seguridad y ataque) para luego enviar los resultados al administrador por e-mail.

NFR (http://www.nfr.com/): Network Flight Recorder es un sniffer comercial para detectar intrusiones en los sistemas.

Sam Spade (http://www.samspade.org/): herramientas online para investigar una dirección IP y econtrar spammers.

Scanlogd (http://www.openwall.com/scanlogd): programita que detecta los scanneos de puertos que alguien pueda hacer contra tu sistema.

NAT (http://www.tux.org/pub/security/secnet/tools/nat10): NetBios Auditing Tool sirve para explorar los recursos compartidos a través del protocolo NetBios en un sistema windows.

Traceroute/ping/telnet (http://www.linux.com/): herramientas de Unix y Windows (en este sistema operativo el comando treceroute se denomina tracert).

NTOP (http://www.ntop.org/): utilidad para Unix que permite visualizar en tiempo real los usuarios y aplicaciones que están consumiendo recursos de red en un instante concreto.
Tiene como un microservidor web que permite que cualquier usuario que sepa la clave pueda ver la salida NTOP de forma remota con cualquier navegador.

TCP Wrappers (ftp://ftp.porcupine.org/pub/security/index.html): pequeños programas que permiten una conexión controlada, restringiendo determinados servicios del sistema.
Se pueden monitorizar y filtrar las peticiones de entrada de servicios como Systar, Finger, FTP, Telnet, Rlogin, RSH, TFTP, etc. El wrapper reporta el nombre del cliente y del servicio que ha solicitado pero no intercambia información con el cliente o el servidor de la aplicación/servicio solicitado porque lo que hace es comprobar si el cliente tiene permiso para utilizar el servicio que está pidiendo y si no es así, corta la conexión.

SSH (http://www.ssh.com/commerce/index.html): Tenemos dos opciones usar el SSH que es de pago o utilizar en cambio el OpenSSH que es una evolución del ssh para OpenBSD. SSH o Secure Shell, es un protocolo o programa que se sirve de dicho protocolo, que permite una conexión cifrada y protegida entre dos máquinas (normalmente cliente servidor) que sirve para substituir al telnet y poder acceder y administrar sistemas remotos de manera segura.

Hunt (http://www.cri.cz/kra/index.html#HUNT): este es un sniffer avanzado que funciona bajo redes ethernet pero que no conocía así que poca cosa puedo decir.

John the Ripper (http://www.openwall.com/join): esta es una de esas utilidades que, yo por lo menos, recuerdo de toda la vida. Es uno de los programas que yo utilizaba cuando empecé a hacer mis primeros pinitos en esto del hack y la verdad es que era el mejor crackeador de passswords para Unix.

L0pht Crack (http://www.l0pht.com/l0phtcrack): Esta es la conocida herramienta de auditoría para
los passwords bajo Windows. La última versión es la LC3.

Strobe (http://www.insecure.org/nmap/index.html#other): scanneador de puertos de gran velocidad.

Firewalk (http://www.packetfactory.net/Projects/Firewalk): programa para analizar las respuestas a los paquetes IP con la técnica del Firewalking con una interface gráfica (opcional) para determinar los filtros ACL de los gateways y los mapeos de red.

IPtables/netfilter/ipchains/ipfwadm (http://netfilter.kernelnotes.org/): herramientas para filtrar los paquetes IP bajo Linux.

IPFilter (http://coombs.anu.edu.au/ipfilter): este es un filtro de paquetes TCP/IP indicado para el uso con un firewall en plataformas Unix.
Puede trabajar como un módulo cargable del kernel o incorporado en él directamente.
Curiosamente, las versiones previas a la 3.4.17 presentan una vulnerabilidad que permite alcanzar puertos TCP y UDP teóricamente protegidos.

SATAN (http://www.fish.com/satan): hace falta decir algo sobre el más famoso scanneador de vulnerabilidades y analizador de red???

Sniffit (http://reptile.rug.ac.be/~coder/sniffit.html): otro sniffer de paquetes TCP/UDP e ICMP capaz de obtener información técnica muy detallada.

SARA (http://www-arc.com/sara): Security Auditor’s Research Assistant es la tercera generación de herramientas para el análisis de seguridad en plataformas Unix. La primera fue el SATAN (Security Administrator’s Tool for Analizing Networks) y la segunda el SAINT.

Hping2 (http://www.hping.org/): este programa basado en el comando ping de Unix sirve para enviar paquetes ICMP,UDP y TCP hechos a medida para mostrar las respuestas del obejtivo como replicas ICMP echo (ping).
Con hping conseguimos testar firewalls, scannear puertos, etc. Nota: ICMP (Protocolo de Mensajes de Control Internet).

Cybercop (http://www.pgp.com/products/cybercop-scanner/default.asp): este es un scanner de agujeros de seguridad comercial que tiene versiones para Windows y Unix y que es capaz de auditar servidores, estaciones de trabajo, hubs, routers, firewalls, etc.

Tripwire (http://www.tripwire.com/): esta es una utilidad para el análisis de red que sirve de gran ayuda a los adminsitradores de red.

DSniff (http://naughty.monkey.org/~dugsong/dsniff): el nombre ya lo dice todo… este es un sniffer para buscar passwords y el resto de información de una red incluyendo técnicas sofisticadas para defender la “protección” de los switchers de red.

Abacus Portsentry (http://www.psionic.com/abacus/portsentry): demonio de Unix para detectar scanneos de puertos contra nuestros sistemas capaz de bloquear al atacante mediante host.deny, filtrar las rutas o reglar el firewall.

ISS (http://www.iss.net/): Internet Security Scanner es una herramienta comercial de análisis de vulnerabilidades para Windows.

Whisker (http://www.wiretrip.net/rfp/bins/whisker/whisker.zip): buen scanner de vulnerabilidades CGI .

Ethereal (http://www.vaxman.es.org/ethereal.zing.org): este sniffer de red para Unix tiene un entorno gráfico y soporta decodificación de diversos protocolos pero presenta una vulnerabilidad de búfer overflow (versiones anteriores a la 0.8.14).

Saint (http://www.vaxman.es.org/www.wwdsi.com/saint): Security Administrator’s Integrated Network Tool (SAINT) es una evolución del conocido SATAN para plataformas Unix que sirve para evaluar toda la seguridad de un sistema recibiendo incluso múltiples updates desde el CERT y CIAC.

Snort (http://www.vaxman.es.org/www.snort.org): sniffer/logger, Snort sirve para detectar intrusiones y ataques tipo búfer overflows, CGI, SMB, scanneo de puertos, etc. Snort puede enviar alertas en tiempo real, enviándolas directamente al archivo de Unix syslog o incluso a un sistema Windows mediante SAMBA.
Las versiones anteriores a la 1.8.1 presentan una vulnerabilidad en la codificación Unicode que posibilita que un atacante evada dicha detección.

TCPDump (http://www.vaxman.es.org/www.tcpdump.org): este sniffer para Unix sirve para monitorizar todo el tráfico de una red, recolectar toda la información posible y detectar así posibles problemas como ataques ping.
Combinado con SNORT se convierte en una poderosa herramienta solventando las carencias que ambos porgramas tienen por separado. Es curioso porque podemos servirnos del propio TCPDump para evadir IDSs de los que forma parte porque presenta una vulnerabilidad en las capacidades de decodificación de DNS y puede entrar en un loop infinito que nos permita saltarnos ese IDS (Sistema de Detección de Intrusos).

Netcat (http://www.vaxman.es.org/www.atstake.com/research/tools/nc11nt.zip): esta sencilla utilidad para Windows y Unix sirve para escuchar y analizar las conexiones de red usando los protocolos TCP o UDP. Se ha usado bastante para explotar el bug del Isapi en los servidores IIS (ref. Desbordamiento de búfer en el IIS del 21 de junio).

Nessus (http://www.nessus.org/): este programa es un scanner de seguridad empleado para hacer más de una auditoría en busca de vulnerabilidades. Consta de dos partes, cliente y servidor (nessusd) con versiones para Windonws, Java y Unix (la parte cliente) y sólo para Unix el servidor. El servidor /daemon realiza los ataques mientras que el cliente interactúa con el usuario a través de un interface gráfico.
Pros: desarrolla una completa exploración de todos los puertos y servicios y presenta los puntos vulnerables que encuentra y sus posibles soluciones.
Contras: es un poco lento.

IPLog

IPlog es una aplicación que corre sobre GNU/Linux, FreeBSD, OpenBSD y BSDI encargada de loguear tráfico TCP, UDP y ICMP para estudiarlo en tiempo real y avisarnos de la detección de alguno de estos tipos de acciones: Scans de puertos TCP/UDP, TCP null scans, FIN scans, TCP “Xmas” scans y ataques de denegación de servicio (DOS) del tipo: UDP & ICMP “smurf”, bogus TCP flags, TCP SYN scans, ICMP ping floods y IP fragment attacks. Basa sus capacidades en la dependencia libpcap, muy utilizada en software de monitorización y análisis de redes.

Otra de sus reconocidas posibilidades es la de poder engañar a la funcionalidad de Nmap de reconocimiento del sistema operativo escaneado, imposibilitando la extracción del fingerprint correcto. Puede que no sea el programa más completo y liviano para este tipo de menesteres pero su facilidad de uso lo hace interesante en muchos escenarios y vamos a dedicar unas lineas a explicar la forma de uso de este programa.

IPLog y la opción –promisc / -a

La aplicación IPLog por defecto solo loguea las conexiones entrantes a la interfaz de red, cuando nos escanean los puertos, cuando nos floodean, en resumen, cuando los paquetes van dirigidos a nuestro ordenador. Esto explica que al tener funcionando Iplog en una máquina A y desde esa mismo host A realizar un flood a un servidor B, nos detecte las contestaciones de B como un ataque, generalmente como ataque smurf.

La opción –promisc nos posibilita poder identificar las conexiones salientes a una determinada red / host, no solo las entrantes a nuestro ordenador. Esta opción es especialmente útil si queremos vigilar a nuestro PC de forma de que si se realiza un ataque, desde el ordenador o desde alguna de las máquinas que lo usen como gateway a una determinada red, podremos saberlo. Veamos un ejemplo.

Teniendo wlan0 con una dirección IP 192.168.1.34 ejecutamos el siguiente comando:

# ping -f 192.168.1.170

Obteniendo una salida de IPLog (Usando –promisc):

# iplog -o -L -D -a 6192.168.1.0/24 --scans-only=true --ignore --disable-resolver -i wlan0

Ahora veamos la salida sin usar la opción “–promisc”:

# iplog -o -L -D --scans-only=true --ignore --disable-resolver -i wlan0

Al no detectar el tráfico saliente, detecta solo las respuestas del flood (ping -f) de 66.249.91.103 y NO avisa del ataque que estamos realizando, sino que lo entiende como un ataque smurf a nuestra propia máquina, como antes dijimos, ya que solo analiza los paquetes entrantes. El usar esta opción, indicando la red o host que queremos mantenga vigilados con respecto al trafico saliente, limita el uso de IPLog para que detecte ataques orientados a la propia máquina donde está corriendo, ya que solo le interesará el trafico saliente a esa red / IP, si queremos que loguee todo, podríamos hacer un apaño usando como parámetro: 0.0.0.0/0

De usar esta opción de la siguiente manera:

-a 0.0.0.0/0

Le estamos diciendo a IPLog que identifique los ataques emitidos y recibidos por nuestro host en la interfaz definida en la opción “-i”. Esto nos permite poder usar GNU/Linux o BSD como router para otros hosts e identificar cuando nuestros usuarios atacan ciertas máquinas y detectar cuando nos están atacando a nosotros o a alguno de los hosts que enrutemos. Si estamos enrutando y queremos detectar si las maquinas que enrutamos realizan determinados ataques, el programa IPLog debemos colocarlo usando la opción -i, lo más próximo a las redes que se enrutan. Veamos un ejemplo práctico dado este escenario:

IPLog y la opción –promisc / -a

La aplicación IPLog por defecto solo loguea las conexiones entrantes a la interfaz de red, cuando nos escanean los puertos, cuando nos floodean, en resumen, cuando los paquetes van dirigidos a nuestro ordenador. Esto explica que al tener funcionando Iplog en una máquina A y desde esa mismo host A realizar un flood a un servidor B, nos detecte las contestaciones de B como un ataque, generalmente como ataque smurf.

La opción –promisc nos posibilita poder identificar las conexiones salientes a una determinada red / host, no solo las entrantes a nuestro ordenador. Esta opción es especialmente útil si queremos vigilar a nuestro PC de forma de que si se realiza un ataque, desde el ordenador o desde alguna de las máquinas que lo usen como gateway a una determinada red, podremos saberlo. Veamos un ejemplo.

Teniendo wlan0 con una dirección IP 192.168.1.34 ejecutamos el siguiente comando:

# ping -f 192.168.1.170

Obteniendo una salida de IPLog (Usando –promisc):

# iplog -o -L -D -a 192.168.1.0/24 --scans-only=true --ignore --disable-resolver -i wlan0

Ahora veamos la salida sin usar la opción “–promisc”:

# iplog -o -L -D --scans-only=true --ignore --disable-resolver -i wlan0

Al no detectar el tráfico saliente, detecta solo las respuestas del flood (ping -f) de 66.249.91.103 y NO avisa del ataque que estamos realizando, sino que lo entiende como un ataque smurf a nuestra propia máquina, como antes dijimos, ya que solo analiza los paquetes entrantes. El usar esta opción, indicando la red o host que queremos mantenga vigilados con respecto al trafico saliente, limita el uso de IPLog para que detecte ataques orientados a la propia máquina donde está corriendo, ya que solo le interesará el trafico saliente a esa red / IP, si queremos que loguee todo, podríamos hacer un apaño usando como parámetro: 0.0.0.0/0

De usar esta opción de la siguiente manera:

-a 0.0.0.0/0

Le estamos diciendo a IPLog que identifique los ataques emitidos y recibidos por nuestro host en la interfaz definida en la opción “-i”. Esto nos permite poder usar GNU/Linux o BSD como router para otros hosts e identificar cuando nuestros usuarios atacan ciertas máquinas y detectar cuando nos están atacando a nosotros o a alguno de los hosts que enrutemos. Si estamos enrutando y queremos detectar si las maquinas que enrutamos realizan determinados ataques, el programa IPLog debemos colocarlo usando la opción -i, lo más próximo a las redes que se enrutan.

Sobre esa máquina GNU/Linux, ejecutamos el siguiente comando y observamos la salida:

# iplog -o -L -D -a 0.0.0.0/0 --scans-only=true --ignore --disable-resolver -i eth0 -l /var/log/iplog_eth0

Conclusiones

Hoy en dia las empresas deben de enfocar parte de sus atencion en el grado de vunerabilidad y en las herramientas de seguridadcon las que cuenten para hacerles frente a posibles ataques informaticos que luego se puede traducir en cuantiosas perdidas economicas.

Pero para protegerse ante ciertas amenazas no vasta con que las empresas posean dispositivos de proteccion como firewalls o cortafuegos, sistemas de detencion de intrusos, antivirus de red, antispam o vpn, si no que el funcionamiento de los mismos han de estar marcados por la implicacion de todo los usuarios.

Bibliografia

Anonimo. “Seguridad Informática en ordenadores personales – Herramientas de seguridad”.

22 de Febrero de 2006.

http://www.wikilearning.com/tutorial/seguridad_informatica_en_ordenadores_personales-herramientas_de_seguridad/4375-5

Busindre. “Como compilar Iplog sin errores (Parche)”

October 19th, 2007

http://www.busindre.com/como-compilar-iplog-sin-errores-parche/

Busindre. “Detectar escaneos de puertos y ataques DOS con IPlog (GNU/Linux / *BSD)”

September 24th, 2008

http://www.busindre.com/detectar-escaneos-de-puertos-y-ataques-dos-con-iplog-gnulinux-bsd/