Redes

El panorama general y las palabras que necesitamos

Antes de las capas, pongámonos de acuerdo en algunas palabras. Vuelven en todas las secciones, así que vale la pena conocerlas una vez, con calma.

Las redes tienen tamaños. Una LAN (red local) cubre un salón, una casa o una escuela. Una WAN (red de área amplia) cubre ciudades o países. Internet no es una sola red: son millones de redes unidas por enrutadores, todas hablando la misma familia de protocolos, llamada TCP/IP.

Capas: los modelos de referencia OSI y TCP/IP

Imagina que quieres mandar una tarjeta de cumpleaños a un amigo en otro país. La escribes, un empleado la mete en un sobre con dirección, un camión la lleva al aeropuerto, un avión la vuela y otro cartero la entrega. Nadie hace todo el trabajo, y cada ayudante solo necesita conocer su parte. Las redes funcionan igual, y cada ayudante se llama capa.

Una capa ofrece un servicio a la capa de arriba: una promesa de lo que sabe hacer, como 'yo llevo tu paquete hasta la siguiente máquina'. Para cumplir la promesa, la capa conversa con la misma capa de la otra máquina usando un protocolo: las reglas y los formatos de mensaje que acordaron. El servicio dice qué se ofrece. El protocolo dice cómo lo hacen los dos lados. Como son cosas separadas, se puede cambiar el protocolo de una capa (por ejemplo, usar otro cable) sin tocar las capas vecinas.

El modelo OSI tiene siete capas. El modelo TCP/IP tiene cuatro: enlace, internet, transporte y aplicación. Las dos capas del medio de OSI, sesión y presentación, tuvieron poca utilidad práctica, así que en TCP/IP su trabajo queda a cargo de cada aplicación. Un resumen clásico: OSI es un buen modelo cuyos protocolos nunca se impusieron, mientras que TCP/IP tiene protocolos que conquistaron el mundo, pero un modelo que solo se describe bien a sí mismo (no separa con claridad servicio, interfaz y protocolo).

Encapsulamiento: sobres dentro de sobres

Cuando un mensaje baja por la pila, cada capa mete lo que recibió dentro de su propio sobre, llamado encabezado (header), y a veces también un final (trailer). En el destino ocurre lo contrario: cada capa abre su sobre, lo lee y entrega lo que hay dentro a la capa de arriba. Eso es el encapsulamiento. Una capa nunca necesita entender lo que hay dentro del sobre que lleva.

Origen                              Destino

[ Mensaje ]                         [ Mensaje ]
   |  + encabezado de aplicación       ^  - se quita
[EA|Mensaje]  (aplicación)
   |  + encabezado de transporte       ^
[ET|EA|Mensaje]  (segmento)
   |  + encabezado de red (paquete)    ^
[ER|ET|EA|Mensaje]
   |  + encabezado/final de enlace     ^
[EE|ER|ET|EA|Mensaje|FE] --bits--> cable

Los encabezados cuestan espacio. La sobrecarga (overhead) es la parte de los bytes enviados que son encabezados: total de encabezados dividido entre el total enviado. Si la aplicación escribe 400 bytes y cuatro capas agregan 50 bytes de encabezado cada una, la sobrecarga es 200 / 600, es decir, un tercio. Cuanto más pequeño el mensaje, más pesan los encabezados.

Conmutación de circuitos y conmutación de paquetes

• Conmutación de circuitos (teléfono antiguo): antes de hablar se reserva un camino de punta a punta. Nadie más usa esa capacidad, aunque tú estés en silencio. Buena calidad, pero desperdicio para tráfico en ráfagas.
• Conmutación de paquetes (Internet): el mensaje se corta en paquetes que comparten los enlaces. Cada enrutador recibe el paquete completo, lo guarda y solo después lo envía (store-and-forward). Es eficiente cuando el tráfico llega en ráfagas. El precio es el retardo variable, porque los paquetes pueden esperar en una cola, y la pérdida de paquetes cuando la cola se llena.

¿Cuánto tarda un paquete?

El retardo en un enlace tiene dos partes separadas. El tiempo de transmisión es lo que se tarda en poner todos los bits en el cable: tamaño del paquete en bits dividido entre la tasa del enlace. El retardo de propagación es lo que tarda un bit en recorrer el cable: distancia dividida entre la velocidad de la señal (unos 200 000 km/s en cable o fibra). El último bit llega después de la suma de ambos. Convención del quiz: los dos se cuentan desde el instante en que el primer bit empieza a salir del remitente.

paquete = 500 bytes = 4000 bits, enlace = 2 Mbps, distancia = 3000 km
transmisión = 4000 bits / 2 000 000 bps = 0,002 s = 2 ms
propagación = 3000 km / 200 000 km/s    = 0,015 s = 15 ms
el último bit llega después de 2 + 15 = 17 ms

La capa física: convertir bits en señales

El piso de abajo tiene un trabajo simple: tomar bits y hacer que algo viaje por un medio, para que el otro lado pueda leerlos otra vez. No sabe qué significan los bits. Solo le importan los voltajes, la luz y las ondas de radio.

El cobre lleva electricidad, así que los rayos, los motores y los cables cercanos agregan ruido, y la señal se debilita (atenuación), sobre todo en frecuencias altas. La fibra lleva luz, y el ruido eléctrico no la perturba. Por eso los enlaces largos y rápidos usan fibra.

Baudios y tasa de bits

La tasa de símbolos, medida en baudios, es cuántas veces por segundo cambia la señal. Si cada símbolo puede tener V estados distintos, un símbolo lleva log₂ V bits. Así que tasa de bits = baudios × log₂ V. Una señal con 8 estados y 1 000 cambios por segundo lleva 3 bits por símbolo, es decir, 3 000 bits por segundo. Baudios y bits por segundo solo son iguales cuando hay dos estados.

