Analizar Puertos y Sesiones de Red con netstat en Linux

Introducción

En este laboratorio, aprenderá a utilizar el comando netstat para analizar la actividad de red en un sistema Linux. Explorará conceptos fundamentales como puertos de red, sockets y conexiones activas para obtener información sobre cómo los servicios se comunican a través de la red.

Comenzará listando todos los sockets activos y luego filtrará los resultados para centrarse en los puertos TCP y UDP en escucha, mapeándolos a sus servicios en ejecución. Para ver estos conceptos en acción, generará una nueva conexión navegando por un sitio web y luego usará netstat para identificar la sesión ESTABLISHED recién creada y su puerto efímero asociado.

Listar Todos los Sockets Activos y en Escucha con `netstat -a`

En este paso, comenzará a explorar la actividad de red de su sistema utilizando el comando netstat. Este comando es una herramienta fundamental para administradores de red y desarrolladores, ya que proporciona información sobre conexiones de red, tablas de enrutamiento y estadísticas de interfaces. Comenzaremos con la opción -a, que indica a netstat que muestre todos los sockets activos, incluidas tanto las conexiones a sistemas remotos como los puertos que están "escuchando" nuevas conexiones entrantes.

Primero, asegúrese de estar en su directorio de trabajo predeterminado. Todos los comandos en este laboratorio se ejecutarán desde la terminal.

Ahora, listemos todos los sockets. En su terminal, escriba el siguiente comando y presione Enter:

netstat -a

Verá una gran cantidad de salida. No se preocupe, la desglosaremos. La salida muestra todos los tipos de sockets, incluidos los sockets de dominio TCP, UDP y UNIX.

Examinemos la estructura de la salida. Debería parecerse a esto (los detalles exactos en su sistema variarán):

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN
tcp        0      0 localhost:6010          0.0.0.0:*               LISTEN
tcp        0     52 labex-vm:ssh            192.168.0.10:54321      ESTABLISHED
tcp6       0      0 [::]:http-alt           [::]:*                  LISTEN
udp        0      0 0.0.0.0:bootpc          0.0.0.0:*
...
Active UNIX domain sockets (servers and established)
Proto RefCnt Flags       Type       State         I-Node   Path
unix  2      [ ]         DGRAM                    23456    /run/systemd/notify
unix  2      [ ACC ]     STREAM     LISTENING     34567    /tmp/.X11-unix/X0
...

Aquí hay un desglose de las columnas más importantes para las conexiones de Internet:

Proto: El protocolo utilizado por el socket, como tcp (para TCPv4), tcp6 (para TCPv6) o udp.
Local Address: La dirección IP de su sistema y el número de puerto que está utilizando para esta conexión. El puerto es el número después de los dos puntos (:). Una dirección de 0.0.0.0 o [::] significa que el puerto está escuchando en todas las interfaces de red disponibles en su máquina.
Foreign Address: La dirección IP y el número de puerto del sistema remoto. Si el estado es LISTEN, esto será típicamente 0.0.0.0:* o [::]:*, lo que indica que está esperando una conexión desde cualquier dirección.
State: Esto es crucial para las conexiones TCP.
- LISTEN: La aplicación está esperando una conexión entrante en el puerto especificado de Local Address. Este es un estado del lado del servidor.
- ESTABLISHED: Una conexión está activa y los datos se pueden transferir entre las direcciones local y remota.
- Otros estados como TIME_WAIT o CLOSE_WAIT se relacionan con el proceso de cierre de una conexión TCP.

Tómese un momento para desplazarse por la salida e identificar cualquier entrada en el estado LISTEN. Estas representan servicios en su sistema que están listos para aceptar conexiones de red. Esta es una visión directa de la Capa de Transporte (Capa 4) en acción.

Filtrar Puertos TCP/UDP en Escucha con `sudo netstat -tulnp`

