---
title: "Capa de transporte: TCP, UDP y puertos"
domain: networking
level: beginner
duration: "50 min"
objectives:
  - Explicar la función de la capa de transporte y cómo los puertos identifican procesos (puertos conocidos, registrados y efímeros).
  - Comparar TCP y UDP (conexiones, fiabilidad, orden, sobrecarga) y elegir uno para una aplicación concreta.
  - Describir el acuerdo de tres vías de TCP, el cierre de la conexión, los números de secuencia y de confirmación, la retransmisión y el control de flujo.
  - Identificar sockets en escucha y estados de conexión (LISTEN, ESTABLISHED, TIME_WAIT) con `ss` o `netstat`.
  - Diagnosticar «connection refused» frente a «connection timed out».
lang: es
source_hash: 6d1886187aec
---

# Capa de transporte: TCP, UDP y puertos

## Por qué importa
Despliegas una pequeña aplicación web en un servidor y la pruebas desde tu portátil. El navegador dice *connection refused* (conexión rechazada). Un compañero lo prueba un minuto después desde casa y obtiene *connection timed out* (tiempo de espera agotado). Los dos mensajes significan «no funciona», pero apuntan a problemas completamente distintos. El primero dice que el servidor respondió: «aquí no escucha nadie». El segundo dice que no respondió nada, así que los paquetes se descartaron en algún punto del camino. Si sabes distinguirlos, sabes si mirar la aplicación o el cortafuegos.

El mismo conocimiento explica enigmas cotidianos. ¿Por qué una videollamada sigue adelante con una mala conexión Wi-Fi mientras una descarga se atasca? ¿Por qué un servidor ocupado muestra miles de conexiones en un estado llamado `TIME_WAIT`? ¿Por qué un mismo servidor puede ejecutar un servidor web y un servidor Secure Shell (SSH) en la misma dirección del Internet Protocol (IP)? Todas las respuestas están en la capa de transporte, el hogar del Transmission Control Protocol (TCP) y del User Datagram Protocol (UDP), y el tema de esta lección.

## Objetivos de aprendizaje
- Explicar la función de la capa de transporte y cómo los puertos identifican procesos (puertos conocidos, registrados y efímeros).
- Comparar TCP y UDP (conexiones, fiabilidad, orden, sobrecarga) y elegir uno para una aplicación concreta.
- Describir el acuerdo de tres vías de TCP, el cierre de la conexión, los números de secuencia y de confirmación, la retransmisión y el control de flujo.
- Identificar sockets en escucha y estados de conexión (LISTEN, ESTABLISHED, TIME_WAIT) con `ss` o `netstat`.
- Diagnosticar «connection refused» frente a «connection timed out».

## Conceptos clave

### Puertos: del equipo al proceso
Una dirección IP lleva un paquete al edificio correcto. No dice a qué piso. Un servidor en `203.0.113.80` puede ejecutar a la vez un servidor web, un servidor SSH y una base de datos, y tu portátil puede tener veinte pestañas del navegador abiertas. Algo tiene que decidir a qué programa pertenece cada paquete.

Esa es la tarea de la **capa de transporte** (capa 4 del [modelo OSI](../04-osi-model/lesson.es.md)). Transporta datos entre *procesos*, no solo entre equipos. Para ello etiqueta cada mensaje con dos números de **puerto**: uno de origen y otro de destino. Un puerto es un número de 16 bits, de 0 a 65535. Un programa que quiere recibir tráfico pide un puerto al sistema operativo; a partir de ese momento, el sistema operativo le entrega todo lo que llega a ese puerto. Repartir los datos entrantes según el puerto se llama **demultiplexación**; mezclar los datos de muchos programas en una sola dirección IP es **multiplexación**.

La RFC 6335 divide los números de puerto en tres rangos, y la Internet Assigned Numbers Authority (IANA) mantiene el registro:

| Rango | Nombre en la RFC 6335 | También llamados | Se usan para |
|---|---|---|---|
| 0–1023 | Puertos del sistema | **Puertos conocidos** (well-known) | Servicios estándar: 22 SSH, 53 Domain Name System (DNS), 443 HTTP Secure (HTTPS) |
| 1024–49151 | Puertos de usuario | **Puertos registrados** | Servicios registrados en la IANA: 3389 Remote Desktop Protocol (RDP), 5432 PostgreSQL |
| 49152–65535 | Puertos dinámicos y/o privados | **Puertos efímeros** | Puertos de origen temporales de los clientes, nunca asignados a un servicio |

Un servidor escucha en un puerto fijo y conocido para que los clientes sepan dónde encontrarlo. A un cliente le da igual qué puerto usa, así que el sistema operativo le asigna un **puerto efímero** libre cada vez que abre una conexión.

> [!NOTE]
> No todos los sistemas operativos siguen el rango dinámico de la RFC 6335. Windows (desde Vista) y macOS usan por defecto 49152–65535, pero Linux usa 32768–60999. Comprueba el tuyo con `cat /proc/sys/net/ipv4/ip_local_port_range` en Linux, `sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last` en macOS o `netsh int ipv4 show dynamicport tcp` en Windows. Esto importa cuando escribes reglas de cortafuegos para el tráfico de vuelta.

El extremo de un programa, una dirección IP más un puerto más un protocolo, se llama **socket**. Una conexión se identifica por su **4-tupla**: dirección IP de origen, puerto de origen, dirección IP de destino y puerto de destino. Si añades el protocolo, obtienes la **5-tupla** que siguen los cortafuegos y los dispositivos de Network Address Translation (NAT). Como el puerto del cliente es distinto, dos pestañas del navegador pueden hablar con el mismo puerto del servidor a la vez sin mezclar sus datos:

![Un cliente en 192.0.2.10 ejecuta la pestaña 1 del navegador en el puerto efímero 50514, la pestaña 2 en el 50515 y un cliente SSH en el 50600. Un servidor en 203.0.113.80 escucha en el puerto 443 (servidor web) y en el puerto 22 (servidor SSH). Las dos pestañas se conectan al 443 y el cliente SSH al 22. Las tres conexiones TCP son 192.0.2.10:50514 a 203.0.113.80:443, 192.0.2.10:50515 a 203.0.113.80:443 y 192.0.2.10:50600 a 203.0.113.80:22](../../../assets/diagrams/tcp-ports-sockets.es.svg)

*Figura 1. Dos conexiones comparten el destino `203.0.113.80:443`. Siguen siendo distintas, porque sus 4-tuplas difieren en el puerto de origen.*

Algunos puertos con los que te cruzarás constantemente:

| Puerto | Protocolo | Servicio |
|---|---|---|
| 22 | TCP | Secure Shell (SSH) |
| 25 | TCP | Simple Mail Transfer Protocol (SMTP), de servidor a servidor |
| 53 | UDP y TCP | DNS |
| 67 / 68 | UDP | Dynamic Host Configuration Protocol (DHCP), servidor / cliente |
| 80 | TCP | Hypertext Transfer Protocol (HTTP) |
| 123 | UDP | Network Time Protocol (NTP) |
| 443 | TCP, y UDP para HTTP/3 | HTTPS |
| 3389 | TCP y UDP | Remote Desktop Protocol (RDP) |

