Guía Hardening – Configuración de redes y Firewall – IPtables Parte 2

En la primera parte de esta entrada se vio como funcionaba muy básicamente IPtables, y para ver el potencial y funcionamiento de un Firewall con IPtables, hemos decidido coger un script que teníamos a mano, y así poder ver de una manera mas completa el potencial de IPtables. Tenéis que tener en cuenta que este FW se ha puesto como ejemplo, no es que se haya realizado super securizado, es simplemente para que veáis algunos ejemplos de lo que se puede hacer con iptables.

ESQUEMA DE RED

Mr.Pako = KALI
FIREWALL = CERBERO
ECORP = eth2 Debian
UMBRELLA = eth0 Win

ARCHIVO INTERFACE

up /etc/fw.sh start
down /etc/fw.sh stop

ARCHIVO BLACKLIST

Este es un simple archivo de texto en el que para el ejemplo hemos decidido incluir  direcciones URL de sitios web a bloquear, se puede utilizar este mismo ejemplo para otros menesteres,  se invoca desde el script al inicio, por ejemplo.

Variables

BLACKLIST="/etc/blacklist"

ejemplo de contenido:

---- inicio archivo blacklist ----
marca.es
elmundo.es
elpais.com
etc.
--- fin archivo blacklist ----

SCRIPT Firewall

He decidido crear un script e iniciarlo al arrancar el equipo, personalmente me gusta hacerlo así, pero bueno aquí cada cual que elija el método que más le guste.

Hemos comentado todo el script, además consideramos que es auto explicativo. Vamos al tajo.

1.- Stop, borrado de reglas y Start
La primera parte del script elimina todas las reglas anteriormente creadas, de este modo evitamos posibles conflictos con alguna regla existente, para esta tarea utilizamos la opción –flush o -F, acompañada de -X (borra todas las cadenas) y -Z (pone a cero los contadores de paquetes) y finalizamos poniendo todas las políticas por defecto en ACCEPT y aplicando reglas para el Firewall.

 

========= INICIO SCRIPT ==========

#!/bin/sh
#
#
# Variables
BLACKLIST="/etc/blacklist"

stop(){
# Eliminamos reglas (flush)

echo -ne "[.] Eliminando reglas anteriores "
iptables --flush
iptables -X
iptables -Z
iptables --table nat --flush
iptables --table mangle --flush

# Ponemos las politicas por defecto en ACCEPT.

iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
echo -ne " -> [ OK ]\n "
}