En el paso anterior, el comando netstat -a nos proporcionó una lista completa pero extensa de todos los sockets. Para hacer que esta información sea más útil, necesitamos filtrarla. En este paso, aprenderá a utilizar opciones específicas con netstat para mostrar solo los puertos TCP y UDP en escucha y, lo más importante, para identificar qué programas los están utilizando.

Para ver el nombre del programa asociado a un puerto, a menudo se necesitan privilegios administrativos, ya que el proceso puede ser propiedad del sistema u otro usuario. Es por eso que usamos el comando sudo. En el entorno LabEx, puede usar sudo sin contraseña.

Ejecutemos un comando netstat más enfocado. En su terminal, escriba lo siguiente:

sudo netstat -tulnp

Desglosemos estas opciones, ya que se combinan comúnmente:

t: Muestra conexiones TCP.
u: Muestra conexiones UDP.
l: Muestra solo sockets en lista (listening). Este es nuestro filtro principal para ver qué servicios están esperando conexiones.
n: Muestra direcciones numéricas. Esto evita que netstat intente resolver direcciones IP y números de puerto en nombres de host y nombres de servicio (por ejemplo, muestra 22 en lugar de ssh), lo que hace que el comando se ejecute mucho más rápido.
p: Muestra el ID de proceso (PID) y el nombre del programa al que pertenece el socket. Esto requiere sudo para ver todos los procesos.

Después de presionar Enter, su salida será mucho más corta e informativa. Se verá algo como esto:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve

Observe la nueva columna al final: PID/Program name. Esta es la información clave. Ahora puede mapear directamente un puerto en escucha a la aplicación exacta que lo abrió. Por ejemplo, en la salida anterior, puede ver que el puerto 22 (el puerto estándar para SSH) está siendo utilizado por el programa sshd con un ID de Proceso de 3422.

Este comando es extremadamente potente para los administradores de sistemas. Les permite verificar rápidamente qué servicios se están ejecutando y están expuestos a la red, lo cual es esencial tanto para la resolución de problemas como para la auditoría de seguridad.

Mapear Puertos en Escucha a Servicios en Ejecución

En este paso, solidificará su comprensión del vínculo entre las aplicaciones en ejecución y los puertos de red en escucha. Ha visto cómo listar los servicios existentes con netstat. Ahora, iniciará su propio servicio web simple y lo verá aparecer en la salida de netstat, demostrando esta relación en tiempo real.

Utilizaremos el módulo incorporado http.server de Python para lanzar rápidamente un servidor web. Esta es una herramienta conveniente para el desarrollo y las pruebas.

Primero, iniciemos el servidor web. Le indicaremos que escuche en el puerto 8080, un puerto alternativo común para servicios web. En su terminal, ejecute el siguiente comando. Tenga en cuenta que su terminal parecerá "colgarse" ya que ahora está ejecutando activamente el servidor.
```
python3 -m http.server 8080
```
Debería ver una salida que indica que el servidor se ha iniciado:
```
Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) ...
```
Esta terminal ahora está ocupada por el proceso del servidor web. Necesita una nueva terminal para ejecutar otros comandos. En el entorno LabEx, puede abrir una nueva pestaña de terminal haciendo clic en el icono "más" en la ventana de la terminal o utilizando el menú (File -> New Tab).
En su nueva pestaña de terminal, ejecute el comando netstat nuevamente para ver la lista de puertos en escucha.
```
sudo netstat -tulnp
```

Examine la salida cuidadosamente. Ahora verá una nueva entrada para el puerto 8080.

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      779/systemd-resolve
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      3422/sshd
tcp        0      0 0.0.0.0:8080            0.0.0.0:*               LISTEN      12345/python3
udp        0      0 127.0.0.53:53           0.0.0.0:*                           779/systemd-resolve
...

Como puede ver, el sistema ahora informa que el programa python3 (con un PID específico, como 12345) está en estado LISTEN en el puerto 8080. Ha lanzado con éxito un servicio y ha confirmado que está escuchando conexiones de red.