TCP y UDP tienen espacios de puertos separados. El puerto TCP 53 y el puerto UDP 53 son dos sockets distintos, y un programa puede escuchar en uno sin el otro.

> [!CHECK]
> Tu portátil abre dos conexiones a `https://www.example.com` a la vez. Ambas van a `203.0.113.80:443`. ¿Cómo mantiene el servidor separados sus datos?
>
> - [ ] Cada conexión usa un puerto de destino distinto en el servidor
> - [x] El portátil usa un puerto de origen efímero distinto para cada una, así que las dos 4-tuplas difieren
> - [ ] El servidor solo puede atender una conexión por dirección IP de cliente a la vez
> - [ ] El navegador añade un número de conexión a la cabecera IP
>
> El puerto del servidor sigue siendo el 443 en ambas. El sistema operativo da a cada conexión su propio puerto de origen efímero, y la 4-tupla (IP de origen, puerto de origen, IP de destino, puerto de destino) identifica cada conexión de forma única.

### TCP y UDP comparados
Internet tiene dos protocolos de transporte de uso cotidiano. Hacen concesiones opuestas.

El **User Datagram Protocol (UDP)** (RFC 768) es la opción mínima. Añade una cabecera de 8 bytes (puerto de origen, puerto de destino, longitud y una suma de comprobación) y envía el mensaje. Cada mensaje es un **datagrama**: llega entero o no llega. UDP es **sin conexión**: no hay establecimiento, ni confirmación ni retransmisión. Si un datagrama se pierde, se duplica o lo adelanta otro posterior, UDP no se entera. La aplicación decide si eso importa.

El **Transmission Control Protocol (TCP)** (RFC 9293) hace mucho más. Está **orientado a conexión**: ambos extremos acuerdan hablar antes de que fluya ningún dato. Después entrega un **flujo de bytes** fiable y ordenado: cada byte se numera, se confirma y se reenvía si se pierde, y el programa receptor lee los bytes en el orden en que se enviaron. TCP también reduce el ritmo cuando el receptor o la red no pueden seguirlo. Su unidad de datos es el **segmento**, con una cabecera de 20 a 60 bytes.

![Comparación. Antes de enviar: TCP hace un acuerdo de tres vías; UDP envía directamente. Entrega: TCP confirma los datos y reenvía las pérdidas; UDP es de mejor esfuerzo, sin ACK. Orden: TCP es un flujo de bytes ordenado; UDP envía datagramas separados. Control de flujo y congestión: integrado en TCP; ninguno en UDP, es cosa de la aplicación. Tamaño de cabecera: TCP de 20 a 60 bytes, UDP 8 bytes. Usos típicos de TCP: HTTPS 443, SSH 22, SMTP 25, IMAPS 993. Usos típicos de UDP: DNS 53, DHCP 67/68, NTP 123, QUIC 443](../../../assets/diagrams/tcp-vs-udp.es.svg)

*Figura 2. TCP compra fiabilidad y orden con un acuerdo inicial, confirmaciones y una cabecera mayor. UDP da velocidad y sencillez y deja el resto a la aplicación.*

Elegir entre ambos es cuestión de qué duele más: esperar o perder datos.

| Aplicación | Elección habitual | Por qué |
|---|---|---|
| Páginas web, interfaces de programación de aplicaciones (API), transferencia de archivos, correo, SSH | TCP | Cada byte debe llegar, en orden. Un pequeño retraso es aceptable. |
| Consultas DNS | UDP (TCP para respuestas grandes y transferencias de zona) | Una pregunta pequeña, una respuesta pequeña. Una consulta perdida simplemente se repite. La RFC 7766 exige que los servidores DNS admitan también TCP. |
| Llamadas de voz y vídeo, juegos en línea | UDP | Un paquete tardío no sirve de nada. Mejor saltárselo que parar todo mientras se reenvía. |
| DHCP | UDP | El cliente aún no tiene dirección IP y debe enviar por difusión (broadcast). TCP no puede: una conexión tiene exactamente dos extremos. |
| Vídeo en directo a muchos receptores (multicast) | UDP | Mismo motivo: TCP es solo uno a uno. |

UDP no es «poco fiable» en mal sentido. Es *sin opiniones*. **QUIC** (RFC 9000) es el mejor ejemplo: funciona sobre UDP y construye su propia fiabilidad, orden, control de congestión y cifrado integrado con Transport Layer Security (TLS) 1.3. HTTP/3 (RFC 9114) usa QUIC, por eso hoy HTTPS usa tanto el puerto TCP 443 como el puerto UDP 443.

> [!CHECK]
> Un equipo crea un juego multijugador. El servidor envía la posición de cada jugador 30 veces por segundo. ¿Qué transporte encaja mejor y por qué?
>
> - [ ] TCP, porque una actualización de posición perdida siempre debe reenviarse
> - [x] UDP, porque una posición antigua reenviada no sirve cuando ya existe una más reciente, y esperarla congelaría el juego
> - [ ] UDP, porque cifra los datos e impide las trampas
> - [ ] TCP, porque UDP no puede transportar más de un mensaje por segundo
>
> Cada actualización sustituye a la anterior, así que una retransmisión llega demasiado tarde para servir, y la entrega en orden de TCP retendría las actualizaciones más nuevas mientras espera. Ni TCP ni UDP cifran nada por sí mismos.

### La conexión TCP: establecimiento y cierre
Una conexión TCP empieza con el **acuerdo de tres vías** (three-way handshake). Piensa en una llamada de teléfono: «¿Me oyes?» «Sí, te oigo, ¿me oyes tú?» «Sí.» Solo entonces empieza la conversación.

El acuerdo usa indicadores (flags), bits sueltos de la cabecera TCP. El indicador **SYN** (synchronize) abre una conexión, el indicador **ACK** (acknowledgement, confirmación) dice que el número de confirmación es válido, el indicador **FIN** (finish) cierra un sentido y el indicador **RST** (reset) aborta una conexión al instante.

![Acuerdo TCP entre un cliente en 192.0.2.10:50514 (CLOSED) y un servidor en 203.0.113.80:443 (LISTEN). 1: el cliente envía SYN seq=1000 y pasa a SYN-SENT; el servidor pasa a SYN-RECEIVED. 2: el servidor envía SYN, ACK seq=5000 ack=1001; el cliente pasa a ESTABLISHED. 3: el cliente envía ACK ack=5001; el servidor pasa a ESTABLISHED. Después el cliente envía 100 bytes de datos en seq=1001, por ejemplo un TLS ClientHello, y el servidor responde ACK ack=1101](../../../assets/diagrams/tcp-handshake.es.svg)

