Cómo Cambiar el Puerto SSH por Defecto

Cambiar el puerto SSH por defecto del 22 a un puerto personalizado es una medida de seguridad simple pero efectiva que reduce significativamente los ataques automatizados en tu servidor Linux. Esta guía completa te guía a través del proceso de cambiar el puerto SSH en varias distribuciones de Linux, configurar cortafuegos e implementar mejores prácticas para una configuración segura de puerto SSH.

Tabla de Contenidos

Prerrequisitos

Antes de cambiar tu puerto SSH, asegúrate de tener:

  • Servidor Linux (Ubuntu, Debian, CentOS, Rocky Linux o similar)
  • Acceso root o privilegios sudo
  • Conexión SSH activa al servidor
  • Acceso a la consola del servidor vía panel del proveedor de hosting (acceso de respaldo crítico)
  • Comprensión básica de la línea de comandos de Linux
  • Conocimiento de gestión de cortafuegos (UFW, firewalld o iptables)
  • Para sistemas basados en RHEL: Comprensión de conceptos básicos de SELinux

Advertencia crítica: Siempre mantén acceso a la consola de tu servidor antes de hacer cambios SSH. Si pierdes el acceso SSH y no tienes acceso a la consola, podrías quedar bloqueado de tu servidor.

Comprendiendo Por Qué Cambiar el Puerto SSH

Beneficios de Seguridad

1. Reduce ataques automatizados:

  • Los bots y scripts escanean el puerto 22 por defecto
  • Cambiar el puerto elimina el 99% de los intentos de fuerza bruta automatizados
  • Reduce significativamente el desorden de registros del servidor por intentos fallidos de inicio de sesión

2. Seguridad por oscuridad:

  • No es un reemplazo para medidas de seguridad apropiadas
  • Agrega una capa adicional a la estrategia de defensa en profundidad
  • Hace que los ataques dirigidos sean ligeramente más difíciles

3. Mejora el rendimiento del servidor:

  • Menos intentos de inicio de sesión automatizados reducen el uso de CPU y red
  • Registros de autenticación más limpios para un monitoreo más fácil
  • Consumo reducido de ancho de banda de escáneres de puerto

Limitaciones y Conceptos Erróneos

Lo que NO hace cambiar el puerto SSH:

  • No protege contra ataques dirigidos
  • No reemplaza la autenticación fuerte (claves SSH, 2FA)
  • No elimina la necesidad de fail2ban o herramientas similares
  • No es suficiente como única medida de seguridad

Importante: Cambiar el puerto SSH es una medida de seguridad complementaria, no un reemplazo para el endurecimiento apropiado de SSH, autenticación fuerte y configuración de cortafuegos.

Cuándo Cambiar el Puerto SSH

Escenarios recomendados:

  • Servidores públicos con SSH expuesto a internet
  • Servidores experimentando grandes volúmenes de ataques automatizados
  • Requisitos de cumplimiento para puertos no estándar
  • Servidores de desarrollo compartidos entre múltiples usuarios
  • Servidores detrás de cortafuegos corporativos restrictivos

No necesario:

  • Servidores solo accesibles vía VPN
  • Servidores con reglas de cortafuegos de lista blanca de IP
  • Servidores solo de red interna
  • Contenedores o instancias temporales

Paso 1: Elegir un Nuevo Número de Puerto SSH

Criterios de Selección de Puerto

Rangos de puerto válidos:

  • 1-1023: Puertos del sistema/privilegiados (requieren root)
  • 1024-49151: Puertos registrados (algunos asignados a servicios)
  • 49152-65535: Puertos dinámicos/privados (rango recomendado)

Opciones recomendadas de puerto SSH:

  • 2222: Alternativa común, fácil de recordar
  • 22000: Fácil de recordar, rango alto
  • 50000-60000: Rango menos comúnmente escaneado
  • Puerto alto aleatorio: Usar puerto aleatorio entre 49152-65535

Puertos a evitar:

# Verificar si el puerto ya está en uso
sudo ss -tlnp | grep :NÚMERO_PUERTO
sudo netstat -tlnp | grep :NÚMERO_PUERTO