Ahora, detengamos el servicio. Vuelva a su primera pestaña de terminal (la que ejecuta el servidor Python) y presione Ctrl+C. Esto interrumpirá y terminará el proceso del servidor.
Regrese a la segunda pestaña de terminal y ejecute el comando netstat una última vez.
```
sudo netstat -tulnp
```
La línea del puerto 8080 habrá desaparecido, lo que demuestra que cuando una aplicación se termina, ya no escucha en el puerto.

Crear una Nueva Conexión Navegando por un Sitio Web

En este paso, cambiará su enfoque de los puertos de escucha del lado del servidor a las conexiones activas del lado del cliente. Hasta ahora, ha observado servicios esperando que otros se conecten a ellos. Ahora, iniciará una conexión desde su máquina a un servidor remoto y observará cómo se forma la conexión. Utilizaremos la herramienta de línea de comandos curl para simular la visita a un sitio web.

Para observar este evento fugaz, utilizaremos el comando watch, que ejecuta repetidamente otro comando, permitiéndonos ver los cambios en la salida de netstat en tiempo casi real.

Primero, configuremos nuestra ventana de monitoreo. En su terminal, ejecute el siguiente comando. Esto ejecutará netstat -antp cada dos segundos y mostrará los resultados, actualizando continuamente la pantalla.
```
watch netstat -antp
```
- a: Muestra todos los sockets.
- n: Muestra direcciones numéricas.
- t: Muestra solo conexiones TCP.
- p: Muestra el PID/Nombre del Programa.
Su terminal ahora se llenará con la salida de netstat, que se actualiza automáticamente. Mantenga esta terminal abierta y visible.
Ahora, necesita abrir una nueva pestaña de terminal para emitir el comando que creará la conexión. Haga clic en el icono "más" en la barra de pestañas de su terminal.
En la nueva pestaña de terminal, utilizará curl para obtener la página principal del sitio web de LabEx. El símbolo > redirige la salida HTML a /dev/null para que no sature su pantalla.
```
curl https://www.labex.io > /dev/null
```
Tan pronto como presione Enter, cambie rápidamente su vista de vuelta a su primera pestaña de terminal (la que ejecuta watch). Verá aparecer una nueva conexión durante unos segundos. Se verá algo como esto:
```
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
...
tcp        0      0 172.17.0.2:45678        104.21.5.141:443        ESTABLISHED 13579/curl
...
```
- Observe que el State (Estado) es ESTABLISHED (Establecido), lo que indica una conexión activa.
- La Foreign Address (Dirección Remota) muestra la dirección IP del servidor de labex.io y el puerto 443 (el estándar para HTTPS).
- La columna PID/Program name (PID/Nombre del Programa) identifica claramente curl como el programa que inició esta conexión.
- La Local Address (Dirección Local) utiliza un puerto aleatorio de alto número (como 45678 en el ejemplo). Este es un puerto efímero, que discutiremos en el próximo paso.
Una vez que el comando curl termine de descargar (lo cual es muy rápido), verá que el estado de la conexión cambia a TIME_WAIT o FIN_WAIT antes de desaparecer por completo de la lista.
Ahora puede detener el comando watch. Vaya a la primera pestaña de terminal y presione Ctrl+C. También puede cerrar la segunda pestaña de terminal.

Identificar una Sesión ESTABLISHED y Puertos Efímeros

En este paso final, consolidará su comprensión examinando una conexión activa y persistente. Esto le permitirá identificar claramente una "sesión" de red y ver cómo su sistema utiliza puertos temporales, o "efímeros", para la comunicación del lado del cliente.

Una conexión ESTABLISHED en la salida de netstat representa una sesión activa (Capa 5 del Modelo OSI), donde dos aplicaciones están listas para intercambiar datos. En el paso anterior, la sesión de curl fue muy breve. Para estudiar una sesión más fácilmente, crearemos una que permanezca abierta utilizando SSH.