Sentidos de un enlace

• Símplex: un solo sentido (como la transmisión de TV).
• Semidúplex (half-duplex): los dos sentidos, pero por turnos (como un walkie-talkie: se dice 'cambio').
• Dúplex completo (full-duplex): los dos sentidos al mismo tiempo (como una llamada telefónica). El Ethernet conmutado de hoy es full-duplex; el antiguo cable compartido era half-duplex.

¿Qué tan rápido puede ir un canal?

Dos límites famosos responden esto. Ancho de banda aquí significa el ancho de la banda de frecuencias que el canal deja pasar, medido en hertz (Hz). Nyquist vale para un canal perfecto, sin ruido: se pueden enviar como máximo 2B símbolos por segundo, así que, con V niveles, el máximo es 2B log₂ V bits por segundo. Shannon vale para un canal real, con ruido: el máximo es B log₂(1 + S/N), sin importar el número de niveles. S/N es la potencia de la señal dividida entre la potencia del ruido. A menudo se da en decibelios: dB = 10 log₁₀(S/N), así que 10 dB son 10 veces, 20 dB son 100 veces y 30 dB son 1 000 veces.

Nyquist: B = 4 kHz, V = 4 niveles
  máx = 2 * 4000 * log2(4) = 2 * 4000 * 2 = 16 000 bps

Shannon: B = 2 kHz, 20 dB -> S/N = 100
  máx = 2000 * log2(1 + 100) = 2000 * 6,66 = unos 13 300 bps

Canal real con los dos límites: vale el menor (13 300)

Enviar bits: codificación y relojes

El receptor necesita saber dónde termina un bit y empieza el siguiente, pero no hay un cable aparte con el reloj del remitente. La codificación Manchester mete el reloj dentro de los datos: cada bit tiene una transición en la mitad de su intervalo, y la dirección de esa transición (hacia arriba o hacia abajo) dice si el bit es 0 o 1. Qué dirección significa qué depende del estándar. El precio es que la señal cambia el doble de veces, así que necesita cerca del doble de ancho de banda. El Ethernet clásico la usaba. La forma simple, NRZ, usa un voltaje para 1 y otro para 0, así que una racha larga de bits iguales parece una línea plana y se pierde el reloj.

bits:        1 1 1 1 1 0
NRZ:         ---------\_   (un nivel fijo por 5 bits:
                           ¿dónde empieza cada bit?)
Manchester:  un cambio en la mitad de TODO bit

Compartir un canal: multiplexación

• FDM (división de frecuencia): cada señal recibe su propia banda de frecuencias, como las estaciones de radio en puntos distintos del dial.
• TDM (división de tiempo): las señales se turnan, cada una en su intervalo de tiempo.
• CDM / CDMA (división de código): todos hablan a la vez en la misma banda, pero cada estación multiplica sus bits por un código propio (una secuencia de chips). Los códigos son ortogonales: su producto interno es cero.

CDMA es como una fiesta donde la gente habla idiomas distintos: sintonizas el oído en tu idioma y los demás suenan como ruido de fondo. En números: toma los chips A = (+1 +1 −1 −1) y B = (+1 −1 +1 −1). Su producto elemento a elemento es +1 −1 −1 +1, que suma 0, así que son ortogonales. A envía el bit 1 (envía A) mientras B envía el bit 0 (envía −B). El canal los suma: (0, +2, −2, 0). Para escuchar a A, multiplica por A y divide entre 4: (0 + 2 + 2 + 0)/4 = +1, bit 1. Para escuchar a B: (0 − 2 − 2 + 0)/4 = −1, bit 0. Un resultado +1 significa bit 1, −1 significa bit 0, y 0 significa que esa estación estuvo en silencio.

La PCM (modulación por codificación de pulsos) convierte la voz en bits. La voz telefónica ocupa unos 4 kHz, así que se muestrea al doble, 8 000 veces por segundo (una cada 125 µs). Con 8 bits por muestra, la tasa es 8 000 × 8 = 64 000 bps, el clásico canal de voz de 64 kbps.

La capa de enlace de datos: entramado, errores y ventana deslizante

La capa física envía un flujo de bits. La capa de enlace convierte el flujo en tramas (frames, paquetitos de bits) que viajan entre dos máquinas conectadas directamente por un enlace. Tiene tres tareas: marcar dónde empieza y termina cada trama, descubrir (o arreglar) bits dañados y evitar ahogar a un receptor lento.

Entramado: ¿dónde termina una trama?

• Conteo de bytes: el encabezado dice cuántos bytes siguen. Simple, pero un conteo equivocado arruina todo lo que viene después.
• Byte de bandera con byte stuffing: un byte especial (la bandera) marca el inicio y el final. Si el mismo valor aparece dentro de los datos, el remitente pone un byte de escape antes (y antes de cualquier byte de escape en los datos). El receptor quita los bytes de escape, y los datos llegan sin cambios.
• Bandera de bits con bit stuffing: la bandera es el patrón 01111110. Cada vez que el remitente ve cinco 1 seguidos en los datos, inserta un 0. El receptor hace lo inverso: después de cinco 1, se quita un 0. Así, seis 1 seguidos solo pueden ser la bandera.

datos a enviar:   0 1 1 1 1 1 1 0 1
después de cinco 1 se inserta un 0:
datos con stuffing: 0 1 1 1 1 1 [0] 1 0 1
trama: 01111110 0111110101 01111110   (bandera, datos, bandera)

Descubrir errores