*Figura 3. Tres mensajes abren la conexión. Cada extremo elige su propio número de secuencia inicial y el otro lo confirma sumándole uno.*

1. **SYN.** El cliente elige un **número de secuencia inicial (ISN, initial sequence number)**, aquí 1000, y envía un segmento con el indicador SYN. También anuncia opciones como su **Maximum Segment Size (MSS, tamaño máximo de segmento)**, el mayor fragmento de datos que puede recibir en un segmento.
2. **SYN, ACK.** El servidor elige su propio ISN (5000) y confirma el del cliente: `ack=1001` significa «he recibido tu SYN; el siguiente byte que espero de ti es el 1001». Un SYN cuenta como un byte del espacio de secuencia aunque no lleve datos.
3. **ACK.** El cliente confirma el SYN del servidor con `ack=5001`. Ambos extremos están ya **ESTABLISHED** y los datos pueden fluir en los dos sentidos.

Los ISN reales no son 1000 y 5000. Son números de 32 bits elegidos de forma impredecible (RFC 9293, siguiendo la RFC 6528), para que un atacante no pueda adivinarlos e inyectar segmentos falsos en una conexión.

El cierre es cosa de cuatro pasos, porque cada sentido se cierra por separado:

![Cierre TCP entre el cliente 192.0.2.10:50514 y el servidor 203.0.113.80:443, ambos en ESTABLISHED. 1: el cliente envía FIN seq=1101 y pasa a FIN-WAIT-1. 2: el servidor envía ACK ack=1102 y pasa a CLOSE-WAIT; el cliente pasa a FIN-WAIT-2. La aplicación del servidor termina y llama a close(). 3: el servidor envía FIN seq=5001 y pasa a LAST-ACK; el cliente pasa a TIME-WAIT. 4: el cliente envía ACK ack=5002; el servidor pasa a CLOSED. El cliente espera en TIME-WAIT 2 × MSL, 60 segundos en Linux, y luego pasa a CLOSED](../../../assets/diagrams/tcp-teardown.es.svg)

*Figura 4. Cada extremo envía su propio FIN. El que cierra primero acaba en TIME-WAIT; el otro termina en cuanto se confirma su FIN.*

- El extremo que cierra primero envía FIN: «no tengo nada más que enviar». El otro extremo lo confirma y pasa a **CLOSE-WAIT**: puede seguir enviando datos hasta que su aplicación llame a `close()`. Este estado unidireccional es un **cierre a medias** (half-close).
- Cuando el segundo extremo envía su FIN y se confirma, ese extremo pasa a CLOSED.
- El extremo que cerró primero espera en **TIME-WAIT** (`TIME_WAIT` en `netstat`) durante el doble del **Maximum Segment Lifetime (MSL, vida máxima del segmento)** antes de olvidar la conexión.

**Por qué existe TIME-WAIT.** Tiene dos funciones. Primero, si se pierde el último ACK, el otro extremo reenviará su FIN y alguien tiene que seguir ahí para confirmarlo de nuevo. Segundo, evita que los segmentos retrasados de la conexión antigua sean aceptados por una conexión nueva que reutilice por casualidad la misma 4-tupla. La RFC 9293 define el MSL como 2 minutos, lo que haría el TIME-WAIT de 4 minutos; Linux usa 60 segundos fijos. TIME-WAIT es normal y cuesta muy poca memoria. Un cliente o proxy ocupado que abre muchas conexiones cortas puede mostrar miles, y eso no es una fuga. Solo se convierte en problema cuando un cliente abre tantas conexiones a la *misma* dirección y puerto de servidor que se queda sin puertos efímeros. La solución es reutilizar conexiones (HTTP keep-alive, pools de conexiones), no desactivar TIME-WAIT.

Una conexión también puede terminar de golpe con RST: un programa se cae, un cortafuegos reinicia la conexión o llega un segmento para una conexión que no existe.

> [!CHECK]
> Después de que un cliente cierre una conexión TCP con un servidor web, `ss` en el cliente muestra la conexión en `TIME-WAIT` durante aproximadamente un minuto. ¿Qué te indica?
>
> - [ ] El servidor nunca respondió al FIN del cliente, así que la conexión está atascada
> - [ ] La aplicación cliente olvidó llamar a `close()`
> - [x] No pasa nada: el extremo que cierra primero espera ahí para poder reenviar un último ACK perdido y dejar que caduquen los segmentos antiguos
> - [ ] El cliente sigue enviando datos al servidor
>
> TIME-WAIT es el último estado normal de quien envía el primer FIN. Una aplicación que olvida llamar a `close()` aparece en cambio como CLOSE-WAIT, en su propio lado.

### Fiabilidad: números de secuencia, confirmaciones y ventanas
TCP numera bytes, no segmentos. El **número de secuencia** de cada segmento es el número de su primer byte de datos. El **número de confirmación** es el siguiente byte que espera el receptor, y es acumulativo: `ack=4001` significa «tengo todo hasta el byte 4000». En la Figura 3, el cliente envía 100 bytes a partir del 1001, así que el servidor responde `ack=1101`.

El emisor conserva cada byte hasta que se confirma. Si una confirmación no llega a tiempo, vence el **temporizador de retransmisión (RTO, retransmission timeout)** y el emisor reenvía. El temporizador se adapta al tiempo de ida y vuelta medido (RFC 6298). Hay también una señal más rápida: si el receptor recibe un segmento desordenado, repite su última confirmación. Tres de estos **ACK duplicados** seguidos indican al emisor que falta un segmento, y reenvía al instante sin esperar al temporizador. Es la **retransmisión rápida** (fast retransmit) (RFC 5681).

![El emisor 192.0.2.10 envía seq=1001, 1000 bytes; el receptor 203.0.113.80 responde ACK ack=2001 win=64000. El segmento seq=2001 se pierde en la red. El segmento seq=3001 llega y el receptor repite ACK ack=2001, un duplicado que significa que sigue faltando el byte 2001. Los ACK duplicados o el temporizador de retransmisión hacen que el emisor reenvíe seq=2001, y el receptor responde ACK ack=4001](../../../assets/diagrams/tcp-retransmission.es.svg)

*Figura 5. El receptor solo puede confirmar hasta el primer hueco. Cuando el hueco se rellena, un solo ACK cubre ambos segmentos.*

El TCP moderno también usa la **confirmación selectiva (SACK, Selective Acknowledgement)** (RFC 2018), de modo que el receptor puede indicar exactamente qué bloques ya tiene y el emisor reenvía solo lo que falta.