start(){
clear 
echo -ne "***** Aplicando Reglas de Firewall *****\n"
 
# Politicas por defecto (drop) 
# creo las politicas por defecto en drop para que 
# lo deniege todo, excepto el PRE Y POSTROUTING.

echo -ne "[.] Estableciendo POLITICAS (DROP) por defecto"
iptables --policy INPUT DROP
iptables --policy OUTPUT DROP
iptables --policy FORWARD DROP
iptables --table nat --policy PREROUTING ACCEPT
iptables --table nat --policy POSTROUTING ACCEPT
echo -ne " -> [ OK ]\n "

2.- Protección
Para protegernos frente a algunos ataques comunes debemos habilitar varios módulos, esto lo hacemos con echo 1  >  seguido del modulo que queremos activar, además añadimos protección para 3 tipos de escaneo de red comunes.

# Ahora hacemos enmascaramiento de la red local y activamos el BIT 
# DE FORWARDING (imprescindible)
echo -ne "[.] Estableciendo MASQUERADE Y FORWARD para la red local"
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
echo 1 > /proc/sys/net/ipv4/ip_forward
echo -ne " -> [ OK ]\n "

# Habilitamos protección broadcast echo.
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts

# Habilitamos protección tcp_syn cookie.
echo 1 > /proc/sys/net/ipv4/tcp_syncookies

# Protecciones a 3 tipos de escaneo 
# NULL, XMAS, SYN-FIN-scan
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP

# Permitir hacer pings al servidor
echo -ne "[.] Permitiendo ping al FW desde la LAN y desde Internet"
iptables -A OUTPUT -p icmp -j ACCEPT
iptables -A INPUT -i eth2 -p icmp -j ACCEPT
iptables -A INPUT -i eth0 -p icmp -j ACCEPT
iptables -A INPUT -i eth1 -p icmp -j ACCEPT 
echo -ne " -> [ OK ]\n "

3.- SSH
Para poder trabajar a través de SSH debemos indicarle al firewall las direcciones de origen y puertos que se utilizaran normalmente para conectarse utilizando SSH, además podemos indicarle la mac address del equipo para brindar un poco mas de seguridad en la conexiones.

# Reglas para poder acceder al servidor por ssh
echo -ne "[.] Permitiendo ACCESO SSH hacia CERBERO desde puesto de trabajo y laptop Mr.Pako"
iptables -A INPUT -i eth2 -s IP ORIGEN -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -i eth0 -s IP ORIGEN.46 -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -i eth2 -s IP ORIGEN.179 -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -i eth0 -s IP ORIGEN.179 -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -i eth2 -s IP ORIGEN.46 -p udp --dport 22 -j ACCEPT
iptables -A INPUT -i eth0 -s IP ORIGEN.46 -p udp --dport 22 -j ACCEPT
#iptables -A INPUT -m mac --mac 00:00:00:00:00:00 -p tcp --dport 22 -j ACCEPT
#iptables -A INPUT -m mac --mac 00:00:00:00:00:00 -p udp --dport 22 -j ACCEPT
#iptables -A INPUT -m mac --mac 00:00:00:00:00:11 -p tcp --dport 22 -j ACCEPT
#iptables -A INPUT -m mac --mac 00:00:00:00:00:11 -p udp --dport 22 -j ACCEPT
iptables -A OUTPUT -o eth0 -s IP ORIGEN.80.1 -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o eth2 -s IP ORIGEN.1 -m state --state ESTABLISHED,RELATED -j ACCEPT
echo -ne " -> [ OK ]\n "

 

# ntp 
iptables -A FORWARD -p udp --dport 123 -j ACCEPT
iptables -A FORWARD -p tcp --dport 123 -j ACCEPT 
 
# Reglas para el DNS local
echo -ne "[.] Permitiendo peticiones DNS desde ECORP hacia inet" 
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state NEW -p tcp --dport 53 -j ACCEPT
iptables -A OUTPUT -m state --state NEW -p udp --dport 53 -j ACCEPT
echo -ne " -> [ OK ]\n " 
 
echo -ne "[.] Permitiendo peticiones DNS desde Lan hacia ECORP" 
iptables -A INPUT -i eth2 -p tcp --dport 53 -d IP DESTINO/24 -j ACCEPT
iptables -A INPUT -i eth2 -p udp --dport 53 -d IP DESTINO/24 -j ACCEPT
iptables -A OUTPUT -o eth2 -m state --state ESTABLISHED,RELATED -j ACCEPT
echo -ne " -> [ OK ]\n "

 

4 – VPN, RDP, WEB, VozIP, CITRIX, FTP

 

# Reglas para conexiones VPN desde INTERNET
echo -ne "[.] Permitiendo conexiones vpn desde inet" 
iptables -t nat -A PREROUTING -i eth0 -p 47 -s 0/0 -j DNAT --to IP DESTINO
iptables -t nat -A PREROUTING -i eth0 -p tcp -s 0/0 --dport 1723 -j DNAT --to IP DESTINO:1723
iptables -A FORWARD -i eth0 -o eth2 -d IP DESTINO -p 47 -j ACCEPT
iptables -A FORWARD -i eth0 -o eth2 -d IP DESTINO -p tcp --dport 1723 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Regla para permitir pptp (VPN)
echo -ne "[.] Activando reglas FORWARD para conexion vpn desde el SERVIDOR DE ECORP hacia otros destinos"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 1723 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p 47 -o eth0 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Permito RDP 3389.
echo -ne "[.] Permitiendo conexiones RDP a laptop Mr.Pako" 
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 3389 -s IP ORIGEN -j DNAT --to IP DESTINO:3389
iptables -t nat -A PREROUTING -i eth0 -m mac --mac 00:00:00:00:00:00 -p tcp --dport 3389 -j DNAT --to IP DESTINO:3389
iptables -A FORWARD -i eth0 -s IP ORIGEN -o eth2 -d IP DESTINO -p tcp --dport 3389 -j ACCEPT 
iptables -A FORWARD -i eth0 -m mac --mac 00:00:00:00:00:00 -p tcp --dport 3389 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Reglas para permitir al equipo 51 y 57 salir por el puerto 3390 y 3391 por rdp.
echo -ne "[.] Activando reglas FORWARD para conexión RDP"
iptables -A FORWARD -i eth2 -s IP ORIGEN.51 -p tcp --dport 3390:3391 -o eth0 -d IP DESTINO -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN.57 -p tcp --dport 3390:3391 -o eth0 -d IP DESTINO -j ACCEPT
echo -ne " -> [ OK ]\n "

# Regla para navegación web.
echo -ne "[.] Activando reglas FORWARD para www y https"
iptables -A FORWARD -i eth0 -o eth2 -m state --state ESTABLISHED,RELATED -j ACCEPT 
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 80 -m state --state NEW -o eth0 -j ULOG --ulog-prefix="WEB: -->"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 80 -m state --state NEW -o eth0 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 443 -m state --state NEW -o eth0 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p udp --dport 443 -m state --state NEW -o eth0 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Regla para permitir el pop3.
echo -ne "[.] Activando reglas FORWARD para pop3"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 110 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p udp --dport 110 -o eth0 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Regla para permitir el smtp.
echo -ne "[.] Activando reglas FORWARD para smtp"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 25 -o eth0 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Reglas para la VOIP.
echo -ne "[.] Activando reglas FORWARD para la VozIP"
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p tcp --dport 5060:5081 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p udp --dport 5060:5081 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p tcp --dport 6060:6061 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p udp --dport 6060:6061 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p tcp --dport 34567 -o eth0 -j ACCEPT
iptables -A FORWARD -i eth0 -s IP ORIGEN/24 -p udp --dport 34567 -o eth0 -j ACCEPT
echo -ne " -> [ OK ]\n "

# Reglas para acceder por CITRIX a los servidores de UMBRELLA CORPORATION.
echo -ne "[.] Activando reglas FORWARD para conectar por CITRIX a UMBRELLA CORPORATION"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 1494 -o eth0 -d IP DESTINO.230 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 1494 -o eth0 -d IP DESTINO.234 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 1494 -o eth0 -d IP DESTINO.235 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p udp --dport 1604 -o eth0 -d IP DESTINO.230 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p udp --dport 1604 -o eth0 -d IP DESTINO.234 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p udp --dport 1604 -o eth0 -d IP DESTINO.235 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 2598 -o eth0 -d IP DESTINO.230 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 2598 -o eth0 -d IP DESTINO.234 -j ACCEPT
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 2598 -o eth0 -d IP DESTINO.235 -j ACCEPT
echo -ne " ->[ OK ]\n "

# Regla para permitir FTP a los servidores.
echo -ne "[.] Activando reglas FORWARD para ftp a la IP de eth2"
iptables -A FORWARD -i eth2 -s IP ORIGEN/24 -p tcp --dport 20:21 -o eth0 -d IP DESTINO -j ACCEPT
echo -ne " -> [ OK ]\n "

iptables -A FORWARD -i eth2 -o eth0 -s 192.168.0.0/24 -m state --state ESTABLISHED,RELATED -j ACCEPT }
Lines=0
cat $BLACKLIST | while read line;
do {
 echo -ne "[.]Denegando acceso a $line"
 iptables -A FORWARD -d $line -p tcp --dport 80-j DROP
 echo -ne "-> [ OK ]\n"
 ((Lines++))
   }