El ruido invierte algunos bits. Para notarlo, enviamos bits extra de verificación, llamados redundancia. El bit de paridad es el más simple: se elige el bit para que la cantidad de 1 en el bloque sea par (o impar, por acuerdo). Los datos 1011 tienen tres 1, así que el bit de paridad par es 1. Si un bit se invierte, la cuenta queda impar y el receptor lo nota. Pero si se invierten dos bits, la cuenta vuelve a ser par y el error pasa sin verse. Un solo bit de paridad detecta cualquier cantidad impar de bits invertidos y deja pasar las cantidades pares.

La fuerza de un código se mide por su distancia de Hamming: el menor número de posiciones de bits en que dos palabras de código válidas difieren. Para detectar e errores se necesita distancia e + 1. Para corregir e errores se necesita distancia 2e + 1 (la palabra dañada debe seguir más cerca de la correcta que de cualquier otra). Distancia 5 detecta 4 errores o corrige 2. La paridad tiene distancia 2: detecta 1, no corrige ninguno.

Un código de Hamming corrige un bit invertido. Los bits de verificación están en las posiciones 1, 2, 4, 8, ... y cada uno revisa las posiciones cuyo número en binario contiene esa potencia de dos. Tras una falla, sumar los números de las verificaciones que fallaron da la posición exacta del bit malo, y el receptor lo invierte de vuelta. Con m bits de datos y r bits de verificación, los r bits deben decir 'sin error' o señalar uno de m + r lugares, así que m + r + 1 ≤ 2ʳ.

El CRC (verificación de redundancia cíclica) trata los bits de datos como un polinomio y lo divide entre un polinomio generador fijo, usando aritmética sin acarreo (la resta es XOR). El remitente agrega r ceros (r es el grado del generador), divide y pone el residuo en lugar de los ceros. La trama ahora es exactamente divisible entre el generador. El receptor divide la trama completa: cualquier residuo distinto de cero indica un error.

datos 1101, generador x^2 + 1 = 101, así que r = 2
agrega dos ceros:  110100
110 xor 101 = 011, baja el 1 -> 111
111 xor 101 = 010, baja el 0 -> 100
100 xor 101 = 001, baja el 0 -> 010 (empieza con 0)
residuo = 10, transmite 1101 10 = 110110
el receptor divide 110110 entre 101 -> residuo 0 -> aceptada

Stop-and-wait

La regla más simple para un remitente: enviar una trama, esperar una confirmación (ACK, una trama pequeña de 'recibido') y solo entonces enviar la siguiente. Si el ACK no llega antes de que se acabe un temporizador, se envía la trama de nuevo. Pero un ACK perdido crea un problema: el receptor ya tiene la trama y la recibe otra vez, sin poder distinguir una copia de una trama nueva. Por eso cada trama lleva un número de secuencia. En stop-and-wait, un bit (0, 1, 0, 1...) basta.

Stop-and-wait desperdicia el enlace. Cada ciclo dura el tiempo de transmisión de la trama más el tiempo de ida y vuelta (RTT), y la línea está parada mientras espera. Utilización = t_trama / (t_trama + RTT). Con un enlace de 1 Mbps y tramas de 1 000 bits, t_trama = 1 ms. Si el RTT es 20 ms, la utilización es 1/21, solo 4,8 %. Para mantener el enlace ocupado haría falta tener unas 21 tramas en el aire, y esa es la idea de la ventana deslizante.

Otro truco es el piggybacking: cuando hay datos yendo en sentido contrario, el ACK viaja dentro del encabezado de esa trama de datos, ahorrando una trama completa. Si no hay datos que lo lleven, un temporizador corto envía el ACK solo.

Ventana deslizante: muchas tramas en tránsito

En un protocolo de ventana deslizante, el remitente puede enviar varias tramas antes de que llegue el primer ACK. La ventana es la lista de números que puede tener pendientes. A medida que llegan los ACK, la ventana se desliza hacia adelante. Con n bits para el número de secuencia hay 2ⁿ números.

secuencia: 0  1  2  3  4  5  6  7  0  1 ...
          [ enviadas, esperando ACK ][ puede enviar ]
           ^ más antigua sin ACK     ^ siguiente a enviar
           la ventana se desliza a la derecha al llegar el ACK del 0

Control de acceso al medio: compartir un canal

En algunas redes muchas estaciones comparten un solo canal, como niños en un salón que quieren hablar todos. Si dos hablan a la vez, nadie entiende nada: eso es una colisión. Las reglas que dicen quién habla cuándo pertenecen a una subcapa de la capa de enlace, llamada MAC (control de acceso al medio).

ALOHA: habla cuando quieras

En el ALOHA puro la estación envía en cuanto tiene una trama, sin escuchar. Si choca, espera un tiempo aleatorio y vuelve a intentar. Una trama es golpeada si cualquier otra empieza durante una ventana de dos tiempos de trama alrededor de ella (el período vulnerable). Si G es el promedio de intentos por tiempo de trama, el rendimiento es S = G e^(−2G), como máximo 1/(2e) ≈ 18,4 %, en G = 0,5. Se pierde más del 80 % del tiempo.

El ALOHA ranurado (slotted) divide el tiempo en ranuras, y las estaciones solo pueden empezar al inicio de una ranura. Las tramas o se solapan por completo o no se tocan, así que el período vulnerable es solo un tiempo de trama. Entonces S = G e^(−G), como máximo 1/e ≈ 36,8 %, en G = 1, el doble de la versión pura. Por encima de la mejor carga, más intentos significan más colisiones, que causan más retransmisiones y aún más carga. Ese comportamiento inestable es la razón de que exista el backoff.

CSMA: escucha primero

