Seguridad

Seguridad de un servidor Ubuntu: SSH, firewall, puertos y gestión de secretos

Guía práctica para asegurar un servidor Ubuntu: SSH con llaves, firewall UFW, puertos que deben estar abiertos, fail2ban, actualizaciones y rotación de secretos.

Diagrama de firewall: los puertos 22, 80 y 443 abiertos y los puertos de bases de datos cerrados

Un servidor recién creado en la nube recibe intentos de acceso automáticos a los pocos minutos de tener IP pública. No hace falta ser un objetivo interesante: los bots prueban contraseñas de SSH, buscan bases de datos abiertas y escanean versiones vulnerables de forma continua. La buena noticia es que un puñado de medidas, aplicadas en orden, elimina la gran mayoría del riesgo.

Esta guía es para desarrolladores con conocimiento medio de servidores que van a desplegar aplicaciones en Ubuntu Server (22.04, 24.04 o posterior). Cubre acceso por SSH, firewall, qué puertos abrir, actualizaciones, usuarios, TLS, secretos y su rotación, con los comandos exactos.

Principios que guían todo lo demás

  1. Superficie mínima. Lo que no está instalado, escuchando o abierto no se puede atacar. Cada puerto y cada servicio debe tener una razón.
  2. Mínimo privilegio. Cada persona y cada proceso recibe solo los permisos que necesita.
  3. Defensa en capas. Ninguna medida es suficiente sola: firewall, autenticación fuerte, actualizaciones y monitoreo se compensan entre sí.
  4. Automatiza y deja evidencia. Lo que depende de acordarse se olvida. Actualizaciones, renovación de certificados y bloqueo de intrusos deben funcionar sin intervención.
  5. Asume que algo fallará. Prepara copias de seguridad, registros y un procedimiento para rotar secretos comprometidos.

Antes de empezar: casi todo lo que sigue puede dejarte fuera del servidor si te equivocas (SSH y firewall sobre todo). Ten a mano la consola de emergencia de tu proveedor (VNC, serial o web) y no cierres la sesión SSH activa hasta comprobar el cambio desde otra terminal.

Paso 1. Actualizar el sistema y crear un usuario propio

Lo primero en un servidor nuevo es instalar los parches pendientes:

sudo apt update && sudo apt upgrade -y

Trabajar como root es peligroso: un error o un comando malicioso tiene permisos totales. Crea un usuario administrador con sudo:

sudo adduser deploy
sudo usermod -aG sudo deploy

Usa un nombre que no sea admin, ubuntu ni root, y un usuario por persona para saber quién hizo qué. Las cuentas compartidas hacen imposible la auditoría y la baja de una persona.

Paso 2. Acceso por SSH con llaves

Las contraseñas se adivinan, se filtran y se reutilizan. Las llaves SSH, bien protegidas, son mucho más difíciles de comprometer.

Generar la llave en tu equipo (no en el servidor)

ssh-keygen -t ed25519 -a 100 -C "tu-nombre@equipo"
  • ed25519 es el algoritmo recomendado: llaves cortas y seguras.
  • -a 100 aumenta las rondas de derivación para proteger la llave privada.
  • Define una passphrase cuando te la pida. Así, si alguien roba el archivo ~/.ssh/id_ed25519, no puede usarlo directamente. Usa ssh-agent para no escribirla en cada conexión.

La llave privada (id_ed25519) nunca sale de tu máquina. Solo se comparte la pública (id_ed25519.pub).

Instalar la llave pública en el servidor

ssh-copy-id -i ~/.ssh/id_ed25519.pub deploy@IP_DEL_SERVIDOR
ssh deploy@IP_DEL_SERVIDOR      # debe entrar sin pedir la contraseña del usuario

Endurecer el servidor SSH

No edites /etc/ssh/sshd_config directamente: crea un archivo en sshd_config.d. El nombre importa: OpenSSH aplica el primer valor que encuentra para cada opción y lee los archivos en orden alfabético. Algunas imágenes en la nube traen 50-cloud-init.conf con PasswordAuthentication yes, así que el tuyo debe llamarse con un número menor.

sudo tee /etc/ssh/sshd_config.d/01-hardening.conf <<'EOF'
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
AllowUsers deploy
MaxAuthTries 3
LoginGraceTime 30
X11Forwarding no
ClientAliveInterval 300
ClientAliveCountMax 2
EOF