Dos mecanismos más impiden que TCP envíe demasiado deprisa:
- El **control de flujo** protege al *receptor*. Cada segmento lleva una **ventana de recepción** (`win`): cuántos bytes más puede almacenar el receptor ahora mismo. El emisor nunca tiene en tránsito más datos sin confirmar que esa cantidad. Si la ventana baja a 0, el emisor se detiene y espera. El escalado de ventana (RFC 7323) permite que la ventana supere los 64 KB en enlaces rápidos.
- El **control de congestión** protege a la *red*. El emisor mantiene su propia estimación, la ventana de congestión, y empieza pequeña (arranque lento, slow start), crece mientras vuelven confirmaciones y retrocede cuando ve pérdidas (RFC 5681). Linux usa por defecto el algoritmo CUBIC (RFC 9438); BBR, desarrollado por Google, es una alternativa común.

UDP no tiene nada de esto. Una aplicación sobre UDP que necesita fiabilidad o control de ritmo, como QUIC, tiene que construirlo.

> [!CHECK]
> Un receptor anuncia `win=0` en sus confirmaciones. ¿Qué hace el emisor?
>
> - [ ] Reenvía de inmediato todos los datos sin confirmar
> - [ ] Cierra la conexión con FIN
> - [x] Deja de enviar datos nuevos hasta que el receptor anuncie una ventana mayor que 0
> - [ ] Cambia la conexión a UDP
>
> Una ventana de recepción cero es control de flujo: la aplicación receptora no lee lo bastante deprisa y su búfer está lleno. El emisor hace una pausa y sondea periódicamente hasta que la ventana vuelve a abrirse.

### Sockets y sus estados
En cualquier equipo puedes listar los sockets que el sistema operativo tiene abiertos. En Linux la herramienta es `ss` (socket statistics); en macOS y Windows, `netstat`.

| Estado (como lo muestra `ss`) | Significado | Causa típica |
|---|---|---|
| `LISTEN` | Un socket de servidor esperando conexiones | Un servicio está en marcha y acepta conexiones en esa dirección y puerto |
| `SYN-SENT` | Una conexión en curso; aún sin respuesta | Muchos: el destino no responde (busca un timeout) |
| `SYN-RECV` | Llegó un SYN y se envió el SYN, ACK | Muchos: una red lenta o un SYN flood |
| `ESTAB` | Una conexión establecida | Tráfico normal |
| `CLOSE-WAIT` | El otro extremo cerró; nuestra aplicación aún no | Muchos: un fallo de la aplicación (nunca llama a `close()`) |
| `TIME-WAIT` | Cerramos primero y esperamos 2 × MSL | Normal; muchos en clientes y proxies ocupados |
| `UNCONN` | Un socket UDP (UDP no tiene conexiones) | Un servicio UDP como DNS o NTP |

`netstat` y la RFC escriben los estados de forma ligeramente distinta: `ESTABLISHED`, `TIME_WAIT`, `CLOSE_WAIT` y, en Windows, `LISTENING`. Significan lo mismo.

Un **socket en escucha** está enlazado a una dirección además de a un puerto, y esa dirección decide quién puede conectarse:
- `127.0.0.1:5432` (o `[::1]:5432`): solo programas de la misma máquina, a través de la interfaz de loopback.
- `0.0.0.0:22` (o `[::]:22`, o `*:22`): todas las direcciones IPv4 (o IPv6) del equipo, es decir, cualquiera que pueda llegar al equipo.
- `203.0.113.80:443`: solo las conexiones que llegan a esa única dirección.

Un servidor que «funciona en local pero no desde fuera» muy a menudo escucha solo en `127.0.0.1`.

Los comandos que más necesitarás:

| Tarea | Linux | macOS | Windows (PowerShell) |
|---|---|---|---|
| Sockets TCP y UDP en escucha, con el programa | `ss -tulpn` | `lsof -nP -iTCP -sTCP:LISTEN` y `lsof -nP -iUDP` | `netstat -ano` o `Get-NetTCPConnection -State Listen` |
| Todos los sockets TCP con su estado | `ss -tan` | `netstat -an -p tcp` | `netstat -an -p tcp` |

En `ss -tulpn`, las letras significan: `-t` TCP, `-u` UDP, `-l` solo sockets en escucha, `-p` mostrar el proceso, `-n` mostrar números en lugar de nombres de servicio. En Linux solo ves el proceso de los sockets de otros usuarios si lo ejecutas con `sudo`.

Para contar los sockets TCP por estado, lo que muestra enseguida una acumulación de TIME-WAIT o CLOSE-WAIT, en Linux:

```bash
ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c
```

En Windows (PowerShell), `Get-NetTCPConnection | Group-Object State` hace lo mismo.

> [!CHECK]
> `ss -tln` en un servidor muestra `LISTEN 0 4096 127.0.0.1:8000 0.0.0.0:*`. Tu compañero no puede llegar al puerto 8000 desde su portátil. ¿Cuál es el motivo más probable?
>
> - [ ] El puerto es superior al 1023, así que solo los administradores pueden conectarse a él
> - [ ] El servicio está en TIME-WAIT y aceptará conexiones dentro de un minuto
> - [x] El servicio escucha solo en la dirección de loopback, así que acepta conexiones desde el propio servidor y desde ningún otro sitio
> - [ ] `0.0.0.0:*` significa que todos los clientes están bloqueados
>
> La dirección local `127.0.0.1` restringe el oyente a la interfaz de loopback. La columna del par `0.0.0.0:*` simplemente significa «cualquier par» en un socket en escucha. Enlazar a `0.0.0.0` (y abrir el cortafuegos) lo haría accesible desde fuera.

### «Connection refused» frente a «connection timed out»
Cuando falla una conexión TCP, el mensaje de error te dice *hasta dónde llegó el SYN*.

![Izquierda: un cliente en 192.0.2.10 envía SYN a 198.51.100.20:8080, donde el puerto está cerrado. El host responde RST, ACK y el cliente informa de conexión rechazada en milisegundos. Derecha: un cliente en 192.0.2.10 envía SYN a 198.51.100.30:8080, donde un cortafuegos lo descarta en silencio. El cliente reintenta el SYN dos veces más sin respuesta e informa de tiempo de espera agotado cuando expira el temporizador](../../../assets/diagrams/tcp-refused-vs-timeout.es.svg)

*Figura 6. Rechazada significa que algo respondió. Tiempo agotado significa que nada lo hizo.*

- **Connection refused** (`ECONNREFUSED`). El SYN llegó al equipo de destino, pero ningún programa escucha en ese puerto, así que la pila TCP del equipo respondió con RST. Obtienes el error casi al instante. Un cortafuegos configurado para *rechazar* en lugar de *descartar* tiene el mismo efecto, enviando RST o un mensaje de «puerto inalcanzable» del Internet Control Message Protocol (ICMP). Mira el servidor: ¿está el servicio en marcha? ¿Escucha en el puerto y la dirección correctos (`ss -tlnp`)?
- **Connection timed out** (`ETIMEDOUT`). No volvió ninguna respuesta. El cliente reenvía el SYN varias veces, esperando cada vez más, y se rinde cuando expira su temporizador. Causas: un cortafuegos o grupo de seguridad de la nube que descarta el tráfico en silencio, un equipo apagado, una dirección IP equivocada o un problema de enrutamiento. Mira el camino: cortafuegos, grupos de seguridad, rutas.