El CSMA (acceso múltiple con detección de portadora) agrega una regla educada: escucha antes de hablar y espera si otro está usando el canal. El CSMA/CD (con detección de colisiones) además sigue escuchando mientras envía y se detiene en cuanto nota una colisión. Después de la colisión, cada estación espera un tiempo aleatorio elegido por el retroceso exponencial binario: después de la i-ésima colisión de la misma trama, se sortea un número de ranuras de 0 a 2ⁱ − 1 (es decir, 0 a 1, luego 0 a 3, luego 0 a 7, y así sucesivamente), hasta un tope de 0 a 1023. Con pocas estaciones la espera es corta. Con muchas, el rango crece rápido y dispersa los intentos. Se adapta a la carga sin que nadie la conozca.

Hay un detalle. Una estación solo descubre la colisión si todavía está enviando cuando regresa el ruido. En el peor caso, la trama casi ha llegado al otro extremo cuando choca, y el ruido tarda lo mismo en volver: dos veces el tiempo de propagación (2τ). Así que la trama debe durar al menos 2τ, y el tamaño mínimo de trama = tasa × 2τ. Las redes más rápidas necesitan tramas mínimas más largas o cables más cortos.

10 Mbps, tiempo de ranura 2*tau = 51,2 microsegundos
trama mínima = 10 000 000 bps * 0,0000512 s = 512 bits = 64 bytes

Diez veces más rápido (100 Mbps) con la MISMA trama de 64 bytes:
  el cable tendría que ser 10 veces más corto

Ethernet, switches y hubs

Toda interfaz Ethernet tiene una dirección MAC de 48 bits. Los primeros 24 bits identifican al fabricante. Nombra a un dispositivo dentro de la red local; no se usa para enrutar entre redes (eso es trabajo de la dirección IP, en la capa siguiente).

Un hub solo repite los bits en todos los demás puertos, así que todos comparten un canal y hay colisiones. Un switch lee la dirección MAC de destino de cada trama y la envía solo por el puerto correcto, así que varias conversaciones pueden ocurrir a la vez y no hay colisiones entre puertos. Un switch no necesita configuración, porque aprende solo: cuando una trama de A entra por el puerto 1, anota 'A está en el puerto 1' en su tabla. Para reenviar, consulta el destino. Si el destino es conocido, usa solo ese puerto. Si es desconocido (o la trama es de broadcast), hace flooding: envía la trama por todos los demás puertos.

      A --1[ SWITCH ]2-- B          tabla al inicio: vacía
                  3                 1) A -> B : aprende A=puerto1,
                  |                    B desconocido: FLOOD (B y C la reciben)
                  C                 2) B -> A : aprende B=puerto2,
                                       A es conocido: solo el puerto 1

Los enlaces redundantes entre switches son buenos contra fallas, pero crean bucles (loops). Con un bucle, las tramas de flooding y de broadcast dan vueltas sin parar y se multiplican: una tormenta de broadcast que detiene la red. El protocolo spanning tree elige un switch raíz y mantiene activos solo los enlaces que forman un árbol (sin ciclos, por definición). Los demás enlaces quedan de respaldo.

Inalámbrico: CSMA/CA

En un cable, la estación puede escuchar mientras habla. Una radio no hace eso bien, así que el Wi-Fi (802.11) no puede detectar colisiones. Usa CSMA/CA (con evitación de colisiones): espera a que el medio esté libre, espera un retroceso aleatorio y solo entonces envía. Como el remitente no puede saber si hubo colisión, el receptor envía un ACK por cada trama, y la falta del ACK significa retransmitir.

La radio trae el problema de la terminal oculta. Lo que importa es la interferencia en el receptor, no en el remitente. Toma A y C, ambos al alcance de B pero demasiado lejos entre sí. A envía a B. C escucha, no oye nada (no oye a A) y también envía: las dos señales chocan en B. La solución es RTS/CTS: antes de enviar, el remitente pregunta (RTS) y el receptor responde (CTS). El CTS lo oyen los vecinos del receptor, que entonces se quedan callados.

   A ------- B ------- C       A y C no se oyen
   (alcance de A llega a B)    A -> B ...... C también -> B
                (alcance de C llega a B)
                               colisión en B, nadie lo nota

La capa de red: enrutamiento, direcciones IP y subredes

La capa de enlace es para vecinos. La capa de red une muchos enlaces y muchas redes y debe responder: ¿por qué camino debe ir este paquete para llegar a una máquina lejana? Existen dos servicios básicos. Una red de datagramas (sin conexión) trata cada paquete por separado: cada uno lleva la dirección de destino completa, y cada enrutador decide con su tabla en ese momento. Es simple y sobrevive a fallas; la confiabilidad se deja a la capa de transporte. Una red de circuitos virtuales (orientada a conexión) primero establece un camino y luego todos los paquetes lo siguen. Internet usa datagramas.

Enrutamiento: cómo encuentran el camino los enrutadores

Un enrutador tiene una tabla de enrutamiento. Para cada destino sabe cuál es el siguiente enrutador (o el siguiente enlace) a usar. Los algoritmos de enrutamiento construyen esas tablas.

Camino más corto (Dijkstra). Piensa en la red como pueblos unidos por caminos con costos. Dijkstra empieza en el origen y repite: toma el nodo aún no fijado con la menor distancia conocida, lo fija y actualiza las distancias de sus vecinos. El camino más barato puede tener más saltos que otro.

enlaces: A-B 1, A-C 4, B-C 2, C-D 1      origen = A
paso 1: fija A (0).  B = 1, C = 4
paso 2: fija B (1).  C = min(4, 1+2) = 3
paso 3: fija C (3).  D = 3+1 = 4
paso 4: fija D (4).  camino a D: A-B-C-D, costo 4