Primero, definamos un concepto importante: puertos efímeros. Cuando su computadora (el cliente) se conecta a un servidor en un puerto conocido (como el puerto 22 para SSH o 443 para HTTPS), su sistema operativo debe asignar un puerto para su lado de la conversación. Selecciona un puerto temporal y no utilizado de un rango de números altos (típicamente por encima de 32768). Esto se llama puerto efímero. Este mecanismo permite que su única máquina tenga muchas conexiones separadas al mismo puerto del servidor, por ejemplo, tener varias pestañas del navegador abiertas al mismo sitio web.

Para crear una sesión estable y observable, hará SSH desde su máquina de laboratorio de vuelta a sí misma. En su terminal, ejecute el siguiente comando:
```
ssh localhost
```
La primera vez que haga esto, puede ver un mensaje sobre la autenticidad del host. Esto es normal.
```
The authenticity of host 'localhost (127.0.0.1)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?
```
Escriba yes y presione Enter para continuar.

Le mostrará un aviso para ingresar la contraseña. No necesita ingresar la contraseña, simplemente espere.
Abra una nueva pestaña de terminal haciendo clic en el icono "más". Necesitamos esta nueva terminal para ejecutar netstat sin perturbar nuestra sesión SSH activa.
En la nueva terminal, ejecute netstat nuevamente, pero esta vez, utilizaremos el comando grep para filtrar la salida y mostrar solo las líneas que contienen ESTABLISHED. Esto hace que sea mucho más fácil encontrar sesiones activas.
```
netstat -antp | grep ESTABLISHED
```
La salida mostrará todas las conexiones TCP activas actualmente. Puede ver una advertencia de que no todos los procesos pudieron ser identificados, lo cual es esperado ya que no estamos usando sudo. Debería ver su conexión SSH original al entorno de laboratorio y la nueva que acaba de crear a localhost.
```
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 172.16.50.192:22        47.251.66.143:36882     ESTABLISHED -
tcp        0      0 127.0.0.1:46280         127.0.0.1:22            ESTABLISHED 5449/ssh
tcp        0      0 127.0.0.1:22            127.0.0.1:46280         ESTABLISHED -
```
Analicemos la nueva conexión de localhost, identificada por la dirección 127.0.0.1:
- El lado del servidor de la conexión es 127.0.0.1:22, que es el servidor SSH (sshd) escuchando en el puerto 22. Tiene una conexión establecida desde 127.0.0.1:46280. La información del programa es - porque el proceso sshd es propiedad del usuario root, y no usamos sudo.
- El lado del cliente es 127.0.0.1:46280 conectado a 127.0.0.1:22. El programa está claramente identificado como 5449/ssh.
- El puerto 46280 es el puerto efímero. Su sistema lo eligió aleatoriamente para el extremo cliente de esta sesión SSH específica. Si abriera otra conexión ssh localhost, usaría un puerto efímero diferente.
Para finalizar, cierre la sesión. Vuelva a la pestaña de terminal donde ejecutó ssh localhost y escriba exit, luego presione Enter.
```
exit
```
Esto terminará la conexión. Si ejecuta netstat -antp | grep ESTABLISHED nuevamente en la otra terminal, verá que la sesión de localhost ha desaparecido.

Resumen

En este laboratorio, aprendió a utilizar el comando netstat para analizar la actividad de red en un sistema Linux. Comenzó utilizando netstat -a para listar todos los sockets activos y en escucha, incluyendo sockets TCP, UDP y de dominio UNIX. Luego refinó esta salida aplicando indicadores como -t, -u, -l, -n y -p para filtrar específicamente los puertos TCP y UDP en escucha, mostrar direcciones numéricas e identificar el ID del proceso y el nombre asociado con cada puerto.

Basándose en esto, practicó la interpretación de la salida del comando para mapear los puertos en escucha a sus servicios correspondientes. Para observar una conexión en acción, inició una nueva sesión de red conectándose a un sitio web. Esto le permitió identificar una conexión en estado ESTABLISHED y comprender el papel de los puertos efímeros, que son puertos temporales asignados al lado del cliente de una comunicación de red.