Cuánto tarda el «timed out» depende del cliente. En Linux con la configuración por defecto, el kernel reintenta el SYN con intervalos que empiezan en aproximadamente 1 segundo y luego se duplican, y se rinde pasados poco más de 2 minutos (medimos 136 s en Linux 7.2 con `net.ipv4.tcp_syn_retries = 6`). La mayoría de las aplicaciones fijan su propio límite más corto, por ejemplo `curl --connect-timeout 5`.

Dos errores relacionados vienen de la capa de red y no del destino:
- **No route to host** (`EHOSTUNREACH`): un router devolvió un ICMP de «host inalcanzable», o tu propio equipo no pudo resolver la dirección Media Access Control (MAC) del siguiente salto en el enlace local.
- **Network is unreachable** (`ENETUNREACH`): tu propio equipo no tiene ninguna ruta hacia ese destino (revisa `ip route`).

UDP no tiene acuerdo inicial, así que no hay nada que rechazar. Si un datagrama UDP llega a un puerto cerrado, el equipo suele responder con un ICMP de «puerto inalcanzable», y un programa que haya usado `connect()` en su socket UDP puede ver un error «connection refused» en su siguiente recepción. Lo más frecuente es que un cliente UDP simplemente no oiga nada y tenga que fiarse de su propio temporizador.

> [!NOTE]
> En Windows, un cliente que recibe RST puede reintentar la conexión un par de veces antes de informar del error, así que el «refused» puede tardar unos dos segundos en lugar de milisegundos. La distinción (respuesta rápida frente a ninguna respuesta) sigue siendo válida.

> [!CHECK]
> `curl https://198.51.100.20:8443` falla tras exactamente 5 segundos con «Connection timed out», usando `--connect-timeout 5`. ¿Dónde miras primero?
>
> - [ ] En la configuración del servidor web, porque escucha en el puerto equivocado
> - [x] En el camino: un cortafuegos, un grupo de seguridad o un problema de enrutamiento está descartando el SYN, o el equipo está caído
> - [ ] En el rango de puertos efímeros del cliente, porque se ha quedado sin puertos
> - [ ] En TIME-WAIT en el servidor, porque las conexiones antiguas bloquean las nuevas
>
> Un puerto equivocado en un equipo alcanzable da un «connection refused» inmediato (RST). Un timeout significa que no hay ninguna respuesta, lo que apunta a algo que descarta paquetes o a un equipo inalcanzable.

## Cómo funciona
Junta todo. Escribes `https://www.example.com` en un navegador de un portátil en `192.0.2.10`. La página se sirve desde `203.0.113.80`.

1. **DNS sobre UDP.** El navegador necesita la dirección IP. El portátil envía una consulta DNS en un datagrama UDP desde un puerto efímero (digamos 41837) al puerto 53 del resolvedor, y recibe un datagrama de vuelta: `www.example.com` es `203.0.113.80`. Sin acuerdo inicial, dos paquetes.
2. **Elegir un puerto de origen.** El navegador pide al sistema operativo una conexión TCP a `203.0.113.80:443`. El sistema operativo elige un puerto efímero libre, el 50514. La 4-tupla `192.0.2.10:50514 → 203.0.113.80:443` nombra ahora esta conexión.
3. **Acuerdo de tres vías.** SYN, SYN-ACK, ACK (Figura 3). Cuesta un viaje de ida y vuelta antes de que puedan fluir datos. El socket del servidor en LISTEN sigue abierto para el siguiente cliente; el sistema operativo crea un nuevo socket ESTABLISHED para este.
4. **Datos.** El navegador inicia el acuerdo TLS y luego envía la petición HTTP. Cada segmento lleva números de secuencia y de confirmación; los segmentos perdidos se retransmiten (Figura 5); la ventana de recepción y la ventana de congestión limitan la velocidad del flujo de datos.
5. **Cierre.** Cuando el navegador termina (a menudo tras mantener la conexión abierta un rato para más peticiones), un extremo envía FIN, el otro responde con ACK y su propio FIN (Figura 4). Quien envió el primer FIN mantiene la 4-tupla en TIME-WAIT durante 60 segundos en Linux.
6. **Si algo falla** en el paso 3, el error te dice dónde: RST significa que el equipo es alcanzable pero nada escucha en el 443 (refused); el silencio significa que algo en el camino descarta el SYN (timed out).

Si el navegador y el servidor admiten HTTP/3, los pasos 2 a 5 se ejecutan sobre QUIC en el puerto UDP 443, y QUIC combina su propio acuerdo con el acuerdo TLS para ahorrar un viaje de ida y vuelta.

> [!CHECK]
> En la secuencia anterior, ¿qué mensajes viajan **antes** de que el primer byte de la petición HTTP salga del portátil?
>
> - [ ] Solo la propia petición HTTP; TCP envía datos de inmediato
> - [ ] Un acuerdo UDP con el resolvedor DNS y luego la petición HTTP
> - [x] Una consulta y respuesta DNS sobre UDP, el acuerdo de tres vías de TCP y el acuerdo TLS
> - [ ] El cierre TCP de la conexión anterior
>
> DNS no necesita acuerdo inicial, pero TCP sí (SYN, SYN-ACK, ACK), y HTTPS añade encima el acuerdo TLS. Por eso la reutilización de conexiones y el acuerdo combinado de HTTP/3 hacen que las páginas carguen más rápido.

## Ejemplo práctico
Te piden revisar un servidor web Linux en `203.0.113.80`. Todas las direcciones son direcciones de documentación (RFC 5737).

**¿Qué servicios están escuchando?** Ejecútalo como administrador para que `ss` pueda mostrar todos los procesos:

```bash
sudo ss -tulpn
```

```text
Netid State  Recv-Q Send-Q  Local Address:Port  Peer Address:Port Process
udp   UNCONN 0      0           127.0.0.1:323        0.0.0.0:*     users:(("chronyd",pid=702,fd=5))
tcp   LISTEN 0      128           0.0.0.0:22         0.0.0.0:*     users:(("sshd",pid=812,fd=3))
tcp   LISTEN 0      511           0.0.0.0:443        0.0.0.0:*     users:(("nginx",pid=1034,fd=6))
tcp   LISTEN 0      4096        127.0.0.1:5432       0.0.0.0:*     users:(("postgres",pid=990,fd=7))
tcp   LISTEN 0      128              [::]:22            [::]:*     users:(("sshd",pid=812,fd=4))
```