Vector de distancias (Bellman-Ford; RIP es un ejemplo): cada enrutador dice solo a sus vecinos a qué distancia cree que está de cada destino, y cada uno actualiza su tabla con lo que oye. Las buenas noticias viajan rápido. Las malas viajan despacio, y ese es el problema de la cuenta hasta el infinito. Ejemplo: A — B — C en línea. B llega a C en 1, A llega a C en 2. El enlace B–C se rompe. B oye de A 'llego a C en 2' (A no sabe que la ruta pasa por B), así que B piensa 'entonces llego a C en 3'. A oye el 3 de B y dice 4. Siguen subiendo los números, de uno en uno. RIP define 16 saltos como 'infinito' para detenerlo, y usa split horizon (no decirle a un vecino una ruta aprendida de él), a veces con poisoned reverse (decirle que esa ruta es infinita). Eso ayuda, pero aún pueden ocurrir bucles entre tres enrutadores.

Estado de enlace (OSPF es un ejemplo): cada enrutador descubre a sus vecinos, mide el costo de los enlaces y difunde esa información, en paquetes numerados, a todos. Todos los enrutadores obtienen el mismo mapa de la red y cada uno ejecuta Dijkstra por su cuenta. Converge rápido y no tiene cuenta hasta el infinito.

Entre organizaciones (BGP). Internet se divide en sistemas autónomos (AS): redes administradas por una organización. Dentro de un AS, un protocolo como OSPF encuentra el mejor camino. Entre AS el objetivo no es el camino más corto, sino un camino permitido por las reglas de cada organización (por ejemplo, no llevar gratis el tráfico de un competidor). BGP es un protocolo de vector de rutas: para cada destino anuncia la lista completa de AS en el camino. La lista permite a un enrutador ver un bucle de inmediato (ve su propio AS) y da los datos para las decisiones de política.

Congestión y calidad de servicio

La congestión ocurre cuando el tráfico de muchas fuentes, sumado, es mayor de lo que una parte de la red puede llevar. Los paquetes esperan en colas y se descartan. Es un problema global. El control de flujo es local a los dos extremos: impide que un remitente rápido ahogue a un receptor lento. Ambos dicen 'envía más despacio', pero por razones distintas.

Un token bucket (cubeta de fichas) da forma al tráfico. Las fichas caen en la cubeta a tasa R, hasta una capacidad B. Cada unidad enviada gasta una ficha. Después de un tiempo tranquilo la cubeta está llena, así que una ráfaga puede salir a la tasa pico M mientras haya fichas. La cubeta se vacía a M − R (las fichas siguen llegando). La ráfaga dura S = B / (M − R), luego la tasa baja a R.

B = 6 Mbit, R = 1 Mbps, pico M = 7 Mbps
S = B / (M - R) = 6 / (7 - 1) = 1 s
enviado en la ráfaga = M * S = 7 Mbit  (= B + R*S = 6 + 1)

Direcciones IPv4, máscaras y subredes

Una dirección IPv4 tiene 32 bits, escritos como cuatro números de 0 a 255 (por ejemplo 192.168.10.77). Tiene dos partes: los primeros bits nombran la red, el resto nombra al host dentro de ella. El prefijo /n dice que los primeros n bits son la red. La máscara es n unos seguidos de ceros. Aplicar un AND lógico de la dirección con la máscara borra los bits de host y da la dirección de red. Poner todos los bits de host en 1 da la dirección de broadcast. Con 32 − n bits de host hay 2^(32−n) direcciones, pero la primera (red) y la última (broadcast) están reservadas, así que hay 2^(32−n) − 2 hosts utilizables. Cada bit que se quita del prefijo duplica el bloque.

172.16.5.200/27   máscara 255.255.255.224   (tamaño del bloque 256-224 = 32)
200 está en el bloque 192..223 del último número
red       172.16.5.192
broadcast 172.16.5.223
hosts     172.16.5.193 .. 172.16.5.222   2^5 - 2 = 30 hosts

Para enviar, la máquina aplica su propia máscara al destino. Si el resultado es igual a su red, el destino está en el mismo enlace: la máquina obtiene la dirección MAC con ARP y envía directo. Si no, la trama va a la MAC del enrutador predeterminado (default gateway), pero el paquete IP conserva la dirección del destino final.

El ARP (protocolo de resolución de direcciones) une los dos tipos de dirección. La máquina pregunta a todos, por broadcast, '¿quién tiene esta dirección IP?', el dueño responde con su MAC, y la respuesta se guarda unos minutos en una caché.

Con CIDR, las tablas de enrutamiento guardan prefijos de cualquier longitud. Un destino puede coincidir con varios; el enrutador elige el prefijo coincidente más largo, el más específico. Los bloques contiguos pueden unirse (agregación) en un prefijo más corto que cubre exactamente las mismas direcciones, lo que mantiene pequeñas las tablas de Internet. Cuatro bloques /24 forman un /22 solo si son consecutivos y el primero empieza en un múltiplo de 4 en el tercer número.

rutas: 172.16.0.0/12 -> A,  172.16.8.0/21 -> B,  0.0.0.0/0 -> C
paquete a 172.16.9.1 : coincide /12 y /21  -> el más largo = /21 -> B
paquete a 172.20.1.1 : coincide solo /12   -> A
paquete a 8.8.8.8    : coincide solo /0    -> C (predeterminada)

agregación: 10.1.0.0/24 + 10.1.1.0/24 + 10.1.2.0/24 + 10.1.3.0/24 = 10.1.0.0/22

El paquete IPv4: TTL, fragmentos e ICMP

Las tablas de enrutamiento pueden estar equivocadas por un momento y mandar paquetes en círculos. El campo TTL (tiempo de vida) protege contra eso: el origen fija un número, cada enrutador resta uno y, cuando llega a cero, el paquete se tira y se avisa al origen. ICMP es el protocolo que usan los enrutadores para enviar esos avisos ('destino inalcanzable', 'tiempo excedido'). El comando ping se construye sobre él. Traceroute envía paquetes con TTL 1, 2, 3, ... y lee las respuestas de 'tiempo excedido' para descubrir cada enrutador del camino.