done


case "$1" in
 start)
 start
 ;;
 
 stop)
 stop
 ;;
 
 restart)
 stop
 start;;
 *)
 echo -ne " Uso: $0 {start | stop | restart } \n"

esac
exit

============== FIN SCRIPT ==================

Las prisas son malas compañeras y durante la redacción de este post, el becario en lugar de guardar le dió a publicar 🙂 , esperamos que este post (algo distinto de lo habitual) os sirva para tener una idea de lo que se puede hacer. Más adelante, veremos como testear las distintas reglas y algún truco más.

Guía Hardening – Configuración de redes y Firewall – IPtables Parte 1

Antes de continuar con esta guía quiero aclarar un aspecto de esta entrada, hace ya casi 5 años escribí en mi blog personal sobro el uso de IPtables, y hemos decidido rescatarlo para esta entrada de la guía, y ampliarlo para completarlo y mejorarlo.

Llegados a este punto de la guía tenemos que tomarlo con más calma, en esta ocasión trataremos la configuración óptima de la red y el uso de cortafuegos y medidas de protección, para ello primero debemos saber como funciona en este caso IPtables.

Iptables es seguramente la herramienta más conocida del Framework Netfilter, que se encuentra incluido en el núcleo de Linux desde marzo de 2000, es el predecesor de Ipcahins , aquí podéis encontrar algunas de las diferencias entre ambos, también podemos decir sin duda alguna que es una de las herramientas por excelencia para la gestión de servidores.