Qué hace cada línea:

  • PermitRootLogin no: nadie entra directamente como root.
  • PasswordAuthentication no y KbdInteractiveAuthentication no: solo se acepta autenticación por llave.
  • AllowUsers deploy: lista blanca de usuarios que pueden conectarse por SSH. Añade los que correspondan.
  • MaxAuthTries 3 y LoginGraceTime 30: limitan intentos y tiempo para autenticarse.
  • X11Forwarding no: cierra una vía que casi nunca se necesita.
  • ClientAliveInterval y ClientAliveCountMax: cierran sesiones inactivas (unos 10 minutos en este caso).

Valida antes de aplicar, y comprueba que la configuración efectiva es la que esperas:

sudo sshd -t
sudo sshd -T | grep -E 'passwordauthentication|permitrootlogin|allowusers'
sudo systemctl reload ssh

Después, abre una segunda terminal y comprueba que puedes entrar. Solo entonces cierra la sesión original. Si algo falla, la sesión abierta te permite corregirlo.

¿Cambiar el puerto 22?

Mover SSH a otro puerto reduce el ruido en los registros, pero no es una medida de seguridad: un escaneo lo encuentra en segundos. En Ubuntu 22.10 y posteriores SSH se activa por socket de systemd, así que cambiar Port en sshd_config no basta y es fácil quedarse sin acceso. Si no tienes una razón concreta, déjalo en 22 y protégelo con llaves, firewall y fail2ban.

Buenas prácticas adicionales de acceso

  • Una llave por persona y por dispositivo, nunca compartidas. Cuando alguien deja el equipo, borras su línea de ~/.ssh/authorized_keys y listo.

  • Revisa periódicamente authorized_keys de cada usuario: debe contener solo llaves que reconozcas.

  • Permisos correctos: chmod 700 ~/.ssh y chmod 600 ~/.ssh/authorized_keys. SSH ignora las llaves si los permisos son demasiado abiertos.

  • No reenvíes tu agente (ForwardAgent) a servidores que no controlas: quien sea root ahí puede usar tu llave mientras estés conectado.

  • Para varios servidores, usa un host de salto (bastion) con ProxyJump y deja los servidores internos sin IP pública:

    ssh -J deploy@bastion.example.com deploy@10.0.0.12
  • Mejor aún, una VPN (WireGuard, Tailscale) y SSH solo accesible desde la red privada. Elimina SSH de internet por completo.

  • Segundo factor para acciones sensibles: llaves de hardware (ed25519-sk con FIDO2) o autenticación con certificados SSH de corta duración en equipos grandes.

Paso 3. Firewall con UFW

UFW (Uncomplicated Firewall) viene con Ubuntu y es una capa simple sobre iptables/nftables. La política correcta es denegar todo lo entrante y permitir solo lo necesario.

Regla de oro: permite SSH antes de activar el firewall, o te quedas fuera.

sudo ufw default deny incoming
sudo ufw default allow outgoing

sudo ufw limit OpenSSH          # permite SSH y limita intentos repetidos desde una misma IP
sudo ufw allow 80/tcp           # HTTP
sudo ufw allow 443/tcp          # HTTPS

sudo ufw enable
sudo ufw status verbose

limit bloquea temporalmente una IP que abre demasiadas conexiones nuevas en poco tiempo; es un freno básico contra fuerza bruta, y se complementa con fail2ban.

Restringir SSH a tus IP

Si tienes IP fija o una VPN, abre SSH solo para ella en lugar de todo internet:

sudo ufw delete allow OpenSSH          # si ya existía la regla abierta
sudo ufw allow from 203.0.113.10 to any port 22 proto tcp

Cambia 203.0.113.10 por tu IP o rango (10.8.0.0/24 para una VPN).

IPv6

Comprueba que UFW gestiona IPv6; si no, el servidor queda abierto por esa vía:

grep ^IPV6 /etc/default/ufw     # debe decir IPV6=yes

Gestionar reglas

sudo ufw status numbered
sudo ufw delete 3               # borra la regla número 3
sudo ufw reload

Firewall de la nube: una segunda capa

AWS, Google Cloud, Azure, DigitalOcean y similares ofrecen firewalls externos (security groups, reglas de VPC). Úsalos además de UFW: filtran el tráfico antes de que llegue a la máquina y siguen protegiendo si alguien desactiva UFW por error.

Docker y UFW: una trampa conocida

Si usas Docker, los puertos publicados con -p o ports: se saltan las reglas de UFW, porque Docker escribe sus propias reglas de iptables. Un 5432:5432 queda abierto a internet aunque UFW lo bloquee. Soluciones:

  • Publica solo lo que sea público y enlaza el resto a localhost: "127.0.0.1:5432:5432".
  • Mejor aún, no publiques la base de datos: déjala accesible solo para otros contenedores de la misma red, como en la guía de Docker y Compose.
  • Usa también el firewall de la nube, que sí se aplica antes de Docker.