Todo enlace tiene una MTU, el paquete más grande que acepta. Si un paquete IPv4 es mayor, el enrutador lo rompe en fragmentos, cada uno con su encabezado. El campo offset dice dónde encajan los datos, contado en unidades de 8 bytes, y el bit MF (more fragments) dice si vienen más. Solo el destino vuelve a juntar las piezas.

paquete = 20 de encabezado + 2000 de datos, MTU = 1000
máx de datos por fragmento = 1000 - 20 = 980 -> usa 976 (múltiplo de 8)
fragmento 1: datos 976, offset 0,   MF = 1
fragmento 2: datos 976, offset 122, MF = 1   (976 / 8 = 122)
fragmento 3: datos  48, offset 244, MF = 0   (1952 / 8 = 244)

NAT e IPv6

No hay suficientes direcciones IPv4 (unos 4300 millones). El NAT (traducción de direcciones de red) permite que una casa o empresa entera use direcciones privadas (10.0.0.0/8, 172.16.0.0/12 y 192.168.0.0/16) y muestre una sola dirección pública a Internet. La caja de NAT usa números de puerto para distinguir las conversaciones, como una recepcionista que da una extensión a cada llamada. El costo es que los de afuera no pueden iniciar una conexión con una máquina de adentro, lo que rompe la vieja idea de que toda máquina puede alcanzarse desde cualquier lugar.

IPv6 es la solución de verdad: las direcciones tienen 128 bits, prácticamente infinitas. El encabezado se simplificó: tamaño fijo (40 bytes), sin checksum, y los enrutadores no fragmentan. Un enrutador que recibe un paquete demasiado grande para el siguiente enlace lo descarta y avisa al origen con un mensaje ICMPv6; el origen descubre la MTU más pequeña del camino y ajusta el tamaño de sus paquetes.

La capa de transporte: puertos, UDP y TCP

IP lleva un paquete a la máquina correcta, pero una máquina ejecuta muchos programas a la vez: un navegador, un juego, un reproductor de música. La capa de transporte entrega los datos al programa correcto y, cuando hace falta, vuelve confiable la entrega. Trabaja solo en los dos extremos; los enrutadores del medio no la miran.

Los programas se distinguen por números de puerto, números de 16 bits (0 a 65 535). El par (dirección IP, puerto) es un punto de comunicación, un socket. Algunos puertos son bien conocidos: 80 para HTTP, 443 para HTTPS, 53 para DNS, 25 para SMTP. Es como un edificio de apartamentos: la dirección IP es el edificio y el puerto es el apartamento.

UDP: el ligero

UDP no agrega casi nada a IP: puertos para llegar al programa correcto y un checksum para detectar datos dañados. No tiene conexión, ni confirmación, ni retransmisión, ni control de flujo. El encabezado es de solo 8 bytes. Es la herramienta correcta cuando el dato tardío no sirve, como en una llamada de voz o un juego: es mejor saltarse un pedazo perdido y seguir que parar a esperar una retransmisión. Las aplicaciones que necesitan confiabilidad sobre UDP deben construirla ellas mismas.

TCP: el confiable

TCP le da a la aplicación un flujo confiable de bytes, en el orden correcto. Numera los bytes, confirma lo que llega, reenvía lo que se pierde y reduce la velocidad cuando el receptor o la red están sobrecargados.

Abrir una conexión: el handshake de tres vías. Cada lado elige un número de secuencia inicial y necesita que el otro lado lo confirme. Primero el cliente envía SYN con su número. Luego el servidor responde SYN+ACK: confirma el número del cliente y envía el suyo, en un solo segmento. Por último el cliente envía un ACK. Tres segmentos bastan. El tercero tiene un propósito más profundo: las redes pueden retrasar y duplicar paquetes, así que un SYN viejo puede llegar mucho después. El servidor solo no sabe si es nuevo. El ACK final, que confirma un número que el servidor eligió hace un momento, prueba que el cliente realmente está participando.

Cliente                       Servidor
  |---- SYN, seq=x ---------->|
  |<--- SYN+ACK, seq=y, ack=x+1|
  |---- ACK, ack=y+1 -------->|
  |        (fluyen datos)      |
  |---- FIN ----------------->|   cerrando:
  |<--- ACK ------------------|   cada sentido
  |<--- FIN ------------------|   se cierra
  |---- ACK ----------------->|   por separado

Números y confirmaciones. TCP numera cada byte. El número de secuencia de un segmento es el número de su primer byte. El número de confirmación es el número del siguiente byte esperado, y es acumulativo: confirma todo lo anterior. Así que si un segmento tiene número de secuencia s y n bytes de datos, cubre los bytes s a s + n − 1 y el ACK es s + n. Ejemplo: s = 4000, n = 300 da ACK 4300. Un ACK perdido suele repararse con el siguiente ACK, mayor.

El control de flujo protege al receptor. En cada segmento anuncia el espacio libre de su buffer, la ventana de recepción. Si la aplicación lee despacio, la ventana se encoge, incluso hasta cero, y el remitente debe reducir el ritmo. El control de congestión protege la red, y el remitente lo estima, en una segunda ventana llamada ventana de congestión (cwnd). El remitente puede tener en tránsito, como máximo, min(cwnd, ventana de recepción) bytes sin confirmar.

El control de congestión tiene estas ideas (la unidad es el MSS, el tamaño máximo de segmento):