Con iptables nos podemos encargar de la administración de las políticas y reglas de las tablas que por defecto crea iptables, estas 3 tablas predeterminadas son, la tabla FILTER, tabla NAT y tabla MANGLE.

Para gestionar la tabla filter, nos bastara el comando iptables junto a sus diferentes opciones y especificaciones, y a continuación veremos como gestionar la tabla filters.

Empecemos por lo básico, cómo es la jerarquía de una tabla en Iptables, para ver nuestra tabla, abriremos un terminal y ejecutaremos el siguiente comando:

#iptables -L

Chain INPUT (policy ACCEPT)
target prot opt source destination

Chain FORWARD (policy ACCEPT)
target prot opt source destination

Chain OUTPUT (policy ACCEPT)
target prot opt source destination

Como podéis ver tenemos la tabla que esta compuesta por las cadenas (políticas) que a su vez definen las reglas, que por defecto acepta todo.

CADENAS INPUT, OUTPUT Y FORWARD

Estas 3 cadenas o políticas las podemos modificar para administra el comportamiento de los paquetes, estas políticas son las que definirán el comportamiento por defecto de iptables para todas las reglas.

input sera la encargada de decidir que hacer con los paquetes que entran, la cadena
output se encargara de los paquetes que salen y la cadena
forward se encarga de los paquetes que no van dirigidos a nosotros ni hemos creado localmente.

REGLAS

Con estas reglas indicamos a la cadena que hacer con el paquete, comparando las propiedades del destino, si es aceptado (ACCEPT), descartado (DROP), lo deja en cola (QUEUE) o lo retorna (RETURN), si coincide con la regla de destino de la cadena, aborta el proceso en el resto de cadenas y el paquete es destinado, si por el contrario no coincide con una cadena pasa a la siguiente.

ACCEPT: Acepta el paquete

DROP: Descarta el paquete

QUEUE: Deja en la cola el paquete

RETURN: Retorna el paquete

Este proceso se genera con todos los paquetes, ya sean generados localmente o procedentes del exterior, por lo que con iptables tendremos un control más específico de todo el tráfico de red, y aplicando diferentes reglas a las diferentes cadenas podemos conseguir una mayor seguridad de nuestro sistema, incluso dejarnos incomunicados totalmente, cuidado.

TRABAJANDO CON IPTABLES

Lo primero que debemos hacer es abrir una terminal como superusuario, una vez echo esto y para poder ver la ayuda de iptables escribimos lo siguiente:

#iptables -h

Como podéis ver al introducir iptables -h lo que hace es mostrarnos la ayuda de iptables, en la que se detalla todas las opciones de que disponemos, lo primero que haremos será listar las cadenas de la tabla filter:

#iptables -L

Chain INPUT (policy ACCEPT)
target prot opt source destination

Chain FORWARD (policy ACCEPT)
target prot opt source destination

Chain OUTPUT (policy ACCEPT)
target prot opt source destination

También se puede especificar la cadena por el nombre, por ejemplo:

#iptables -L INPUT

Chain INPUT (policy ACCEPT)
target prot opt source       destination

Ahora ya podemos continuar con la creación y eliminación de cadenas con las siguientes opciones, para ello crearemos la cadena prueba y la eliminaremos.

#iptables -N prueba

Chain prueba (0 references)
target prot opt source  destination 

Y para eliminarla:

#iptables -X prueba

Ya hemos visto cómo listar, crear y eliminar cadenas, pero tenemos más opciones:

#iptables -A  Añade una regla al final de la cadena indicada.

#iptables -D Borra una regla pero indicando el numero de regla.

#iptables -E  Renombrar una cadena.

#iptables -F  Limpia la cadena indicada de las reglas, si no especificas la cadena borra todas las reglas de todas las cadenas.