Paso 4. ¿Qué puertos deben estar abiertos?

Para un servidor que aloja aplicaciones web, la respuesta corta es: tres.

Puerto Servicio Estado recomendado
22/tcp SSH Abierto, restringido a IP conocidas o VPN cuando sea posible
80/tcp HTTP Abierto; solo sirve para redirigir a HTTPS y para validar certificados
443/tcp HTTPS Abierto; el tráfico real de tu aplicación

Todo lo demás debería estar cerrado al exterior. En particular, estos servicios no deben exponerse a internet:

Puerto Servicio Por qué
3306 MySQL / MariaDB Fuerza bruta y explotación directa de la base de datos
5432 PostgreSQL Ídem
6379 Redis Sin autenticación por defecto en muchas instalaciones
27017 MongoDB Historial de miles de bases expuestas y robadas
9200 Elasticsearch Acceso total a los datos sin autenticación en configuraciones antiguas
11211 Memcached Usado para ataques de amplificación
2375 / 2376 API de Docker Acceso a la API equivale a control root del servidor
5672 / 15672 RabbitMQ y su panel Panel de administración con credenciales conocidas
3000, 8080, 8000 y similares Servidores de desarrollo y aplicaciones Deben quedar detrás de un proxy inverso (Nginx, Caddy)

El patrón recomendado es un proxy inverso en los puertos 80 y 443 que recibe todo el tráfico público y lo reenvía a tus aplicaciones, que escuchan solo en 127.0.0.1 o en una red privada.

Verifica qué está escuchando

Desde el servidor, lista los puertos en escucha y qué proceso los usa:

sudo ss -tulpn

Fíjate en la columna de dirección: 127.0.0.1:5432 solo es accesible localmente, mientras que 0.0.0.0:5432 o *:5432 escucha en todas las interfaces. Si algo escucha en todas y no debe, corrige su configuración (bind-address, listen_addresses…) y no te apoyes solo en el firewall.

Desde otra máquina (y solo contra servidores tuyos), confirma lo que ve el exterior:

nmap -Pn -p- IP_DEL_SERVIDOR

La salida debería mostrar únicamente 22, 80 y 443 abiertos.

Paso 5. Bloquear intentos de intrusión con fail2ban

fail2ban lee los registros, detecta patrones como contraseñas fallidas repetidas y bloquea la IP en el firewall durante un tiempo.

sudo apt install -y fail2ban

Crea /etc/fail2ban/jail.local (nunca edites jail.conf, que se sobrescribe en las actualizaciones):

[DEFAULT]
bantime  = 1h
findtime = 10m
maxretry = 5
ignoreip = 127.0.0.1/8 ::1 203.0.113.10

[sshd]
enabled = true
backend = systemd

ignoreip sirve para que no te bloquees a ti mismo: pon tu IP fija o tu rango de VPN. Aplica y comprueba:

sudo systemctl enable --now fail2ban
sudo systemctl restart fail2ban
sudo fail2ban-client status sshd

Con autenticación solo por llave, los intentos de fuerza bruta ya no tienen éxito, pero fail2ban reduce el ruido y la carga, y es útil también para proteger otros servicios (Nginx, aplicaciones) con filtros adicionales.

Paso 6. Actualizaciones de seguridad automáticas

La mayoría de las intrusiones reales explotan vulnerabilidades conocidas con parche disponible. Activa las actualizaciones de seguridad desatendidas:

sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Por defecto instala solo parches de seguridad. Algunas actualizaciones (el kernel, por ejemplo) requieren reiniciar. Comprueba si hace falta:

[ -f /var/run/reboot-required ] && cat /var/run/reboot-required

Programa una ventana de mantenimiento para reiniciar, o activa Unattended-Upgrade::Automatic-Reboot en /etc/apt/apt.conf.d/50unattended-upgrades con una hora de baja actividad. En producción, prueba los cambios en un entorno de staging antes y usa varias instancias para reiniciar sin cortar el servicio.

Además, elimina lo que no uses:

sudo systemctl list-unit-files --state=enabled   # servicios que arrancan al iniciar
sudo apt autoremove --purge