• Slow start: empieza con cwnd = 1 MSS. Cada ACK suma 1 MSS, así que la ventana se duplica cada RTT: 1, 2, 4, 8, 16. Es exponencial, a pesar del nombre. Sigue hasta que cwnd llega al umbral ssthresh.
• Congestion avoidance (evitación de congestión): por encima de ssthresh, crece solo 1 MSS por RTT (aumento aditivo), con cuidado.
• Timeout (congestión seria, ni siquiera vuelven los ACK): ssthresh = la mitad de la ventana actual, cwnd = 1 MSS y slow start otra vez.
• Tres ACK duplicados: el receptor sigue repitiendo el último ACK en orden cuando llegan segmentos posteriores. Uno o dos pueden ser solo reordenamiento, tres indican una pérdida. El fast retransmit reenvía el segmento faltante sin esperar el temporizador. En TCP Reno, la fast recovery luego pone ssthresh y cwnd a la mitad y sigue creciendo 1 MSS por RTT.

cwnd
 20|        /|
 16|      /  |
 12|    /    |        /|
 10|  /      |      /  |    +1 MSS por RTT,
  8|/        |    /    |    la mitad en cada pérdida
  6|         |  /
  4|         |/
   +--------------------------> tiempo

¿Cuánto esperar? El timeout. Si el temporizador es demasiado corto, TCP reenvía por gusto. Si es demasiado largo, la recuperación de pérdidas es lenta. Por eso TCP sigue el retardo real con un promedio móvil: SRTT = α·SRTT + (1 − α)·R, con α = 7/8, donde R es la medición más reciente. El valor antiguo pesa mucho, cada muestra nueva pesa poco. Ejemplo: SRTT = 60 ms y R = 100 ms dan 7/8 × 60 + 1/8 × 100 = 52,5 + 12,5 = 65 ms. El timeout es el SRTT más un margen de seguridad basado en la variación.

El algoritmo de Nagle combate los segmentos diminutos. Mientras haya datos enviados aún sin confirmar, las escrituras pequeñas esperan en un buffer hasta que llegue el ACK o esté listo un segmento completo. Se adapta solo a la red. Las aplicaciones interactivas que odian esperar, como los juegos, lo desactivan.

Cerrar. El lado que cierra primero envía el último ACK y luego espera en el estado TIME_WAIT el doble del tiempo máximo de vida de un segmento. Si ese último ACK se perdió, el otro lado enviará su FIN de nuevo, y alguien tiene que seguir ahí para responder. Esto también deja que los segmentos duplicados viejos de esa conexión mueran en la red antes de reutilizar el mismo par de puertos.

La capa de aplicación: DNS, correo, la Web y streaming

El piso de arriba es lo que la gente realmente usa. Los programas aquí siguen protocolos que corren sobre TCP o UDP. Veremos cómo los nombres se vuelven direcciones, cómo viaja el correo, cómo funciona la Web y cómo los videos y los sitios populares te llegan rápido.

DNS: la guía telefónica de Internet

A la gente le gustan los nombres (www.example.com). La red entiende solo direcciones numéricas. El DNS (sistema de nombres de dominio) traduce de uno al otro. Ninguna máquina lo sabe todo, así que los nombres forman un árbol: la raíz, luego los dominios de nivel superior (.com, .org, .br), luego los nombres de abajo. Cada parte del árbol es una zona, administrada por su propio responsable, con un servidor autoritativo que tiene la última palabra sobre ella.

              . (raíz)
           /     |     \
        .com   .org    .br          dominios de nivel superior
         |
    example.com                      una zona
         |
  www.example.com                    un nombre

Tu computadora pregunta a un resolvedor local (normalmente de tu proveedor). Si el resolvedor no sabe, pregunta a la jerarquía con consultas iterativas: cada servidor responde con lo que sabe, la respuesta final o una referencia a quién preguntar después. Para www.example.com con la caché vacía, el orden es: un servidor raíz (apunta al .com), luego un servidor del .com (apunta al servidor autoritativo de example.com) y, por último, el servidor autoritativo (da la dirección). En la práctica, la caché evita casi todos los viajes a la raíz y a los servidores de nivel superior.

Toda respuesta tiene un TTL (tiempo de vida): durante cuántos segundos puede reutilizarse sin volver a preguntar. Un TTL alto significa menos carga y respuestas más rápidas, pero los cambios se propagan despacio. Un TTL bajo es lo contrario. Si una dirección con TTL 300 está en caché en el instante 0 y el administrador la cambia a los 100 s, los clientes detrás de esa caché siguen con la dirección vieja hasta los 300 s. Por eso se baja el TTL días antes de mover un servicio.

Correo electrónico

El correo hace dos trabajos separados. SMTP empuja (push) un mensaje del remitente al servidor del destinatario. Luego el usuario lee el buzón con un protocolo de acceso, IMAP o POP3, que lo jala (pull). Para saber a dónde enviar un mensaje para ana@example.org, el servidor de envío pregunta al DNS por los registros MX de example.org: nombran los servidores de correo del dominio, en orden de preferencia. La parte después de la @ es un dominio, no el nombre de una máquina.

La Web y HTTP

HTTP es un protocolo de petición y respuesta. El navegador envía una petición ('GET de esta página') y el servidor responde con un código y el contenido. HTTP es sin estado (stateless): cada petición se trata por separado, sin memoria de la anterior. Una cookie agrega memoria: el servidor pide al navegador que guarde un texto pequeño y lo devuelva en cada petición. Normalmente la cookie guarda solo un identificador de sesión, y los datos reales se quedan en el servidor.

Contar idas y vueltas. Convención: abrir una conexión TCP cuesta 1 RTT (el handshake), y cada petición con su respuesta cuesta 1 RTT (el tiempo de enviar los datos en sí se ignora). Con HTTP no persistente, cada objeto necesita una conexión nueva, así que 2 RTT cada uno. Con HTTP persistente, se reutiliza la misma conexión: 1 RTT para el handshake y luego 1 RTT por objeto. Una página con 1 archivo HTML y N imágenes, sin conexiones en paralelo: no persistente 2(N + 1) RTT, persistente 2 + N RTT. Con N = 4: 10 contra 6.

