Cómo verificar si un socket de red específico está abierto en Linux

Introducción

En este laboratorio, aprenderá cómo verificar si un socket de red específico está abierto en Linux. Comprender cómo identificar e inspeccionar los sockets de red activos es una habilidad fundamental para la resolución de problemas y el monitoreo de redes.

A través de ejercicios prácticos, utilizará herramientas de línea de comandos poderosas como ss y netstat para enumerar y filtrar las conexiones de red. También explorará el sistema de archivos /proc/net para obtener una comprensión más profunda de los detalles de los sockets, lo que proporciona un enfoque integral para verificar el estado de los sockets de red en su sistema.

Skills Graph

Verificar sockets con ss -tuln

En este paso, aprenderá cómo utilizar el comando ss para inspeccionar los sockets de red en su sistema Linux. Los sockets son puntos finales para enviar y recibir datos a través de una red. Comprender cómo ver los sockets activos es crucial para la resolución de problemas y el monitoreo de redes.

El comando ss es una herramienta poderosa para examinar los sockets. Lo utilizaremos con las siguientes opciones:

• -t: Muestra los sockets TCP.
• -u: Muestra los sockets UDP.
• -l: Muestra los sockets en escucha (sockets esperando conexiones).
• -n: No resuelve los nombres de servicio (muestra números de puerto en su lugar).

Abra su terminal si no está abierta. Puede encontrar el icono de Xfce Terminal en el lado izquierdo de su escritorio.

Ahora, escriba el siguiente comando y presione Enter:

ss -tuln

Verá una salida similar a esta:

Netid State      Recv-Q Send-Q Local Address:Port               Peer Address:Port
tcp   LISTEN     0      128    0.0.0.0:22                       0.0.0.0:*
tcp   LISTEN     0      128    127.0.0.1:631                    0.0.0.0:*
tcp   LISTEN     0      128    0.0.0.0:5900                     0.0.0.0:*
tcp   LISTEN     0      128    127.0.0.1:25                     0.0.0.0:*
tcp   LISTEN     0      128    [::]:22                          [::]:*
tcp   LISTEN     0      128    [::1]:631                        [::]:*
tcp   LISTEN     0      128    [::]:5900                        [::]:*
tcp   LISTEN     0      128    [::1]:25                         [::]:*
udp   UNCONN     0      0      127.0.0.1:323                    0.0.0.0:*
udp   UNCONN     0      0      0.0.0.0:631                      0.0.0.0:*
udp   UNCONN     0      0      [::1]:323                        [::]:*
udp   UNCONN     0      0      [::]:631                         [::]:*

Analicemos la salida:

• Netid: El tipo de socket (por ejemplo, tcp, udp).
• State: El estado del socket (por ejemplo, LISTEN significa que está esperando una conexión).
• Recv-Q: El número de bytes recibidos en la cola.
• Send-Q: El número de bytes enviados en la cola.
• Local Address:Port: La dirección IP local y el número de puerto a los que está enlazado el socket. 0.0.0.0 y [::] indican que el socket está escuchando en todas las interfaces de red disponibles (IPv4 e IPv6 respectivamente).
• Peer Address:Port: La dirección IP remota y el número de puerto a los que está conectado el socket. * indica que el socket está escuchando conexiones desde cualquier dirección remota.

Esta salida le muestra qué servicios están en ejecución y escuchando conexiones en su sistema. Por ejemplo, puede ver que SSH (puerto 22), CUPS (puerto 631), VNC (puerto 5900) y el servidor de correo (puerto 25) están en escucha.

Comprender esta salida es el primer paso para diagnosticar problemas de conectividad de red o identificar servicios potencialmente no deseados que se ejecutan en su sistema.

Haga clic en Continuar para pasar al siguiente paso.

Verificar sockets con netstat -tuln

En este paso, utilizará otro comando, netstat, para verificar los sockets de red. netstat es un comando más antiguo en comparación con ss, pero todavía se utiliza ampliamente y proporciona información similar sobre las conexiones de red, las tablas de enrutamiento y las estadísticas de interfaz.

Utilizaremos netstat con las mismas opciones que ss para ver los sockets TCP y UDP en escucha sin resolver los nombres de servicio:

• -t: Muestra los sockets TCP.
• -u: Muestra los sockets UDP.
• -l: Muestra los sockets en escucha.
• -n: No resuelve los nombres de servicio.

Escriba el siguiente comando en su terminal y presione Enter:

netstat -tuln