Léelo línea a línea:
- `udp UNCONN 127.0.0.1:323`: el demonio NTP `chronyd` tiene un socket UDP para comandos de control locales. Los sockets UDP aparecen como `UNCONN` porque UDP no tiene conexiones.
- `tcp LISTEN 0.0.0.0:22` y `[::]:22`: SSH acepta conexiones en todas las direcciones IPv4 e IPv6.
- `tcp LISTEN 0.0.0.0:443`: el servidor web, accesible desde cualquier lugar que el cortafuegos permita.
- `tcp LISTEN 127.0.0.1:5432`: la base de datos PostgreSQL acepta solo conexiones locales. Eso es bueno: la aplicación web del mismo equipo puede usarla, Internet no.
- En un socket en escucha, `Send-Q` muestra el **backlog**: el número máximo de conexiones que han completado el acuerdo pero que el programa aún no ha recogido (511 en nginx).

**¿Qué conexiones existen ahora mismo?**

```bash
ss -tan
```

```text
State      Recv-Q Send-Q     Local Address:Port      Peer Address:Port
LISTEN     0      128              0.0.0.0:22             0.0.0.0:*
LISTEN     0      511              0.0.0.0:443            0.0.0.0:*
LISTEN     0      4096           127.0.0.1:5432           0.0.0.0:*
ESTAB      0      0           203.0.113.80:443       192.0.2.10:50514
ESTAB      0      36          203.0.113.80:22      198.51.100.7:51022
TIME-WAIT  0      0           203.0.113.80:443       192.0.2.10:50388
ESTAB      0      0              127.0.0.1:5432         127.0.0.1:41870
ESTAB      0      0              127.0.0.1:41870        127.0.0.1:5432
LISTEN     0      128                 [::]:22                [::]:*
```

- `192.0.2.10:50514` es un navegador conectado al servidor web. Su puerto de origen es efímero; el lado del servidor es el 443.
- Un administrador en `198.51.100.7` ha iniciado sesión con SSH. `Send-Q 36` significa que se han enviado 36 bytes que aún no se han confirmado: normal en una sesión activa.
- `TIME-WAIT … 192.0.2.10:50388` es una conexión anterior del mismo navegador. La cerró primero el *servidor* (por ejemplo, por un timeout de keep-alive inactivo), así que el servidor mantiene el TIME-WAIT.
- Las dos líneas `127.0.0.1` son *una* conexión vista desde ambos extremos: la aplicación web (puerto 41870) hablando con la base de datos (5432). Las conexiones de loopback siempre aparecen dos veces.

**¿Qué aspecto tiene un acuerdo inicial en la red?** Una captura con `tcpdump` en el servidor (`-n` muestra números, `-t` oculta las marcas de tiempo) muestra el inicio de la conexión del navegador:

```bash
sudo tcpdump -n -t -i eth0 'tcp port 443 and host 192.0.2.10'
```

```text
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [S], seq 2864127401, win 64240, options [mss 1460,sackOK,TS val 3017325814 ecr 0,nop,wscale 7], length 0
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [S.], seq 1207650562, ack 2864127402, win 65160, options [mss 1460,sackOK,TS val 1554302991 ecr 3017325814,nop,wscale 7], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [.], ack 1, win 502, options [nop,nop,TS val 3017325839 ecr 1554302991], length 0
IP 192.0.2.10.50514 > 203.0.113.80.443: Flags [P.], seq 1:518, ack 1, win 502, options [nop,nop,TS val 3017325840 ecr 1554302991], length 517
IP 203.0.113.80.443 > 192.0.2.10.50514: Flags [.], ack 518, win 507, options [nop,nop,TS val 1554303016 ecr 3017325840], length 0
```

- `[S]` es SYN, `[S.]` es SYN-ACK (`.` representa el indicador ACK), `[.]` es un ACK simple y `[P.]` son datos con el indicador PSH (push). `[F.]` y `[R]` serían FIN y RST.
- Los ISN son números aleatorios de 32 bits: 2864127401 y 1207650562. El SYN-ACK confirma 2864127401 + 1.
- A partir de la tercera línea, `tcpdump` muestra números de secuencia *relativos* para ahorrar espacio: `ack 1` significa «ISN + 1». Después el cliente envía los bytes 1 a 517 (`seq 1:518`, `length 517`, un TLS ClientHello) y el servidor confirma 518.
- `mss 1460` es el mayor segmento que acepta cada extremo: una trama Ethernet de 1500 bytes menos 20 bytes de cabecera IP y 20 de TCP. `win 502` con `wscale 7` significa una ventana de recepción de 502 × 2⁷ = 64.256 bytes.

> [!NOTE]
> Los tamaños de ventana, las opciones y la disposición exacta de columnas de `ss` varían con la versión del sistema operativo y su configuración. La estructura (indicadores, números de secuencia y de confirmación, estados) es la misma en todas partes. Producirás tu propia captura en el laboratorio.

## Errores comunes
- **Tratar «refused» y «timed out» como el mismo problema.** Refused: ve al servidor y revisa el servicio. Timed out: revisa cortafuegos, grupos de seguridad y enrutamiento. Depurar la aplicación cuando un cortafuegos descarta el SYN hace perder horas.
- **Enlazar un servicio a `127.0.0.1` y preguntarse por qué nadie puede acceder**, o lo contrario: enlazar una base de datos o una interfaz de administración a `0.0.0.0` «para que funcione» y exponerla a Internet.
- **Abrir solo el puerto del servidor en un cortafuegos sin estado.** Las respuestas vuelven al puerto efímero del cliente. Los cortafuegos con estado lo gestionan automáticamente; los que no tienen estado (como algunas listas de control de acceso de red, ACL, en la nube) necesitan el rango efímero abierto para el tráfico de vuelta, y Linux, Windows y macOS usan rangos distintos.
- **«Arreglar» TIME-WAIT con ajustes del kernel.** Miles de sockets en TIME-WAIT son normales en equipos ocupados. Reutiliza conexiones en su lugar. El antiguo ajuste de Linux `tcp_tw_recycle` rompía a los clientes detrás de NAT y se eliminó en Linux 4.12.
- **Ignorar CLOSE-WAIT.** Los sockets en CLOSE-WAIT que se acumulan y nunca desaparecen son un fallo de la aplicación: el programa nunca cierra conexiones que el otro extremo ya cerró. Reiniciar lo oculta; arreglar el código lo cura.
- **Suponer que TCP conserva los límites de los mensajes.** TCP es un flujo de bytes. Dos llamadas `send()` de 100 bytes pueden llegar como una lectura de 200 bytes, o como 150 + 50. Las aplicaciones deben delimitar sus mensajes (prefijos de longitud, delimitadores).
- **Suponer que los datagramas UDP llegan.** UDP no avisa cuando se pierde un datagrama. Una aplicación sobre UDP necesita sus propios temporizadores y reintentos.
- **Olvidar que los puertos TCP y UDP son independientes.** Permitir el puerto TCP 53 en un cortafuegos no permite DNS sobre el puerto UDP 53, y viceversa.