La caché HTTP funciona en dos fases. Mientras la copia guardada está dentro de su vida útil (el max-age del encabezado Cache-Control), el navegador la usa sin preguntar al servidor. Después de eso, hace una petición condicional, enviando el validador que recibió (ETag o Last-Modified). Si nada cambió, el servidor responde 304 Not Modified sin cuerpo, ahorrando la transferencia. Ejemplo: max-age=60 y ETag, y la página se necesita otra vez después de 90 s: se hace una petición condicional.

Entrega de contenido y streaming

Una CDN (red de entrega de contenido) mantiene copias del contenido en muchos lugares del mundo. El truco más común para llevarte a la copia más cercana está en el DNS: el servidor DNS de la CDN devuelve una dirección distinta según el lugar de donde viene la pregunta. El contenido viaja menos, el retardo baja y la carga se reparte.

El video y el audio se reproducen a un ritmo fijo, pero llegan con retardo variable. El reproductor guarda unos segundos en un búfer de reproducción (playout buffer): se llena cuando la red es rápida y se vacía cuando es lenta. El precio es un pequeño retardo al inicio, aceptable para un video grabado, pero malo para una llamada en vivo, que necesita un búfer muy pequeño.

Seguridad de redes

Los mensajes cruzan máquinas de desconocidos. La seguridad pregunta: ¿alguien puede leerlo? ¿Alguien puede cambiarlo? ¿Estoy hablando de verdad con quien creo? Tres propiedades distintas responden estas preguntas, y cada una necesita su propio mecanismo.

Claves simétricas y asimétricas

En la criptografía simétrica, los dos lados comparten la misma clave secreta. Es rápida, pero ¿cómo ponerse de acuerdo en la clave sin que un espía escuche? La criptografía asimétrica (de clave pública) lo resuelve: cada persona tiene un par de claves, una clave pública que todos pueden conocer y una clave privada que se mantiene en secreto. Lo que una clave cierra, solo la otra lo abre. Para enviar un secreto a Bob, cierras con la clave pública de Bob, y solo la clave privada de Bob lo abre.

Hashes y firmas

Una función hash criptográfica (SHA-256 es una) convierte un mensaje de cualquier tamaño en un resumen (digest) corto, de tamaño fijo, como una huella digital. Debe ser fácil de calcular, prácticamente imposible de invertir y resistente a colisiones (muy difícil encontrar dos mensajes con el mismo resumen). Cambiar una letra cambia el resumen por completo.

Una firma digital usa el par de claves al revés: firmas con tu clave privada y todos verifican con tu clave pública. Da autoría, integridad y no repudio (no puedes negarlo). En la práctica se firma el resumen del mensaje, no el mensaje completo, porque es mucho más corto.

Un MAC (código de autenticación de mensajes) es como una firma hecha con una clave secreta compartida: prueba que el mensaje no fue cambiado y que viene de alguien que tiene la clave.

Certificados y confianza

Los trucos de clave pública solo funcionan si la clave pública que recibiste realmente pertenece a quien dice ser su dueño. Si no, un hombre en el medio podría darte su propia clave. Un certificado lo arregla: un tercero de confianza, la autoridad certificadora (CA), firma una declaración 'esta clave pertenece a este nombre'. Tu navegador verifica la firma siguiendo una cadena de certificados hasta una CA raíz en la que ya confía. El certificado atestigua el vínculo entre una identidad y una clave pública, nada más.

Probar quién eres: desafío y respuesta

¿Cómo probar que conoces un secreto sin enviarlo? En el desafío-respuesta, el verificador envía un valor y el otro lado devuelve ese valor transformado con el secreto. Si el desafío fuera siempre el mismo, un atacante podría grabar una respuesta buena y reproducirla otra vez (un replay). Por eso el verificador envía un número aleatorio nuevo, un nonce (número usado una vez), cada vez. Una respuesta vieja no sirve para un desafío nuevo.

Protocolos como TLS (el candado del navegador) e IPsec combinan estas piezas. Las claves públicas y los certificados permiten que los dos lados acuerden una clave y sepan quién es el otro. Luego el cifrado simétrico rápido protege los datos, y un MAC en cada mensaje detecta cualquier cambio antes de usar los datos.

Juntando todo

Sigamos un clic: escribes www.example.com en el navegador. Cada capa hace su pequeño trabajo, en orden.

1. Aplicación (DNS): el navegador pregunta al resolvedor la dirección de www.example.com. La caché o el árbol DNS responde con una dirección IP.
2. Red (ARP): la dirección está fuera de tu subred, así que tu máquina obtiene la dirección MAC del enrutador predeterminado con ARP.
3. Transporte (TCP): un handshake de tres vías abre una conexión al puerto 443 u 80.
4. Aplicación (HTTP): sale la petición y vuelve la respuesta, con un código de estado.
5. Red, enlace y física: cada paquete cruza enrutadores (prefijo más largo, TTL bajando), cada salto es una trama con nuevas direcciones MAC, y los bits son señales en cables, fibra o radio.

Algunos errores se repiten una y otra vez en los exámenes y en la vida real. Revisa esta lista antes de responder.

• Mezclar ancho de banda (cuánto por segundo) con latencia (cuánto tarda).
• Olvidar que los hosts utilizables de una subred son 2^(32−n) − 2.
• Mezclar la dirección MAC (un solo enlace) con la dirección IP (extremo a extremo).
• Pensar que la ventana de recepción y la ventana de congestión son lo mismo.
• Pensar que el slow start es lento: se duplica cada RTT.
• Usar todo el espacio de secuencia como ventana en selective repeat: el límite es la mitad.
• Creer que solo cifrar protege contra cambios en el mensaje.