#iptables -I  Añade una regla pero indicando en que lugar dentro de la cadena.

#iptables -P  Cambia la política de una cadena indicada.

#iptables -R  Remplaza una regla en una cadena indicada.

#iptables -Z  Pone a cero los contadores de bytes y paquetes de todas las cadenas de la tabla.

Como podemos ver tenemos varias opciones que todavía se deben de ampliar más, además con alguna de las opciones debemos fijarnos en especificar bien la cadena o podemos borrar las reglas de todas las cadenas, también podéis ver que todas las opciones se indican con letra mayúscula.

Si os habéis fijado cuando hemos creado la cadena y la listamos aparecía lo siguiente :

Chain prueba (0 references)
target prot opt source destination

Esto es debido, que al crear cadena no hemos indicado las reglas o políticas a seguir, ahora avanzaremos un poco más haciendo un cambio en la cadena, y además indicándole el puerto, protocolo y que hacer con los paquetes, os recuerdo que las cadenas existentes son INPUT, OUTPUT y FORWARD.

#iptables -A INPUT  -p tcp –dport 21 -i DROP

Aquí ya empezamos con más opciones, explicaremos un poco que es lo que estamos haciendo.

#iptables -A INPUT  Aquí estamos indicando que queremos añadir con -A al final del la cadena INPUT  las siguiente regla.

-p tcp  Con -p configuramos el protocolo y con tcp le indicamos cual (icmp, tcp, udp, all)

–dport 21  Con — dport le indicamos el puerto, en este caso el 21 (FTP)

-i DROP  Con -i  podríamos especificar alguna interfaz ( eth0, wlan1..) o como en este caso, si no le indicamos la interfaz se aplicara a todas.

Y finalmente con DROP, descartamos el paquete , por lo que en definitiva lo que hemos conseguido es cerrar el puerto 21, cómo es lógico podemos cambiar el protocolo, número de puerto y regla, y así ajustar iptables a nuestra necesidad.

Otro ejemplo, pero en este caso añadimos otra opción :

#iptables -A INPUT -s 87.34.57.8 -p tcp –dport 22 -i ACCEPT

Ahora con -A añadimos esta regla al final de la cadena y con -s  especificamos una ip entrante, si además al final de la dirección IP le añadimos /20 , le indicamos un rango de puertos entre el 8 y el 20 que pueden acceder por el puerto 22 de nuestro sistema.

Explico alguna opción más :

-p Configuramos el protocolo.

-s Indicamos la dirección de origen , también puede ser el nombre de un host, o una dirección de red. 

-d Indicamos el destino puede ser igual que en -s un host, dirección de red o IP.

-i  Especificamos la interfaz de entrada.

-o Especificamos la interfaz de salida.

-f: Aplica la regla solo a paquetes fragmentos.

-j Especificamos el destino del paquete.

¿Y como guardo los cambios que haga?

Ya que cada vez que reiniciemos el sistema o apaguemos, los cambios se perderán es necesario poder guardar los cambios , siguiendo estos pasos podrás hacerlo :

#iptables-save >  ruta/nombre del fichero

Si añadimos -c  también guardara los contadores y para recupera la configuración al inicio:

#iptables restore < ruta/nombre del fichero

Para poder cargar automáticamente la configuración de iptables podemos guardar el archivo el directorio /etc/ y editar el archivo interfaces en /etc/network con las siguientes lineas :

auto eth0
iface eth0
inet dhcp
pre-up iptables-restore < /etc/nombre de archivo

Como podemos ver podríamos extender esta entrada mucho más, pero creo que para tener unos conocimientos básicos de funcionamiento y configuración de iptables es suficientes, en la próxima parte y con la colaboración de @fpalenzuela, explicaremos cómo montar un script para proteger nuestro sistema o red y profundizar un poco más en IPtables.

¡¡ Hasta la próxima piratas !!

Guía Hardening – Gestion de usuarios y grupos