Paso 7. Usuarios, permisos y servicios

  • Cada servicio con su propio usuario sin privilegios (por ejemplo appuser, sin shell de login): si lo comprometen, el daño queda acotado.
  • Nunca ejecutes aplicaciones como root. Tampoco contenedores, si la imagen permite usar USER.
  • sudo con criterio. Da sudo solo a quien lo necesita. Si automatizas despliegues, permite únicamente los comandos concretos mediante un archivo en /etc/sudoers.d/ editado con sudo visudo -f, en lugar de NOPASSWD: ALL.
  • Permisos de archivos. Los archivos con secretos, como .env, deben ser legibles solo por su propietario: chmod 600 .env. Los directorios de la aplicación no deben ser escribibles por todos (chmod 777 es casi siempre un error).
  • Bloquea cuentas inactivas: sudo passwd -l usuario o sudo usermod -L usuario, y elimina las que ya no se usen.

Paso 8. HTTPS con certificados renovados automáticamente

Todo el tráfico público debe ir cifrado. Let’s Encrypt emite certificados gratuitos y certbot los renueva solo. Con Nginx:

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d ejemplo.com -d www.ejemplo.com

Verifica que la renovación automática funciona:

sudo certbot renew --dry-run
systemctl list-timers | grep certbot

Los certificados duran 90 días y se renuevan antes de caducar; no necesitas calendarizar nada, pero sí monitorear que la renovación no falle. Una vez que HTTPS funcione, redirige HTTP a HTTPS y considera activar la cabecera Strict-Transport-Security (HSTS).

Paso 9. Gestión y rotación de secretos

Un secreto es cualquier dato que da acceso: contraseñas, llaves SSH, tokens de API, credenciales de base de datos, llaves de firma, claves privadas TLS.

Dónde guardarlos y dónde no

  • Nunca en el repositorio, ni siquiera en uno privado. Los historiales de Git conservan todo.
  • Nunca en la imagen de Docker ni en el código fuente.
  • En desarrollo y servidores pequeños: variables de entorno o archivo .env con permiso 600, fuera del control de versiones (.gitignore).
  • En equipos y entornos serios: un gestor de secretos (HashiCorp Vault, AWS Secrets Manager, Google Secret Manager, Azure Key Vault) o archivos cifrados dentro del repositorio con SOPS o age.
  • Escanea tus repositorios para detectar secretos subidos por error, con herramientas como gitleaks o el escaneo de secretos de tu plataforma, y bloquéalo en CI.
  • Un secreto distinto por entorno y por servicio. Desarrollo, staging y producción no comparten credenciales.

¿Con qué frecuencia rotarlos?

La rotación no es un ritual: tiene un propósito, que es limitar el tiempo de utilidad de un secreto robado y acotar los accesos que quedan olvidados. Conviene distinguir entre contraseñas de personas y secretos de máquinas.

Contraseñas de personas. Las guías actuales, como NIST SP 800-63B, desaconsejan los cambios periódicos obligatorios: llevan a contraseñas más débiles y predecibles. Es mejor usar un gestor de contraseñas, contraseñas largas y únicas, y autenticación en dos pasos, y cambiar la contraseña cuando hay sospecha o evidencia de compromiso.

Secretos de máquinas y servicios. Estos sí se benefician de la rotación, y lo ideal es automatizarla:

Secreto Rotación recomendada Rotar de inmediato cuando
Contraseñas de base de datos y servicios Cada 90 días (o automática con un gestor de secretos) Se filtra, sale una persona con acceso o hay un incidente
Tokens y API keys de terceros Cada 90 días Aparecen en un repositorio, un log o un chat
Llaves SSH de personas Revisión anual y al cambiar de equipo o dispositivo Se pierde o roba un equipo, o la persona se va
Llaves de despliegue y CI/CD Cada 6 a 12 meses Se amplía el acceso a la plataforma de CI o hay un incidente
Certificados TLS Automática (Let’s Encrypt, 60 a 90 días) Se expone la clave privada
Secretos de firma (JWT, sesiones) Cada 6 a 12 meses, con ventana de doble validez Hay sospecha de fuga

Cómo rotar sin interrumpir el servicio

  1. Crea el secreto nuevo sin eliminar el anterior.
  2. Haz que el sistema acepte ambos durante una ventana corta (por ejemplo, dos usuarios de base de datos, o dos llaves de firma).
  3. Despliega la aplicación con el secreto nuevo y verifica que funciona.
  4. Revoca el secreto anterior.
  5. Registra la rotación (fecha, quién y por qué).

Si un secreto se filtra

Trátalo como comprometido desde ese momento: rótalo primero y investiga después. Borrarlo del repositorio no basta, porque ya está en el historial y puede haber sido copiado. Revisa los registros de acceso del periodo de exposición y documenta el incidente.

Paso 10. Registros, monitoreo y copias de seguridad

Registros

sudo journalctl -u ssh --since "1 hour ago"     # actividad de SSH
last -a | head                                  # últimas sesiones
sudo lastb | head                               # intentos fallidos
sudo tail -f /var/log/auth.log                  # autenticación en tiempo real