## Consideraciones de seguridad
- **SYN floods.** Durante el acuerdo, el servidor mantiene una conexión semiabierta (SYN-RECV) por cada SYN que responde. Un atacante que envía enormes cantidades de SYN, normalmente con direcciones de origen falsificadas, puede llenar esa cola para que los clientes reales no puedan conectarse. La defensa estándar son las **SYN cookies** (RFC 4987): cuando la cola está llena, el servidor codifica los detalles de la conexión en su propio ISN y no guarda estado hasta que vuelve un ACK válido. Linux las activa por defecto (`net.ipv4.tcp_syncookies = 1`). Los ataques grandes necesitan además limitación de tasa o un servicio de mitigación aguas arriba.
- **Escaneo de puertos.** Como los puertos cerrados responden con RST, los abiertos con SYN-ACK y los filtrados con silencio, cualquiera puede mapear qué servicios expone un equipo. Eso es el **escaneo de puertos**, la misma lógica de refused frente a timeout que acabas de aprender. Los defensores escanean sus *propias* redes para encontrar servicios que no deberían estar expuestos. Escanear sistemas que no son tuyos o que no estás autorizado explícitamente a probar puede ser ilegal e incumple los términos de servicio de la mayoría de los proveedores.
- **Exponer lo mínimo posible.** Cada puerto en escucha es superficie de ataque. Enlaza los servicios internos (bases de datos, cachés, paneles de administración) a `127.0.0.1` o a una dirección privada, pon un cortafuegos de denegación por defecto delante de todo lo demás y nunca publiques SSH (22), RDP (3389) ni bases de datos (3306, 5432, 6379…) directamente a Internet. Usa en su lugar una red privada virtual (VPN) o un host bastión. Revisa con regularidad la salida de `ss -tulpn`.
- **¿Descartar o rechazar?** Descartar hace los escaneos más lentos y revela menos; rechazar hace los fallos rápidos y claros para los usuarios legítimos. Muchas organizaciones descartan en el borde de Internet y rechazan dentro de la red.
- **Reflexión y amplificación UDP.** UDP no tiene acuerdo inicial, así que la dirección de origen es fácil de falsificar. Los atacantes envían consultas pequeñas a servidores DNS, NTP o memcached abiertos con la dirección de la víctima como origen, y las respuestas, más grandes, inundan a la víctima. No ejecutes resolvedores abiertos ni servicios sobre UDP que respondan a cualquiera, y filtra los orígenes falsificados en el borde de la red (Best Current Practice BCP 38, RFC 2827).
- **TCP y UDP no cifran.** Cualquiera en el camino puede leer y cambiar los datos. Usa TLS (HTTPS, SMTP con STARTTLS, el Internet Message Access Protocol sobre TLS, IMAPS), SSH o QUIC para todo lo sensible. Los ISN impredecibles (RFC 6528) y las comprobaciones de la RFC 5961 dificultan la inyección a ciegas de segmentos o RST falsos, pero no protegen frente a un atacante que puede ver el tráfico.

## Resumen
- La capa de transporte entrega datos a procesos. Los puertos (0–65535) los identifican: conocidos/del sistema 0–1023, registrados/de usuario 1024–49151, dinámicos/efímeros 49152–65535 (RFC 6335). Linux usa por defecto 32768–60999 para los puertos efímeros. Una 4-tupla identifica una conexión.
- UDP (RFC 768) es sin conexión, de mejor esfuerzo y mínimo: una cabecera de 8 bytes, datagramas separados, sin confirmaciones. TCP (RFC 9293) está orientado a conexión, es fiable y ordenado, con control de flujo y de congestión. QUIC (RFC 9000) construye sobre UDP prestaciones similares a las de TCP más cifrado.
- TCP se abre con SYN, SYN-ACK, ACK y se cierra con un FIN y un ACK en cada sentido. El extremo que cierra primero espera en TIME-WAIT (2 × MSL; 60 s en Linux), lo cual es normal.
- Los números de secuencia cuentan bytes; las confirmaciones nombran el siguiente byte esperado. Los datos perdidos se reenvían tras un timeout o ACK duplicados; la ventana de recepción (control de flujo) y la ventana de congestión limitan la velocidad de envío.
- `ss -tulpn` / `ss -tan` (Linux) y `netstat`, `lsof` o `Get-NetTCPConnection` (macOS, Windows) muestran los sockets en escucha y los estados. Comprueba la dirección de escucha además del puerto.
- «Connection refused» significa que el equipo respondió con RST: nada escucha ahí. «Connection timed out» significa que no hubo ninguna respuesta: mira los cortafuegos, el enrutamiento y si el equipo está en marcha.