Una de los aspectos más críticos como administrador de sistemas puede ser la gestión de usuarios, y esto depende en muchas ocasiones más por el número de usuarios a gestionar que por su complejidad “técnica”. En un principio en toda instalación se crea habitualmente el usuario Root y un usuario sin privilegios, hasta aquí todo bien, es más se crean automáticamente los grupos de sistema y sus privilegios, por lo que generalmente no solemos encontrar ningún problema con la gestión de usuarios, pero todo esto se convierte en auténticos quebraderos de cabeza cuando el número aumenta e incluso te ves limitado por un $Hyperboss como lo llamaría el maestro wardog.
Como he dicho técnicamente la gestión es sencilla y para el que no tenga mucha idea daré unos ejemplos sencillos a continuación.

Creación de usuarios

# adduser nombre de usuario

Modificación de usuarios

# usermod nombre de usuario

Eliminación de usuarios

# deluser nombre de usuario

Cambiar contraseña

# passwd nombre de usuario

Bloquear o desbloquear una cuenta de usuario

# passwd -l nombre de usuario
# passwd -u nombre de usuario

Bloquear cuantas inactivas pasados 30 dias

# useradd -D -f 30

Creación de grupos

# addgroup nombre de grupo

Modificación de grupos

# groupmod nombre de grupo

Eliminación de grupos

# groupdel nombre del grupo

Añadir usuarios a un grupo

# adduser nombre de usuario nombre de grupo

Quitar usuarios de un grupo

# deluser nombre de usuario nombre de grupo

Para todos los ejemplos y comandos citados arriba recomiendo echar un vistazo a su ayuda para ampliar su uso según necesidades, que pueden ser muy variadas y cambiar muchos aspectos de cada usuario, podemos cambiar el home, o la shell con la que interactúa el usuario entre otras muchas opciones.

PERMISOS

Este apartado es algo que debemos tener muy claro y DOCUMENTADO, es muy importante, y según el número de usuarios y grupos con los que trabajemos, las necesidades de cada usuario a la hora de acceder o editar ciertos ficheros, o la entrada y salida de trabajadores, se puede convertir en un aspecto muy variable y siempre se puede topar esta necesidad, con la seguridad, caballo de batalla en el mundo empresarial, que hoy en día todavía cuesta de explicar y hacer entender a ciertas personas.
Cada usuario y grupo de usuarios tiene que tener una política muy clara y concisa sobre sus permisos, esto lo debemos tener muy documentado y actualizado, y es que aquí nos jugamos mucho, no solo por mantener una seguridad externa, si no como en muchas casos a ocurrido, el acceso sin control a cierta documentación o archivos por trabajadores descontentos (con motivo o sin el), pueden acabar en manos de la competencia o en el peor de los casos en manos  de alguien que puede conseguir acceso a nuestros sistemas.
Y aquí es cuando entra en juego CHMOD, necesario para cambiar estos permisos, llegados a este punto todos deberíamos conocer como funciona,  pero si todavía queda algún despistado, aquí una ayuda sobre el comando.
Si ya tenemos unas políticas de usuarios definidas y los permisos de usuarios y grupos al día podemos pasar a verificar posibles vectores de seguridad.

Verificar Permisos y propietarios en /etc/passwd.

Verificamos
# ls -l /etc/passwd
 -rw-r--r-- 1 root root 1658 OCT 13 10:50 /etc/passwd
Cambiamos permiso si es necesario
# chmod 644 /etc/passwd
Cambiamos propietario si no es correcto
# chown root:root /etc/passwd

Verificar Permisos  y propietarios /etc/shadow.

# ls -l /etc/shadow
 -rw-r----- 1 root shadow 1061 oct 13 10:50 /etc/shadow
Cambiamos si es necesario
# chmod 640 /etc/shadow
Cambiamos propietario si no es correcto
# chown root:shadow /etc/shadow

Verificar Permisos  y propietarios /etc/group.

# ls -l /etc/group
 -rw-r--r-- 1 root root 885 oct 13 10:50 /etc/group
Cambiamos si es necesario
# chmod 644 /etc/group
Cambiamos propietario si no es correcto
# chown root:root /etc/group

También podemos hacer estas comprobaciones en archivos y carpetas de usuarios.

CONTRASEÑAS