Los registros que solo viven en el servidor desaparecen si lo comprometen. Envíalos a un servicio externo (Loki, un SIEM, el servicio de logs de tu proveedor) y configura alertas ante accesos inusuales, picos de intentos fallidos o caídas de servicios.

Copias de seguridad

  • Aplica la regla 3-2-1: tres copias, en dos soportes distintos, una fuera del servidor.
  • Cifra las copias y guarda las claves aparte.
  • Prueba la restauración periódicamente. Una copia que nunca se restauró es una suposición, no una copia.
  • Protege las copias de borrado desde el propio servidor (almacenamiento con versionado o inmutable), para que un ransomware no las elimine también.

Auditoría rápida

Lynis hace una revisión automática y da recomendaciones concretas:

sudo apt install -y lynis
sudo lynis audit system

Lista de verificación

  • Sistema actualizado y unattended-upgrades activo.
  • Usuario propio con sudo; un usuario por persona; root sin acceso SSH.
  • SSH solo con llaves ed25519 con passphrase; contraseñas desactivadas.
  • sshd -T confirma la configuración efectiva.
  • UFW activo con deny incoming; solo 22 (restringido), 80 y 443 abiertos.
  • Firewall de la nube configurado como segunda capa.
  • Bases de datos y cachés escuchando solo en 127.0.0.1 o en red privada.
  • fail2ban activo con tu IP en ignoreip.
  • HTTPS con renovación automática verificada (certbot renew --dry-run).
  • Servicios corriendo como usuarios sin privilegios.
  • Secretos fuera del repositorio, con chmod 600 y rotación definida.
  • Registros enviados fuera del servidor.
  • Copias de seguridad cifradas y restauración probada.

Errores comunes

  • Activar UFW sin permitir SSH antes. La sesión se corta y no puedes volver a entrar sin la consola del proveedor.
  • Dejar la base de datos en 0.0.0.0 “para probar”. Es de las causas más frecuentes de filtraciones masivas.
  • Confiar en UFW con Docker. Los puertos publicados lo atraviesan.
  • Reutilizar la misma contraseña o llave entre entornos. Un compromiso en desarrollo se convierte en acceso a producción.
  • Subir .env a Git “solo una vez”. Ya es parte del historial.
  • Cambiar el puerto de SSH como única defensa. Es ocultamiento, no seguridad.
  • No probar la restauración de copias. Se descubre que no funciona cuando más se necesita.
  • Ignorar los reinicios pendientes. El kernel parcheado no está en uso hasta reiniciar.

Preguntas frecuentes

¿Es suficiente con desactivar la contraseña de SSH?

Es la medida individual más importante, pero no la única. Añade el firewall, fail2ban, actualizaciones automáticas y buenas prácticas con los secretos: cada una cubre un riesgo diferente.

¿Qué hago si me bloqueé fuera del servidor?

Entra por la consola de emergencia de tu proveedor (VNC, serial o web), revisa sudo ufw status y sudo sshd -t, y corrige la regla o la configuración. Por eso conviene probar siempre desde una segunda sesión antes de cerrar la primera.

¿UFW o iptables/nftables directamente?

UFW es suficiente para la mayoría de servidores de aplicaciones y es más difícil de equivocar. Si necesitas reglas avanzadas (NAT, limitación fina de conexiones), nftables da más control.

¿Cada cuánto debo cambiar mis contraseñas?

Para personas, no por calendario: usa un gestor de contraseñas, contraseñas únicas y largas, 2FA, y cámbialas ante cualquier sospecha. Para secretos de máquinas, define una rotación periódica y automatízala siempre que se pueda.

¿Necesito un WAF o protección contra DDoS?

Para una aplicación pública, un CDN con WAF y mitigación de DDoS (Cloudflare, el de tu proveedor de nube) añade una capa valiosa por delante del servidor. No sustituye lo que se describe aquí: complementa.

Para seguir leyendo

Sobre el autor

Rootnite Engineering

Equipo de ingeniería de Rootnite

Los ingenieros detrás del software a medida, la automatización y los productos de Rootnite. Documentamos las prácticas que usamos para construir y operar sistemas en producción para que otros equipos puedan reutilizarlas.

  • Seguridad
  • Ubuntu
  • SSH
  • Firewall
  • UFW
  • Hardening
  • DevOps

¿Necesitas un equipo que trabaje así?

Diseñamos, construimos y operamos software de producción con las prácticas de estas guías. Cuéntanos sobre tu proyecto.

Contactar a Rootnite