## Glosario
| Término | Definición |
|---|---|
| Capa de transporte | Capa 4 de OSI: transporta datos entre procesos de distintos equipos, usando puertos. |
| Puerto | Número de 16 bits (0–65535) que identifica el extremo de un proceso para TCP o UDP en un equipo. |
| Demultiplexación | Entregar los datos entrantes al proceso correcto según su puerto de destino. |
| Multiplexación | Combinar los datos de muchos procesos en una sola conexión de red o dirección IP, etiquetados con puertos. |
| Puertos conocidos | Puertos 0–1023, llamados puertos del sistema en la RFC 6335; los usan los servicios estándar. |
| Puertos registrados | Puertos 1024–49151, llamados puertos de usuario en la RFC 6335; la IANA los asigna a servicios bajo petición. |
| Puerto efímero | Puerto temporal que el sistema operativo da a un cliente para una conexión; la RFC 6335 reserva 49152–65535 para ellos. |
| Socket | Extremo de comunicación: una dirección IP, un puerto y un protocolo, tal como lo usa un programa. |
| 4-tupla | Dirección IP de origen, puerto de origen, dirección IP de destino y puerto de destino: juntos identifican una conexión. |
| 5-tupla | La 4-tupla más el protocolo (TCP o UDP); la usan los cortafuegos y NAT. |
| User Datagram Protocol (UDP) | Protocolo de transporte sin conexión y de mejor esfuerzo con una cabecera de 8 bytes (RFC 768). |
| Datagrama | Mensaje UDP autónomo que llega entero o no llega. |
| Sin conexión | Enviar datos sin establecer antes una conexión ni mantener estado sobre el otro extremo. |
| Transmission Control Protocol (TCP) | Protocolo de transporte orientado a conexión que entrega un flujo de bytes fiable y ordenado (RFC 9293). |
| Orientado a conexión | Que exige a ambos extremos establecer una conexión antes de intercambiar datos. |
| Flujo de bytes | Modelo de servicio de TCP: una secuencia ordenada de bytes sin límites de mensaje. |
| Segmento | La unidad de datos que envía TCP: una cabecera TCP más un fragmento del flujo de bytes. |
| QUIC | Protocolo de transporte sobre UDP con fiabilidad, flujos, control de congestión y cifrado TLS 1.3 integrados (RFC 9000); lo usa HTTP/3. |
| Acuerdo de tres vías | El intercambio SYN, SYN-ACK, ACK que abre una conexión TCP. |
| SYN | Indicador TCP que abre una conexión y lleva el número de secuencia inicial. |
| ACK | Indicador TCP que marca como válido el número de confirmación; presente en casi todos los segmentos después del primero. |
| FIN | Indicador TCP que significa «no tengo más datos que enviar»; cierra un sentido de la conexión. |
| RST | Indicador TCP que aborta una conexión de inmediato, o rechaza una conexión a un puerto cerrado. |
| Número de secuencia inicial (ISN) | El número de secuencia inicial de 32 bits, impredecible, que elige cada extremo para una conexión. |
| Maximum Segment Size (MSS) | La mayor cantidad de datos que un equipo acepta en un segmento TCP, anunciada en el SYN. |
| ESTABLISHED | Estado TCP de una conexión abierta que puede transportar datos (`ESTAB` en `ss`). |
| CLOSE-WAIT | Estado TCP tras cerrar el otro extremo cuando la aplicación local aún no lo ha hecho (`CLOSE_WAIT` en `netstat`). |
| Cierre a medias (half-close) | Conexión TCP en la que un sentido está cerrado mientras el otro aún puede enviar. |
| TIME-WAIT | Estado TCP del extremo que cerró primero, mantenido durante 2 × MSL (`TIME_WAIT` en `netstat`). |
| Maximum Segment Lifetime (MSL) | El tiempo máximo supuesto que un segmento puede sobrevivir en la red; 2 minutos en la RFC 9293. |
| Número de secuencia | El número del primer byte de datos de un segmento TCP. |
| Número de confirmación | El siguiente byte que espera un receptor TCP; confirma todo lo anterior. |
| Temporizador de retransmisión (RTO) | El temporizador adaptativo tras el cual TCP reenvía datos sin confirmar (RFC 6298). |
| ACK duplicado | Una confirmación repetida del mismo byte, enviada cuando un segmento llega desordenado. |
| Retransmisión rápida | Reenviar un segmento tras tres ACK duplicados, sin esperar al RTO (RFC 5681). |
| Confirmación selectiva (SACK) | Opción TCP que permite al receptor informar exactamente de qué bloques ha recibido (RFC 2018). |
| Control de flujo | Limitar al emisor a lo que el receptor puede almacenar, mediante la ventana de recepción. |
| Ventana de recepción | El número de bytes que un receptor TCP aún puede aceptar, anunciado en cada segmento (`win`). |
| Control de congestión | Limitar la velocidad de envío a lo que la red puede transportar, mediante la ventana de congestión (RFC 5681). |
| Socket en escucha | Socket de servidor en estado LISTEN, esperando conexiones en una dirección y puerto. |
| Connection refused | Error cuando el destino responde a un SYN con RST (o ICMP de puerto inalcanzable): nada escucha. |
| Connection timed out | Error cuando no llega respuesta al SYN antes del timeout del cliente. |
| No route to host | Error (`EHOSTUNREACH`) cuando un router informa de que el host es inalcanzable, o no se puede resolver la dirección MAC del siguiente salto. |
| Network is unreachable | Error (`ENETUNREACH`) cuando el equipo local no tiene ruta hacia el destino. |
| Backlog | La cola de conexiones que han completado el acuerdo pero que el programa aún no ha aceptado. |
| SYN cookies | Defensa contra SYN flood que codifica el estado de la conexión en el ISN del servidor en lugar de almacenarlo (RFC 4987). |
| Escaneo de puertos | Sondear los puertos de un equipo para averiguar cuáles están abiertos, cerrados o filtrados. |

## Comprueba lo que has aprendido
1. ¿Por qué un cliente usa un puerto efímero en lugar de uno fijo, mientras que un servidor usa un puerto fijo y conocido?
2. DNS normalmente usa UDP, pero DHCP *debe* usar UDP. ¿Cuál es la diferencia en los motivos?
3. En una captura, un SYN tiene `seq 2000` y el SYN-ACK tiene `seq 7000`. ¿Qué números de confirmación llevan el SYN-ACK y el ACK final, y por qué «más uno»?
4. Un servidor muestra 3000 sockets en `TIME-WAIT` y 2000 en `CLOSE-WAIT`. ¿Qué cifra te preocuparía y qué mirarías?
5. `ss -tln` muestra tu servicio en `0.0.0.0:8080`, pero los clientes de Internet obtienen «connection timed out». Enumera dos causas posibles y cómo comprobarías cada una.
6. ¿Por qué los SYN floods son un problema para los servidores TCP, y por qué las SYN cookies no necesitan que el servidor recuerde nada de las conexiones semiabiertas?

## Referencias
- [RFC 9293](https://www.rfc-editor.org/rfc/rfc9293) — Transmission Control Protocol (TCP).
- [RFC 768](https://www.rfc-editor.org/rfc/rfc768) — User Datagram Protocol.
- [RFC 6335](https://www.rfc-editor.org/rfc/rfc6335) — Procedures for the Management of the Service Name and Transport Protocol Port Number Registry.
- [IANA Service Name and Transport Protocol Port Number Registry](https://www.iana.org/assignments/service-names-port-numbers/).
- [RFC 6298](https://www.rfc-editor.org/rfc/rfc6298) — Computing TCP's Retransmission Timer.
- [RFC 5681](https://www.rfc-editor.org/rfc/rfc5681) — TCP Congestion Control.
- [RFC 2018](https://www.rfc-editor.org/rfc/rfc2018) — TCP Selective Acknowledgment Options.
- [RFC 7323](https://www.rfc-editor.org/rfc/rfc7323) — TCP Extensions for High Performance (window scaling, timestamps).
- [RFC 9438](https://www.rfc-editor.org/rfc/rfc9438) — CUBIC for Fast and Long-Distance Networks.
- [RFC 6528](https://www.rfc-editor.org/rfc/rfc6528) — Defending against Sequence Number Attacks.
- [RFC 5961](https://www.rfc-editor.org/rfc/rfc5961) — Improving TCP's Robustness to Blind In-Window Attacks.
- [RFC 4987](https://www.rfc-editor.org/rfc/rfc4987) — TCP SYN Flooding Attacks and Common Mitigations.
- [RFC 7766](https://www.rfc-editor.org/rfc/rfc7766) — DNS Transport over TCP — Implementation Requirements.
- [RFC 9000](https://www.rfc-editor.org/rfc/rfc9000) — QUIC: A UDP-Based Multiplexed and Secure Transport.
- [RFC 9114](https://www.rfc-editor.org/rfc/rfc9114) — HTTP/3.
- [RFC 2827](https://www.rfc-editor.org/rfc/rfc2827) — Network Ingress Filtering (BCP 38).
- [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737) — IPv4 Address Blocks Reserved for Documentation.
- [Documentación del kernel de Linux: IP sysctl](https://docs.kernel.org/networking/ip-sysctl.html) — `ip_local_port_range`, `tcp_syn_retries`, `tcp_syncookies` y ajustes relacionados.