En la primer capítulo de esta guía de hardenig  ya hablamos de la importancia de ella y dimos algunos enlaces para crear nuestras contraseñas, en este punto de la gestión de usuarios y grupos,  debemos tratar con el mismo o mayor cuidado este aspecto, y adaptarnos si así nos lo imponen, ya sabemos que cuanto más complejas sean estas mucho mejor, pero se puede dar el caso de que nos exijan que no superen lo 6 u 8 caracteres y que solo contengan números y letras, si, ya se, pero la vida es así y es lo que toca en muchas ocasiones.
Por otro lado debemos documentar y guardar esta contraseñas, podemos utilizar cualquier plataforma, aplicación o sistema que más nos guste, pero con un mino de seguridad, deben de estar cifradas, protegidas, siempre accesibles y una copia de seguridad de ellas por cualquier imprevisto, a partir de aquí vale todo (excel, keepass, lastpass, 1password, etc, etc…) yo no soy el que te dirá cual es mejor o peor, o cual utilizar.

Otro parte de la gestión, al igual que con usuarios y grupos, es la verificación de las contraseñas y aplicar una política concreta sobre ellas, aquí unos ejemplos.

Asegurar que los campos de contraseña no estén vacíos

Comprobamos si hay algun usuario sin contraseña
# cat /etc/shadow | /usr/bin/awk -F: '($2 == "" ) { print $1 " does not have a password "}'
Bloqueamos usuario hasta comprobar la causa y eliminamos si es necesario
# passwd -l nombre de usuario
# deluser nombre de usuario

 

Establecer días de caducidad de contraseña

Comprobamos
# grep PASS_MAX_DAYS /etc/login.defs 
 PASS_MAX_DAYS 60
# chage --list usuario
 Maximum number of days between password change:    60
Cambiamos si es necesario
# vim /etc/login.defs
PASS_MAX_DAYS 30
# chage --maxdays 30 usuario

Configurar el cambio de contraseña Número mínimo de días

Comprobamos
# grep PASS_MIN_DAYS /etc/login.defs 
 PASS_MIN_DAYS 14
# chage --list usuario
 Minimun number of days between password change:    14
Cambiamos si es necesario
# vim /etc/login.defs
PASS_MIN_DAYS 7
# chage --mindays 7 usuario

Definir días de advertencia de caducidad de la contraseña

# grep PASS_WARN_DAYS /etc/login.defs 
 PASS_MIN_DAYS 14
# chage --list usuario
 Number of days of warning before password expires:    14
Cambiamos si es necesario
# vim /etc/login.defs
PASS_WARN_AGE 7
# chage --warndays 7 usuario


Como hemos visto hoy tener unas políticas, tanto de usuario y grupos como de contraseñas, es una parte muy importante, ya sea en un entorno particular o empresarial, y si a esto le unimos la comprobación y actualización periódica de estas políticas, tendremos un sistema mucho más seguro.

Como regalo dejo aquí un tuit del gran Daboblog, que encontré entre mis notas mientras repasaba para escribir esta entrada, espero que también os sirva de ayuda.

¡¡Hasta la próxima parte de la guía, saludos!!

Guía Hardening – Hardware, habilitar y deshabilitar.

Hoy volvemos con una entrada centrada en intentar controlar el hardware de nuestras maquinas, esta entrada esta orientada al uso personal, primero recomiendo pasarse por el capitulo 2º de la guía de Hardening, en el que hablamos de la BIOS y algunos aspectos de su configuración para continuar después con esta entrada, pues puede ser que algunas de las opciones que indicamos en este capitulo se puedan ejecutar de una manera mas sencilla y rápida en la BIOS, aunque como siempre decimos, no esta mal saber antes como hacer cualquier tarea en modo manual, que con una bonita GUI y el proceso automatizado.

MODULOS DEL KERNEL LINUX

Los módulos en el Kernel Linux son los encargados de cargar los controladores de dispositivos de hardware, y podemos habilitar o deshabilitar estos módulos para mejorar la seguridad de nuestras maquinas, y si en nuestra BIOS no disponemos de estas opciones, gracias a comandos como modprobe podemos quitar o añadir dichos módulos, pero antes debemos conocer como obtener información de los módulos que tenemos cargados y saber cuales son innecesarios para nuestra maquina.

LSMOD, LSPCI, MODINFO, MODPROBE

Para esta tarea disponemos de varios comandos ¿pero que buscamos?
En nuestro caso y teniendo en cuenta que hemos instalado nuestra Debian en una portátil o computadora de sobremesa, tendremos en cuenta que dichas maquinas disponen de hardware integrado, ya sean puertos USB, unidades de CD o una webcam en el caso de los portátiles, y en muchas ocasiones y según la utilidad que le busquemos a nuestras maquinas pueden ser innecesarios.