Verá una salida similar a esta:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
tcp        0      0 127.0.0.1:631           0.0.0.0:*               LISTEN
tcp        0      0 0.0.0.0:5900            0.0.0.0:*               LISTEN
tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN
tcp6       0      0 :::22                   :::*                    LISTEN
tcp6       0      0 ::1:631                 :::*                    LISTEN
tcp6       0      0 :::5900                 :::*                    LISTEN
tcp6       0      0 ::1:25                  :::*                    LISTEN
udp        0      0 127.0.0.1:323           0.0.0.0:*
udp        0      0 0.0.0.0:631             0.0.0.0:*
udp6       0      0 ::1:323                 :::*
udp6       0      0 :::631                  :::*

Note que la salida de netstat -tuln es muy similar a la salida de ss -tuln. Ambos comandos proporcionan información sobre el protocolo (Proto), la dirección y el puerto locales (Local Address), la dirección y el puerto remotos (Foreign Address) y el estado de la conexión (State).

Si bien ss generalmente se considera más rápido y más informativo para escenarios complejos, netstat sigue siendo una herramienta valiosa para tener en su arsenal de comandos de Linux. Es una buena práctica estar familiarizado con ambos.

Ahora ha utilizado con éxito tanto ss como netstat para ver los sockets en escucha. Esta es una habilidad fundamental para entender la actividad de red en su sistema.

Haga clic en Continuar para pasar al siguiente paso.

Inspeccionar detalles de sockets en /proc/net

En este paso, explorará el directorio /proc/net, que proporciona información detallada sobre la pila de red y los protocolos de red en el kernel de Linux. Aquí es donde comandos como ss y netstat obtienen sus datos.

El sistema de archivos /proc es un sistema de archivos virtual que proporciona información sobre procesos y otra información del sistema. Es una forma poderosa de inspeccionar el estado interno del kernel.

Dentro de /proc/net, encontrará archivos que contienen datos en bruto sobre las conexiones de red. Por ejemplo, tcp, udp, tcp6 y udp6 contienen información sobre los sockets TCP y UDP activos (IPv4 e IPv6 respectivamente).

Veamos el contenido del archivo tcp. Escriba el siguiente comando en su terminal y presione Enter:

cat /proc/net/tcp

Verá una salida que se parece a esto:

sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode ref pointer drops
   0: 0100007F:0019 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 12345 1 0000000000000000 0
   1: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 67890 1 0000000000000000 0
   ... (more lines)

Esta salida es menos legible para humanos que ss o netstat porque son datos en bruto del kernel. Cada línea representa un socket TCP y contiene varios campos, incluyendo:

• sl: El índice de la lista de sockets.
• local_address: La dirección IP local y el puerto en formato hexadecimal. 0100007F es la representación hexadecimal de 127.0.0.1 (dirección de bucle interno), y 0019 es la representación hexadecimal del puerto 25.
• rem_address: La dirección IP remota y el puerto en formato hexadecimal.
• st: El estado del socket (por ejemplo, 0A representa LISTEN).
• tx_queue: El tamaño de la cola de transmisión.
• rx_queue: El tamaño de la cola de recepción.
• uid: El ID de usuario que posee el socket.
• inode: El número de inodo del socket.

También puede ver los sockets UDP mirando el archivo /proc/net/udp:

cat /proc/net/udp

Y para los sockets IPv6, puede verificar /proc/net/tcp6 y /proc/net/udp6.

Si bien normalmente no analizará estos archivos directamente en el uso diario, comprender que aquí es donde se origina la información de red proporciona una comprensión más profunda de cómo Linux gestiona las conexiones de red. Comandos como ss y netstat esencialmente leen y formatean los datos de estos archivos para facilitar la comprensión.

Ahora ha explorado la información de sockets en bruto disponible en el sistema de archivos /proc/net.

Haga clic en Continuar para completar el laboratorio.

Resumen

En este laboratorio, aprendiste cómo verificar si un socket de red específico está abierto en Linux utilizando varias herramientas de línea de comandos. Comenzaste utilizando el comando ss con las opciones -tuln para mostrar los sockets TCP y UDP en escucha, y comprendiste las columnas de salida como Netid, State, Local Address:Port y Peer Address:Port.

Después de usar ss, normalmente verificarías la información del socket utilizando el comando netstat, que proporciona estadísticas de red similares. Finalmente, exploraste cómo inspeccionar información detallada del socket directamente desde el sistema de archivos /proc/net, que ofrece una vista de nivel inferior de la pila de red. Estos pasos proporcionan un enfoque integral para identificar y examinar los sockets de red abiertos en un sistema Linux.