Cómo Abrir un Puerto en Linux

Introducción

A port is a communication endpoint. Within an operating system, a port is opened or closed to data packets for specific processes or network services.

Normalmente, los puertos identifican un servicio de red específico asignado a ellos. Esto puede cambiarse configurando manualmente el servicio para usar un puerto diferente, pero en general, se pueden usar los valores predeterminados.

Los primeros 1024 puertos (números de puerto 0 a 1023) se conocen como números de puerto bien conocidos y están reservados para los servicios más comúnmente utilizados. Estos incluyen SSH (puerto 22), HTTP (puerto 80), HTTPS (puerto 443).

Los números de puerto por encima de 1024 se conocen como puertos efímeros.

• Los números de puerto 1024 a 49151 se llaman puertos registrados/usuario.
• Los números de puerto 49152 a 65535 se llaman puertos dinámicos/privados.

En este tutorial, abrirás un puerto efímero en Linux, ya que los servicios más comunes utilizan los puertos bien conocidos.

Requisitos previos

Para completar este tutorial, necesitarás:

• Familiaridad con el uso de la terminal.

Listar Todos los Puertos Abiertos

Antes de abrir un puerto en Linux, debes verificar la lista de todos los puertos abiertos y elegir un puerto efímero que no esté en esa lista.

Usa el comando netstat para listar todos los puertos abiertos, incluyendo TCP y UDP, que son los protocolos más comunes para la transmisión de paquetes en la capa de red.

netstat -lntu

Esto imprimirá:

• todos los sockets escuchando (-l)
• el número de puerto (-n)
• Puertos TCP (-t)
• Puertos UDP (-u)

Output
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address    Foreign Address  State
tcp        0      0 127.0.0.1:5432   0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.1:27017  0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.1:6379   0.0.0.0:*        LISTEN
tcp        0      0 127.0.0.53:53    0.0.0.0:*        LISTEN
tcp        0      0 0.0.0.0:22       0.0.0.0:*        LISTEN
tcp6       0      0 ::1:5432         :::*             LISTEN
tcp6       0      0 ::1:6379         :::*             LISTEN
tcp6       0      0 :::22            :::*             LISTEN
udp        0      0 127.0.0.53:53    0.0.0.0:*        LISTEN

Verifica que estás recibiendo salidas consistentes usando el comando ss para listar los sockets escuchando con un puerto abierto:

ss -lntu

Esto imprimirá:

Output
Netid  State   Recv-Q  Send-Q    Local Address:Port   Peer Address:Port
udp    UNCONN  0       0         127.0.0.53%lo:53          0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:5432        0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:27017       0.0.0.0:*
tcp    LISTEN  0       128           127.0.0.1:6379        0.0.0.0:*
tcp    LISTEN  0       128       127.0.0.53%lo:53          0.0.0.0:*
tcp    LISTEN  0       128             0.0.0.0:22          0.0.0.0:*
tcp    LISTEN  0       128               [::1]:5432        0.0.0.0:*
tcp    LISTEN  0       128               [::1]:6379        0.0.0.0:*
tcp    LISTEN  0       128                [::]:22          0.0.0.0:*

Esto da más o menos los mismos puertos abiertos que netstat.

Abrir un puerto en Linux para permitir conexiones TCP

Ahora, abre un puerto cerrado y haz que escuche conexiones TCP.

Para los fines de este tutorial, estarás abriendo el puerto 4000. Sin embargo, si ese puerto no está abierto en tu sistema, siéntete libre de elegir otro puerto cerrado. Solo asegúrate de que sea mayor que 1023.

Asegúrate de que el puerto 4000 no esté en uso utilizando el comando netstat:

netstat -na | grep :4000

O el comando ss:

ss -na | grep :4000

La salida debe permanecer en blanco, verificando así que no se está utilizando actualmente, para que puedas agregar manualmente las reglas del puerto al firewall iptables del sistema.