LSMOD nos mostrara en varias columnas la información de los módulos cargados ,dicha información proviene del archivo /proc/modules, la primera columna muestra el nombre del modulo, la segunda columna el tamaño del modulo en bytes, y la tercera columna muestra si el modulo depende de otro modulo para funcionar.

[simterm]root@debian:~#lsmod
Module                  Size  Used by
nls_utf8               12456  0 
btrfs                 863535  0 
xor                    21040  1 btrfs
raid6_pq               95238  1 btrfs
ufs                    73443  0 
qnx4                   13036  0 
hfsplus               101391  0 
hfs                    53845  0 
minix                  31387  0 
ntfs                  194605  0 
vfat                   17135  0 
msdos                  17046  0 
fat                    61986  2 vfat,msdos
.....[/simterm]

LSPCI muestra la información detallada de los buses PCI y dispositivos en el sistema,

[simterm]root@debian:~#lspci

00:00.0 Host bridge: Intel Corporation 440FX – 82441FX PMC [Natoma] (rev 02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]
00:01.1 IDE interface: Intel Corporation 82371AB/EB/MB PIIX4 IDE (rev 01)
00:02.0 VGA compatible controller: InnoTek Systemberatung GmbH VirtualBox Graphics
Adapter
00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller
(rev 02)
00:04.0 System peripheral: InnoTek Systemberatung GmbH VirtualBox Guest Service
00:05.0 Multimedia audio controller: Intel Corporation 82801AA AC’97 Audio
Controller (rev 01)
00:06.0 USB controller: Apple Inc. KeyLargo/Intrepid USB
00:07.0 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 08)
00:0d.0 SATA controller: Intel Corporation 82801HM/HEM (ICH8M/ICH8M-E) SATA Controller [AHCI mode] (rev 02)[/simterm]

Para obtener más información sobre algún dispositivo PCI puedes utilizar -vs, si te fijas al final de la información nos indica el modulo que utiliza (e1000).

[simterm]root@debian:~#lspci -vs 00:03.0
00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller
	Subsystem: Intel Corporation PRO/1000 MT Desktop Adapter
	Flags: bus master, 66MHz, medium devsel, latency 64, IRQ 19
	Memory at f0000000 (32-bit, non-prefetchable) [size=128K]
	I/O ports at d010 [size=8]
	Capabilities: [dc] Power Management version 2
	Capabilities: [e4] PCI-X non-bridge device
	Kernel driver in use: e1000[/simterm]

MODINFO muestra información sobre un modulo que le indicamos, esta información se muestra en formato “campo: valor” para una mejor lectura.
[simterm]root@debian:~#modinfo e1000

filename:       /lib/modules/3.16.0-4-amd64/kernel/drivers/net/ethernet/intel/e1000/e1000.ko
version:        7.3.21-k8-NAPI
license:        GPL
description:    Intel(R) PRO/1000 Network Driver
author:         Intel Corporation, <linux.nics@intel.com>
srcversion:     C2E6003E8479D0EA4A71DDB
alias:          pci:v00008086d00002E6Esv*sd*bc*sc*i*
alias:          pci:v00008086d000010B5sv*sd*bc*sc*i*
alias:          pci:v00008086d00001099sv*sd*bc*sc*i*[/simterm]

MODPROBE añade o quita un modulo del kernel seleccionado por nosotros, con los pasos seguidos anteriormente para obtener información del modulo a quitar, debes tener en cuenta que una vez quitado el modulo para su posterior uso debes volver a cargarlo en el Kernel.

Con modprobe -r [ nombre modulo] lo quitamos.

[simterm]root@debian:~#modprobe -r e1000[/simterm]

Si ahora haces un “lsmod | grep e1000″ veras que el modulo ya no aparece en la lista, y para volver a cargarlo debemos hacerlo con modprobe [ nombre modulo ].

[simterm]root@debian:~#modprobe e1000[/simterm]

Esta tarea la podemos realizar con cualquier modulo, nosotros hemos elegido una tarjeta de red como ejemplo, pero también puedes hacerlo con el CDROM puertos USB o cualquier otro dispositivo que no se utilice y pueda ser un vector de ataque fisico a nuestro sistema.