# Puertos comunes a evitar:
# 80, 443 (HTTP/HTTPS)
# 3306 (MySQL)
# 5432 (PostgreSQL)
# 6379 (Redis)
# 8080, 8443 (HTTP/HTTPS alternativo)
# 3389 (RDP)
# 21, 22, 23, 25 (FTP, SSH, Telnet, SMTP)

Generar número de puerto aleatorio:

# Generar puerto aleatorio en rango seguro
shuf -i 49152-65535 -n 1

# O usar este método
echo $((RANDOM + 49152))

Ejemplo: Verificar si el puerto 2222 está disponible:

# Verificar si algo está escuchando en el puerto 2222
sudo ss -tlnp | grep :2222

# Si no hay salida, el puerto está disponible
# Probar conectividad al puerto (debería fallar si no está en uso)
telnet localhost 2222
nc -zv localhost 2222

Para esta guía, usaremos el puerto 2222 como ejemplo. Reemplaza con tu puerto elegido en todos los pasos.

Paso 2: Respaldar la Configuración SSH

Antes de hacer cambios, siempre respalde la configuración SSH original.

# Respaldar configuración SSH con marca de tiempo
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.backup.$(date +%Y%m%d_%H%M%S)

# Verificar que se creó el respaldo
ls -lh /etc/ssh/sshd_config.backup.*

# Alternativa: Crear directorio de respaldo
sudo mkdir -p /root/backups/ssh
sudo cp /etc/ssh/sshd_config /root/backups/ssh/sshd_config.$(date +%Y%m%d_%H%M%S)

Ver configuración SSH actual:

# Mostrar configuración actual de puerto SSH
grep -i "^Port" /etc/ssh/sshd_config

# Si está comentado, SSH está usando el puerto por defecto 22
# Ver todas las configuraciones activas (sin comentarios)
grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"

Documentar configuración actual:

# Crear documentación de configuración
cat > /tmp/ssh-config-pre-change.txt << EOF
Configuración SSH Antes del Cambio de Puerto
Fecha: $(date)
Servidor: $(hostname)
Puerto Actual: $(grep -i "^Port" /etc/ssh/sshd_config || echo "22 (por defecto)")
Escuchando: $(sudo ss -tlnp | grep sshd)
EOF

cat /tmp/ssh-config-pre-change.txt

Paso 3: Configurar el Nuevo Puerto SSH

Editar la Configuración del Daemon SSH

# Editar archivo de configuración SSH
sudo nano /etc/ssh/sshd_config

# O usar vi/vim
sudo vi /etc/ssh/sshd_config

Encontrar y modificar la directiva Port:

Busca esta línea (puede estar comentada con #):

#Port 22

Opción 1: Configuración de puerto único (recomendado después de probar)

Cambiar a tu nuevo puerto:

Port 2222

Opción 2: Configuración de puerto dual (recomendado durante la transición)

Escuchar en ambos puertos antiguo y nuevo temporalmente:

Port 22
Port 2222

¿Por qué configuración de puerto dual?

  • Permite probar el nuevo puerto sin perder acceso en el puerto 22
  • Proporciona respaldo si el nuevo puerto tiene problemas
  • Permite transición gradual para múltiples usuarios
  • Puede revertirse fácilmente si ocurren problemas

Configuraciones adicionales recomendadas de endurecimiento SSH:

Mientras editas, considera estas mejoras de seguridad:

# Deshabilitar inicio de sesión root
PermitRootLogin no

# Deshabilitar autenticación por contraseña (usar claves SSH)
PasswordAuthentication no

# Deshabilitar contraseñas vacías
PermitEmptyPasswords no

# Limitar intentos de autenticación
MaxAuthTries 3

# Establecer tiempo de gracia de inicio de sesión
LoginGraceTime 30

# Deshabilitar reenvío X11 si no es necesario
X11Forwarding no

# Usar solo cifrados fuertes
Ciphers [email protected],[email protected],[email protected],aes256-ctr,aes192-ctr,aes128-ctr

# Usar MACs fuertes
MACs [email protected],[email protected]

# Usar algoritmos de intercambio de claves fuertes
KexAlgorithms curve25519-sha256,[email protected],diffie-hellman-group-exchange-sha256

Guardar y salir del archivo:

  • nano: Presionar Ctrl+X, luego Y, luego Enter
  • vi/vim: Presionar Esc, escribir :wq, presionar Enter

Probar sintaxis de configuración SSH:

# Verificar que la configuración no tenga errores de sintaxis
sudo sshd -t

# Si se muestran errores, corregirlos antes de continuar
# Sin salida significa que la configuración es válida

Ver cambios de configuración:

# Comparar con respaldo
diff /etc/ssh/sshd_config.backup.* /etc/ssh/sshd_config

# Mostrar configuración de puerto
grep -i "^Port" /etc/ssh/sshd_config

Paso 4: Configurar el Cortafuegos para el Nuevo Puerto

Antes de reiniciar SSH, configura tu cortafuegos para permitir el nuevo puerto.

Cortafuegos UFW (Ubuntu/Debian)

# Verificar estado de UFW
sudo ufw status

# Permitir nuevo puerto SSH
sudo ufw allow 2222/tcp comment 'Puerto SSH personalizado'

# Verificar que se agregó la regla
sudo ufw status numbered

# Opcional: Permitir solo desde IP específica
sudo ufw allow from 203.0.113.50 to any port 2222 proto tcp

# Recargar UFW
sudo ufw reload

Firewalld (CentOS/Rocky Linux/RHEL)

# Verificar estado de firewalld
sudo firewall-cmd --state

# Agregar nuevo puerto SSH permanentemente
sudo firewall-cmd --permanent --add-port=2222/tcp

# O crear definición de servicio personalizado
sudo firewall-cmd --permanent --new-service=ssh-custom
sudo firewall-cmd --permanent --service=ssh-custom --set-description="SSH en puerto personalizado"
sudo firewall-cmd --permanent --service=ssh-custom --add-port=2222/tcp
sudo firewall-cmd --permanent --add-service=ssh-custom

# Recargar cortafuegos
sudo firewall-cmd --reload

# Verificar reglas
sudo firewall-cmd --list-all
sudo firewall-cmd --list-ports

Iptables (Configuración Directa)

# Permitir nuevo puerto SSH
sudo iptables -A INPUT -p tcp --dport 2222 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
sudo iptables -A OUTPUT -p tcp --sport 2222 -m conntrack --ctstate ESTABLISHED -j ACCEPT

# Guardar reglas de iptables (Ubuntu/Debian)
sudo netfilter-persistent save
# O
sudo iptables-save | sudo tee /etc/iptables/rules.v4

# Guardar reglas de iptables (CentOS/Rocky Linux)
sudo service iptables save
# O
sudo iptables-save | sudo tee /etc/sysconfig/iptables

# Ver reglas
sudo iptables -L -n -v | grep 2222

Cortafuegos de Proveedores de Nube

No olvides los cortafuegos externos:

Si usas proveedores de nube (AWS, DigitalOcean, GCP, Azure, etc.), también configura sus grupos de seguridad/cortafuegos:

Grupos de Seguridad de AWS:

  • Agregar regla de entrada: Puerto TCP 2222 desde tu IP o 0.0.0.0/0

Cortafuegos en la Nube de DigitalOcean:

  • Agregar regla de entrada: Puerto TCP 2222

Google Cloud Platform:

  • Crear regla de cortafuegos permitiendo TCP:2222

Grupos de Seguridad de Red de Azure:

  • Agregar regla de seguridad de entrada para puerto 2222

Paso 5: Configurar SELinux (Sistemas Basados en RHEL)

En CentOS, Rocky Linux, AlmaLinux y RHEL, SELinux debe configurarse para permitir SSH en el nuevo puerto.

Verificar Estado de SELinux

# Verificar si SELinux está en modo enforcing
sestatus
getenforce

# Ver puertos SSH actuales permitidos por SELinux
sudo semanage port -l | grep ssh
# Salida por defecto incluye: ssh_port_t tcp 22

Agregar Nuevo Puerto a SELinux

# Instalar herramientas de gestión de SELinux si no están presentes
sudo dnf install policycoreutils-python-utils -y

# Agregar nuevo puerto SSH a la política de SELinux
sudo semanage port -a -t ssh_port_t -p tcp 2222

# Verificar que se agregó el puerto
sudo semanage port -l | grep ssh
# Ahora debería mostrar: ssh_port_t tcp 22, 2222

Si el puerto ya está definido para otro servicio:

# Puede ocurrir este error:
# ValueError: Port tcp/2222 already defined

# Verificar qué servicio usa el puerto
sudo semanage port -l | grep 2222

# Si necesitas reasignar el puerto
sudo semanage port -m -t ssh_port_t -p tcp 2222

Alternativa: Establecer temporalmente SELinux en permisivo (no recomendado):

# Solo para solución de problemas - no para producción
sudo setenforce 0

# Después de solucionar problemas, volver a enforcing
sudo setenforce 1

Verificar Configuración de SELinux

# Verificar denegaciones de SELinux
sudo ausearch -m AVC -ts recent | grep sshd

# Si existen denegaciones, generar política
sudo ausearch -m AVC -ts recent | grep sshd | audit2allow -M ssh_custom_port
sudo semodule -i ssh_custom_port.pp

Paso 6: Reiniciar el Servicio SSH

Ahora reinicia el servicio SSH para aplicar la nueva configuración de puerto.

Crítico: No cierres tu sesión SSH actual hasta que hayas verificado que el nuevo puerto funciona.

# Probar configuración una vez más
sudo sshd -t

# Reiniciar servicio SSH (sistemas systemd)
sudo systemctl restart sshd

# Verificar que el servicio SSH está ejecutándose
sudo systemctl status sshd

# Métodos alternativos de reinicio (sistemas antiguos)
sudo service sshd restart
sudo /etc/init.d/ssh restart

Verificar si SSH está escuchando en el nuevo puerto:

# Verificar que SSH está escuchando en el nuevo puerto
sudo ss -tlnp | grep sshd
sudo netstat -tlnp | grep sshd

# Debería mostrar líneas como:
# tcp    0    0 0.0.0.0:22    0.0.0.0:*    LISTEN    1234/sshd
# tcp    0    0 0.0.0.0:2222  0.0.0.0:*    LISTEN    1234/sshd

Ver registros del servicio SSH:

# Verificar errores en registros SSH
sudo journalctl -u sshd -n 50 --no-pager

# O ver registro de autenticación
sudo tail -f /var/log/auth.log  # Ubuntu/Debian
sudo tail -f /var/log/secure    # CentOS/Rocky

Paso 7: Probar el Nuevo Puerto SSH

Crítico: Prueba el nuevo puerto en una sesión de terminal separada antes de cerrar tu conexión actual.

Probar desde Máquina Local

Abre una nueva ventana de terminal en tu máquina local:

# Probar conexión SSH en nuevo puerto
ssh -p 2222 username@ip_de_tu_servidor

# Modo verbose para solución de problemas
ssh -v -p 2222 username@ip_de_tu_servidor

# Probar con timeout
timeout 10 ssh -p 2222 username@ip_de_tu_servidor

Si la conexión tiene éxito:

Deberías poder iniciar sesión normalmente. Mantén ambas sesiones abiertas (antigua y nueva) por ahora.

Si la conexión falla:

NO cierres tu sesión SSH original. Soluciona problemas usando los pasos en la sección de Solución de Problemas más abajo.

Probar Conectividad de Puerto

# Probar si el puerto es alcanzable (desde máquina local)
nc -zv ip_de_tu_servidor 2222
telnet ip_de_tu_servidor 2222

# Probar desde el servidor mismo
nc -zv localhost 2222
telnet localhost 2222

# Verificar si el puerto está abierto (desde servicio externo)
# Usar verificador de puertos en línea: https://www.yougetsignal.com/tools/open-ports/

Verificar que Ambos Puertos Funcionan (si usas configuración dual)

# Probar puerto antiguo (puerto 22)
ssh -p 22 username@ip_de_tu_servidor

# Probar nuevo puerto (puerto 2222)
ssh -p 2222 username@ip_de_tu_servidor

# Ambos deberían funcionar si configuraste puertos duales

Paso 8: Actualizar la Configuración SSH del Cliente

Hacer la conexión a tu servidor conveniente actualizando la configuración de tu cliente SSH.

Configuración SSH en Linux/macOS

# Editar archivo de configuración SSH
nano ~/.ssh/config

# Agregar o modificar entrada de servidor:
Host myserver
    HostName ip_de_tu_servidor
    User username
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
    ServerAliveInterval 60
    ServerAliveCountMax 3

# O para dominio específico
Host example.com
    Port 2222
    User admin

# O para todos los servidores (usar con precaución)
Host *
    Port 2222

Ahora puedes conectarte simplemente con:

ssh myserver
# En lugar de: ssh -p 2222 username@ip_de_tu_servidor

Establecer permisos apropiados:

# La configuración SSH debe tener permisos correctos
chmod 600 ~/.ssh/config

Actualizar Scripts de Automatización

Actualizar cualquier script o automatización que se conecte vía SSH:

# En scripts, actualizar comandos SSH:
# Antiguo:
ssh user@host 'command'

# Nuevo:
ssh -p 2222 user@host 'command'

# O para scp:
scp -P 2222 file.txt user@host:/path/

# O para rsync:
rsync -avz -e "ssh -p 2222" /local/ user@host:/remote/

Actualizar Claves SSH y Agentes

# Agregar clave de host para nuevo puerto
ssh-keyscan -p 2222 ip_de_tu_servidor >> ~/.ssh/known_hosts

# O eliminar clave de host antigua y agregar nueva en primera conexión
ssh-keygen -R ip_de_tu_servidor
ssh -p 2222 username@ip_de_tu_servidor

Paso 9: Cerrar el Puerto SSH Antiguo

Después de confirmar que el nuevo puerto funciona de manera confiable durante varios días, cierra el puerto antiguo.

Actualizar Configuración SSH

# Editar configuración SSH
sudo nano /etc/ssh/sshd_config

# Eliminar o comentar puerto antiguo:
# Port 22  <- Comentar o eliminar esta línea
Port 2222

# Guardar y probar
sudo sshd -t

# Reiniciar SSH
sudo systemctl restart sshd

Eliminar Puerto Antiguo del Cortafuegos

UFW:

# Eliminar regla SSH antigua (¡ten cuidado!)
sudo ufw delete allow 22/tcp

# O deshabilitar solo desde fuente específica
sudo ufw status numbered
sudo ufw delete [número_regla]

# Verificar
sudo ufw status

Firewalld:

# Eliminar servicio SSH antiguo
sudo firewall-cmd --permanent --remove-service=ssh

# O eliminar puerto
sudo firewall-cmd --permanent --remove-port=22/tcp

# Recargar
sudo firewall-cmd --reload

# Verificar
sudo firewall-cmd --list-all

Iptables:

# Eliminar reglas SSH antiguas
sudo iptables -D INPUT -p tcp --dport 22 -j ACCEPT

# Guardar reglas
sudo netfilter-persistent save

Verificar que el Puerto Antiguo está Cerrado

# Verificar que SSH no está escuchando en puerto 22
sudo ss -tlnp | grep :22

# Probar conexión (debería fallar)
ssh -p 22 username@ip_de_tu_servidor
# Debería agotar tiempo de espera o ser rechazado

Verificación

Lista de Verificación Completa

# 1. Verificar que SSH está escuchando en nuevo puerto
sudo ss -tlnp | grep sshd

# 2. Verificar que el cortafuegos permite nuevo puerto
sudo ufw status | grep 2222  # Ubuntu/Debian
sudo firewall-cmd --list-ports  # CentOS/Rocky

# 3. Verificar que SELinux permite nuevo puerto (basado en RHEL)
sudo semanage port -l | grep ssh

# 4. Probar conexión desde fuente externa
ssh -p 2222 username@ip_de_tu_servidor

# 5. Verificar estado del servicio SSH
sudo systemctl status sshd

# 6. Revisar registros SSH para errores
sudo journalctl -u sshd -n 50 --no-pager

# 7. Verificar que el puerto antiguo está cerrado (después de transición)
sudo ss -tlnp | grep :22
nc -zv ip_de_tu_servidor 22  # Debería fallar

# 8. Verificar conexiones SSH activas
sudo ss -tnp | grep sshd
w

# 9. Verificar que la autenticación funciona
ssh -p 2222 username@ip_de_tu_servidor 'whoami'

# 10. Verificar configuración de fail2ban (si está instalado)
sudo fail2ban-client status sshd

Crear Script de Verificación

# Crear script de verificación
cat << 'EOF' | sudo tee /usr/local/bin/verify-ssh-port.sh
#!/bin/bash

echo "=== Verificación de Configuración de Puerto SSH ==="
echo ""

echo "Estado del Servicio SSH:"
systemctl status sshd | grep Active

echo ""
echo "Puertos de Escucha:"
ss -tlnp | grep sshd

echo ""
echo "Configuración de Puerto SSH:"
grep -i "^Port" /etc/ssh/sshd_config

echo ""
echo "Reglas de Cortafuegos:"
if command -v ufw &> /dev/null; then
    ufw status | grep -E "22|2222"
elif command -v firewall-cmd &> /dev/null; then
    firewall-cmd --list-ports | grep -E "22|2222"
fi

echo ""
if command -v getenforce &> /dev/null; then
    echo "Puertos SSH de SELinux:"
    semanage port -l | grep ssh
fi

echo ""
echo "Conexiones SSH Activas:"
ss -tnp | grep sshd | grep ESTAB

EOF

sudo chmod +x /usr/local/bin/verify-ssh-port.sh
sudo /usr/local/bin/verify-ssh-port.sh

Solución de Problemas

No se Puede Conectar al Nuevo Puerto

Problema: La conexión SSH agota tiempo de espera o es rechazada en nuevo puerto.

Lista de verificación de solución:

# 1. Verificar que SSH está escuchando en el puerto
sudo ss -tlnp | grep sshd
sudo netstat -tlnp | grep sshd

# 2. Verificar que el servicio SSH está ejecutándose
sudo systemctl status sshd

# 3. Verificar configuración SSH
sudo sshd -t
grep -i "^Port" /etc/ssh/sshd_config

# 4. Verificar que el cortafuegos permite el puerto
sudo ufw status | grep 2222
sudo firewall-cmd --list-ports

# 5. Verificar SELinux (basado en RHEL)
sudo semanage port -l | grep ssh
sudo ausearch -m AVC -c sshd

# 6. Probar conectividad local
nc -zv localhost 2222
telnet localhost 2222

# 7. Verificar grupos de seguridad del proveedor de nube
# Revisar reglas de cortafuegos de AWS/GCP/Azure

# 8. Revisar registros
sudo journalctl -u sshd -n 100 --no-pager
sudo tail -100 /var/log/auth.log

SELinux Bloqueando SSH (Basado en RHEL)

Problema: Conexión rechazada debido a política SELinux.

Solución:

# Verificar denegaciones de SELinux
sudo ausearch -m AVC -c sshd -ts recent

# Agregar puerto a política SELinux
sudo semanage port -a -t ssh_port_t -p tcp 2222

# Generar política personalizada si es necesario
sudo ausearch -m AVC -c sshd | audit2allow -M ssh_custom
sudo semodule -i ssh_custom.pp

# Verificar que el puerto está permitido
sudo semanage port -l | grep ssh

# Verificar modo SELinux
getenforce

# Ver alertas detalladas de SELinux
sudo sealert -a /var/log/audit/audit.log

Bloqueado Después de Cerrar el Puerto 22

Problema: Cerró el puerto 22 demasiado pronto y ahora no puede conectarse.

Solución:

  1. Acceder vía consola (panel del proveedor de hosting):
# Conectar vía consola
# Verificar estado de SSH
sudo systemctl status sshd

# Editar configuración SSH para agregar puerto 22 de nuevo
sudo nano /etc/ssh/sshd_config

# Agregar:
Port 22
Port 2222

# Reiniciar SSH
sudo systemctl restart sshd

# Permitir puerto 22 en cortafuegos
sudo ufw allow 22/tcp
sudo firewall-cmd --add-port=22/tcp

# Probar conexión en puerto 22
  1. Prevención: Siempre usar configuración de puerto dual inicialmente

Cortafuegos No Permite Nuevo Puerto

Problema: El cortafuegos bloquea el nuevo puerto SSH a pesar de las reglas.

Solución:

# Solución de problemas UFW
sudo ufw status verbose
sudo ufw show added
sudo ufw reload

# Agregar regla si falta
sudo ufw allow 2222/tcp

# Verificar orden de reglas
sudo ufw status numbered

# Solución de problemas Firewalld
sudo firewall-cmd --state
sudo firewall-cmd --list-all
sudo firewall-cmd --reload

# Agregar puerto si falta
sudo firewall-cmd --permanent --add-port=2222/tcp
sudo firewall-cmd --reload

# Verificar iptables directamente
sudo iptables -L INPUT -n -v | grep 2222
sudo ip6tables -L INPUT -n -v | grep 2222

El Servicio SSH No Inicia

Problema: El servicio SSH falla al iniciar después del cambio de configuración.

Solución:

# Verificar errores de configuración
sudo sshd -t

# Ver mensajes de error detallados
sudo systemctl status sshd -l
sudo journalctl -u sshd -n 50 --no-pager

# Problemas comunes:
# - Error de sintaxis en sshd_config
# - Puerto ya en uso
# - Problemas de permisos

# Verificar si el puerto ya está en uso
sudo ss -tlnp | grep :2222
sudo fuser 2222/tcp

# Matar proceso usando puerto
sudo fuser -k 2222/tcp

# Restaurar respaldo si es necesario
sudo cp /etc/ssh/sshd_config.backup.* /etc/ssh/sshd_config
sudo systemctl restart sshd

La Conexión se Cae Inmediatamente

Problema: La conexión se establece pero se cae inmediatamente.

Solución:

# Conectar con salida verbose
ssh -vvv -p 2222 username@ip_de_tu_servidor

# Verificar problemas de autenticación
sudo tail -f /var/log/auth.log

# Verificar permisos de usuario
id username
sudo grep username /etc/passwd

# Verificar permisos de clave SSH
ls -la ~/.ssh/
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

# Verificar contextos SELinux (basado en RHEL)
ls -Z ~/.ssh/
restorecon -Rv ~/.ssh

Mejores Prácticas

Recomendaciones de Seguridad

  1. Usar puertos de numeración alta (49152-65535) para evitar escaneos comunes

  2. Combinar con otras medidas de seguridad:

    • Autenticación con clave SSH (deshabilitar contraseñas)
    • Fail2ban para prevención de intrusiones
    • Reglas de cortafuegos limitando acceso por IP
    • Autenticación de dos factores (2FA)
    • Auditorías de seguridad regulares

  3. Monitorear registros de autenticación:

# Crear alias de monitoreo
echo "alias ssh-logs='sudo tail -f /var/log/auth.log | grep sshd'" >> ~/.bashrc
source ~/.bashrc

# Ejecutar monitoreo
ssh-logs
  1. Documentar cambios de puerto:
# Crear archivo de documentación
cat > /root/ssh-port-info.txt << EOF
Configuración de Puerto SSH
Fecha de Cambio: $(date)
Nuevo Puerto: 2222
Cambiado Por: $(whoami)
Razón: Endurecimiento de seguridad - reducir ataques automatizados
Cortafuegos Actualizado: Sí
SELinux Actualizado: Sí (basado en RHEL)
Configuraciones de Cliente Actualizadas: Sí
EOF
  1. Usar port knocking para seguridad adicional:
# Instalar knockd
sudo apt install knockd  # Ubuntu/Debian
sudo dnf install knockd  # CentOS/Rocky

# Configurar secuencia de knock
sudo nano /etc/knockd.conf

Mejores Prácticas Operativas

  1. Mantener acceso de puerto dual inicialmente (22 y puerto personalizado)
  2. Probar exhaustivamente antes de eliminar puerto 22
  3. Actualizar a todos los miembros del equipo antes de cerrar puerto antiguo
  4. Documentar en runbooks y procedimientos
  5. Actualizar sistemas de monitoreo para verificar nuevo puerto
  6. Configurar métodos de acceso de respaldo (consola, VPN)
  7. Programar cambio durante ventana de mantenimiento

Automatización y Monitoreo

# Crear script de monitoreo de puerto SSH
cat << 'EOF' | sudo tee /usr/local/bin/monitor-ssh-port.sh
#!/bin/bash

PORT=2222
LOG_FILE="/var/log/ssh-port-monitor.log"

if ! ss -tln | grep -q ":$PORT "; then
    echo "$(date): SSH no está escuchando en puerto $PORT" >> "$LOG_FILE"
    systemctl restart sshd
    echo "$(date): Servicio SSH reiniciado" >> "$LOG_FILE"
fi

# Verificar intentos fallidos excesivos
FAILED=$(grep "Failed password" /var/log/auth.log | grep "port $PORT" | tail -100 | wc -l)
if [ $FAILED -gt 50 ]; then
    echo "$(date): Alto número de intentos fallidos: $FAILED" >> "$LOG_FILE"
fi

EOF

sudo chmod +x /usr/local/bin/monitor-ssh-port.sh

# Agregar a crontab para monitoreo periódico
(crontab -l 2>/dev/null; echo "*/5 * * * * /usr/local/bin/monitor-ssh-port.sh") | crontab -

Gestión de Múltiples Servidores

Cuando gestionas múltiples servidores:

# Crear configuración SSH con puertos personalizados
cat >> ~/.ssh/config << EOF

Host servidor1
    HostName 192.0.2.10
    Port 2222
    User admin

Host servidor2
    HostName 192.0.2.11
    Port 50000
    User root

Host servidor3
    HostName 192.0.2.12
    Port 22022
    User deploy

# Coincidencia de patrón para todos los servidores
Host servidor*
    ServerAliveInterval 60
    ServerAliveCountMax 3
    IdentityFile ~/.ssh/id_ed25519

EOF

# Usar ansible para cambios masivos de puerto
# Crear playbook: change-ssh-port.yml

Revertir Cambios

Si necesitas revertir al puerto 22:

# Restaurar configuración de respaldo
sudo cp /etc/ssh/sshd_config.backup.* /etc/ssh/sshd_config

# O editar manualmente
sudo nano /etc/ssh/sshd_config
# Cambiar: Port 2222 → Port 22

# Probar y reiniciar
sudo sshd -t
sudo systemctl restart sshd

# Actualizar cortafuegos
sudo ufw allow 22/tcp
sudo firewall-cmd --add-service=ssh

# Eliminar puerto personalizado de SELinux (basado en RHEL)
sudo semanage port -d -t ssh_port_t -p tcp 2222

Conclusión

Cambiar el puerto SSH por defecto del 22 a un puerto personalizado es una mejora de seguridad simple que reduce significativamente los ataques automatizados y mejora la postura de seguridad de tu servidor. Aunque no es una solución definitiva, es un componente efectivo de una estrategia de seguridad de defensa en profundidad.

Logros clave:

  • Puerto SSH cambiado exitosamente del 22 a puerto personalizado
  • Cortafuegos configurado para permitir nuevo puerto SSH
  • SELinux configurado (sistemas basados en RHEL)
  • Configuraciones SSH de cliente actualizadas
  • Conexión probada y verificada
  • Puerto antiguo cerrado después de transición exitosa

Recordatorios importantes:

  • Los cambios de puerto por sí solos no reemplazan el endurecimiento apropiado de SSH
  • Siempre mantén acceso a consola antes de hacer cambios
  • Prueba exhaustivamente antes de cerrar puerto 22
  • Documenta cambios para miembros del equipo y referencia futura
  • Monitorea registros para problemas después del cambio

Próximos pasos de seguridad:

  • Implementar autenticación con clave SSH (deshabilitar contraseñas)
  • Configurar Fail2Ban para prevención de intrusiones
  • Configurar autenticación de dos factores (2FA)
  • Implementar lista blanca de IP si es posible
  • Auditorías de seguridad regulares y monitoreo de registros

Siguiendo esta guía, has implementado una capa de seguridad importante que reducirá dramáticamente el ruido de ataques automatizados y hará tu servidor ligeramente más difícil de atacar.

Recursos Adicionales

Guías Relacionadas

  • Cómo Conectarse a Tu Servidor vía SSH
  • Configuración de Seguridad Inicial en Ubuntu/Debian
  • Configuración de Seguridad Inicial en CentOS/Rocky Linux
  • Configuración de Fail2Ban para Protección contra Fuerza Bruta
  • Gestión de Claves SSH: Generación y Mejores Prácticas
  • Configuración de Cortafuegos con firewalld (CentOS/Rocky)
  • Endurecimiento de Servidor Linux: Guía Completa