Para Usuarios de Ubuntu y Sistemas basados en ufw

Usa ufw – el cliente de línea de comandos para el Firewall Sencillo.

Tus comandos serán similares a:

sudo ufw allow 4000

Consulta Cómo Configurar un Firewall ufw para tu distribución.

Para sistemas CentOS y basados en firewalld

Usa firewall-cmd – el cliente de línea de comandos para el demonio firewalld.

tus comandos se parecerán a:

firewall-cmd --add-port=4000/tcp

Consulta Cómo Configurar firewalld para tu distribución.

Para Otras Distribuciones Linux

Usa iptables para cambiar las reglas del filtro de paquetes IPv4 del sistema.

iptables -A INPUT -p tcp --dport 4000 -j ACCEPT

Consulta Cómo Configurar Un Firewall Usando iptables para tu distribución.

Prueba el puerto recién abierto para conexiones TCP

Ahora que ha abierto con éxito un nuevo puerto TCP, es hora de probarlo.

Primero, inicie netcat (nc) y escuche (-l) en el puerto (-p) 4000, mientras envía la salida de ls a cualquier cliente conectado:

ls | nc -l -p 4000

Ahora, después de que un cliente haya abierto una conexión TCP en el puerto 4000, recibirá la salida de ls. Deje esta sesión por ahora.

Abra otra sesión de terminal en la misma máquina.

Dado que abrió un puerto TCP, use telnet para verificar la conectividad TCP. Si el comando no existe, instálelo usando su gestor de paquetes.

Ingrese la IP de su servidor y el número de puerto (4000 en este ejemplo) y ejecute este comando:

telnet localhost 4000

Este comando intenta abrir una conexión TCP en localhost en el puerto 4000.

Obtendrá una salida similar a esta, que indica que se ha establecido una conexión con el programa de escucha (nc):

Output
Trying ::1...
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
while.sh

La salida de ls (while.sh, en este ejemplo) también se ha enviado al cliente, lo que indica una conexión TCP exitosa.

Utiliza nmap para verificar si el puerto (-p) está abierto:

nmap localhost -p 4000

Este comando verificará el puerto abierto:

Output
Starting Nmap 7.60 ( https://nmap.org ) at 2020-01-18 21:51 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00010s latency).
Other addresses for localhost (not scanned): ::1

PORT     STATE SERVICE
4000/tcp open  remoteanything

Nmap done: 1 IP address (1 host up) scanned in 0.25 seconds

El puerto ha sido abierto. Has abierto con éxito un nuevo puerto en tu sistema Linux.

Pero esto es solo temporal, ya que los cambios se restablecerán cada vez que reinicies el sistema.

Reglas Persistentes

El enfoque presentado en este artículo solo actualizará temporalmente las reglas del firewall hasta que el sistema se apague o se reinicie. Por lo tanto, deben repetirse pasos similares para abrir el mismo puerto nuevamente después de un reinicio.

Para Firewall ufw

ufw las reglas no se reinician al reiniciar. Esto se debe a que está integrado en el proceso de arranque, y el kernel guarda las reglas del cortafuegos utilizando ufw aplicando archivos de configuración apropiados.

Para firewalld

Necesitarás aplicar la bandera --permanent.

Consulta Cómo Configurar firewalld para tu distribución.

Para iptables

Deberás guardar las reglas de configuración. Estos tutoriales recomiendan iptables-persistent.

Consulta Cómo Configurar un Cortafuegos con iptables para tu distribución.

Conclusión

En este tutorial, aprendiste cómo abrir un nuevo puerto en Linux y configurarlo para conexiones entrantes. También utilizaste netstat, ss, telnet, nc y nmap.

Continúa tu aprendizaje con Cómo funciona el Firewall Iptables, Un Análisis Profundo de la Arquitectura de Iptables y Netfilter, Comprendiendo los Sockets y Cómo Utilizar Herramientas como Top, Netstat, Du y Otras para Monitorizar Recursos del Servidor.