IP, direcciones y puertos

01 · De la red local a la red de redes

Una dirección que dice dónde

La dirección MAC de una placa de red es como el número de serie de un electrodoméstico: identifica el aparato, pero no dice dónde está. Si Internet usara MAC, cada router del mundo tendría que conocer la ubicación de miles de millones de aparatos. Por eso existe una segunda dirección, la dirección IP, que se asigna según la red a la que el equipo está conectado: como una dirección postal, tiene una parte que identifica la calle (la red) y otra que identifica la casa (el equipo). Un router no necesita saber dónde está cada equipo, sino solo hacia dónde queda cada red.

IP (Internet Protocol) es la capa de internet del modelo TCP/IP (tema 29). Hace tres cosas:

• Direcciona: cada paquete lleva la dirección IP de origen y de destino.
• Enruta: los routers reenvían cada paquete, red por red, hacia el destino, consultando una tabla de rutas.
• No garantiza nada más: IP entrega «lo mejor que pueda» (best effort). Un paquete puede perderse, duplicarse, llegar desordenado o demorado. La confiabilidad, si hace falta, la agrega TCP (tema 31).

La versión que se usa en casi todas las redes locales y en la mayoría de los dispositivos embebidos es la 4 (IPv4), con direcciones de 32 bits. La versión 6 (IPv6), con direcciones de 128 bits, la reemplaza de a poco y se resume en la sección 09.

02 · 32 bits

La dirección IPv4 y su encabezado

Una dirección IPv4 es un número de 32 bits. Para leerla se divide en cuatro bytes y cada uno se escribe en decimal, separados por puntos: 192.168.1.50 es 11000000.10101000.00000001.00110010. Hay unos 4300 millones de direcciones posibles, y esa cantidad se agotó: de ahí vienen las direcciones privadas con NAT (sección 08) y el pasaje a IPv6.

Un paquete IP lleva un encabezado de al menos 20 bytes, seguido de los datos de la capa de transporte:

• Versión (4 bits) e IHL (4 bits). La versión es 4. El IHL es el largo del encabezado en palabras de 32 bits: normalmente 5 (20 bytes). El primer byte es entonces 0x45.
• Tipo de servicio (1 byte). Marcas de prioridad y de congestión.
• Largo total (2 bytes). El paquete entero, encabezado y datos, hasta 65 535 bytes (en la práctica, no más que el MTU de 1500 bytes de Ethernet sin fragmentar).
• Identificación, indicadores y desplazamiento de fragmento. Permiten partir un paquete que no cabe en un enlace (fragmentación) y rearmarlo en el destino. El indicador DF («no fragmentar») le pide a los routers que lo descarten antes de partirlo.
• TTL (Time To Live, 1 byte). Cada router lo baja en uno; si llega a cero, descarta el paquete y avisa al origen. Evita que un paquete dé vueltas para siempre si hay un bucle de rutas. Los valores iniciales típicos son 64, 128 y 255.
• Protocolo (1 byte). Qué hay dentro: 6 es TCP, 17 es UDP, 1 es ICMP.
• Suma de comprobación del encabezado (2 bytes). Una verificación liviana, solo del encabezado.
• Dirección de origen y de destino (4 bytes cada una).

La suma de comprobación es una versión simple de lo que vimos en las capas inferiores: se suman todas las palabras de 16 bits del encabezado (con el campo del checksum en cero), se «pliega» el acarreo sumándolo al resultado y se invierte. El receptor suma todo el encabezado, incluido el checksum, y debe obtener cero tras invertir. Cada router la recalcula porque cambia el TTL. A diferencia del CRC de Ethernet, no protege los datos: de eso se encargan el CRC de la trama y el checksum de TCP o UDP.

El protocolo ICMP (Internet Control Message Protocol) viaja dentro de paquetes IP y transporta mensajes de control y de error. El más conocido es el que usa el comando ping: «petición de eco» (tipo 8) y «respuesta de eco» (tipo 0), para comprobar si un equipo responde. También informa «tiempo excedido» (TTL llegó a cero, que es la base de traceroute) y «destino inalcanzable».

03 · Red y equipo

Máscara de red y subredes

Una dirección IP tiene dos partes: los primeros bits identifican la red y los restantes, el equipo dentro de ella. Cuántos bits corresponden a cada parte lo dice la máscara de red: un número de 32 bits que tiene unos en la parte de red y ceros en la de equipo. Se escribe como una dirección (255.255.255.0) o, más corto, como un prefijo con la cantidad de unos: /24. Esta notación (192.168.1.50/24) se llama CIDR (Classless Inter-Domain Routing).

Con la dirección y la máscara se calculan, con operaciones bit a bit:

• Dirección de red = dirección AND máscara. Pone en cero los bits de equipo: 192.168.1.0.
• Dirección de difusión = dirección de red OR (NOT máscara). Pone en uno los bits de equipo: 192.168.1.255. Un paquete enviado ahí llega a todos los equipos de la red.
• Equipos utilizables = 2^{(32 − prefijo)} − 2: se restan la dirección de red y la de difusión, que no se pueden asignar. Una red /24 tiene 254 equipos, de 192.168.1.1 a 192.168.1.254.

Una subred se obtiene tomando prestados bits de la parte de equipo para ampliar la parte de red: cada bit que se toma duplica el número de subredes y divide por dos el de equipos. Para dividir 192.168.10.0/24 en cuatro subredes hacen falta 2 bits: el prefijo pasa a /26, cada subred tiene 64 direcciones (62 utilizables) y las subredes empiezan en 192.168.10.0, .64, .128 y .192. Las subredes sirven para ordenar una instalación (una por sector, una para cámaras, otra para sensores), para limitar el tráfico de difusión y para aplicar reglas de seguridad entre ellas, porque pasar de una a otra requiere un router.

Antes de CIDR se hablaba de «clases» (A, B y C, con máscaras fijas /8, /16 y /24). Hoy el prefijo es libre y las clases ya no se usan, aunque sus nombres sobreviven en los manuales.

04 · Rangos con significado propio

Direcciones privadas y especiales

No todas las direcciones se pueden usar en Internet. Algunos rangos tienen un significado reservado:

En una red de dispositivos embebidos casi siempre se trabaja con las privadas, en especial 192.168.x.0/24 (la más común en redes domésticas y pequeñas) y 10.x.x.x (redes mayores). Una ventaja de las privadas es que nadie desde Internet puede alcanzar un dispositivo con una dirección así sin que el router lo permita explícitamente (sección 08), lo que es una barrera de seguridad útil, aunque no suficiente.

05 · Salir de la red local

Puerta de enlace, ARP y enrutamiento

Cuando un equipo quiere enviar un paquete, hace una sola pregunta: ¿el destino está en mi misma red? Lo averigua con su propia dirección y máscara: compara (destino AND máscara) con (mi dirección AND máscara).

• Si coinciden, el destino está en la misma red y la entrega es directa: el equipo averigua la MAC del destino y le envía la trama.
• Si no coinciden, el equipo no puede alcanzarlo directamente. Entrega el paquete a la puerta de enlace (gateway, normalmente el router), con una dirección IP que sí está en su red. El router se encarga de seguir el camino.

En ambos casos la trama Ethernet lleva la MAC del siguiente salto, y el paquete IP lleva la IP del destino final. Cada router que atraviesa el paquete cambia las MAC (origen y destino) por las del siguiente enlace, y baja el TTL; la IP no cambia (salvo con NAT).

Para averiguar la MAC que corresponde a una IP del segmento local se usa ARP (Address Resolution Protocol, EtherType 0x0806). El equipo envía por difusión: «¿quién tiene la IP 192.168.1.1? Contesten a 192.168.1.50». El dueño de esa IP responde, por unicast, con su MAC. El resultado se guarda un tiempo en una tabla ARP para no preguntar cada vez (se ve con arp -a). ARP no tiene autenticación: cualquiera puede responder, y es la base de algunos ataques en redes locales.

Un equipo sencillo necesita entonces cuatro datos para comunicarse más allá de su red: dirección IP, máscara, puerta de enlace y servidor DNS. Si falta la puerta de enlace, el equipo solo puede hablar con la red local; si la máscara está mal, decide mal qué está «cerca» y qué «lejos»; un error frecuente es poner una puerta de enlace fuera de la red del equipo, cosa imposible de alcanzar.

Los routers deciden con una tabla de rutas: una lista de redes destino (con prefijo) y el siguiente salto para cada una. Se elige la ruta más específica (el prefijo más largo) que contenga al destino; la ruta 0.0.0.0/0 es la ruta por omisión, que lleva todo lo que no coincide con otra. En una red doméstica, el router de acceso tiene una ruta por omisión hacia el proveedor.

06 · Que lo haga la red

DHCP: configuración automática

Configurar a mano la IP, la máscara, la puerta de enlace y el DNS de cada equipo no escala, y es fuente de errores (direcciones repetidas). DHCP (Dynamic Host Configuration Protocol) hace que un servidor, normalmente el router, entregue esa configuración al conectarse. Funciona sobre UDP con los puertos 67 (servidor) y 68 (cliente) y se hace en cuatro mensajes, que se recuerdan como DORA:

1. Discover. El cliente, que todavía no tiene dirección, envía por difusión («¿hay algún servidor DHCP?») desde 0.0.0.0 a 255.255.255.255.
2. Offer. Un servidor responde con una oferta: una dirección libre y la configuración que la acompaña.
3. Request. El cliente pide formalmente esa dirección (también por difusión, para que los demás servidores sepan que su oferta no se aceptó).
4. Acknowledge. El servidor confirma. El cliente configura la interfaz.

La respuesta incluye la máscara, la puerta de enlace, los servidores DNS y el tiempo de concesión (lease): la dirección se «presta» por un tiempo (de minutos a días). A la mitad del plazo el cliente intenta renovarla con el mismo servidor; si no puede, a las 7/8 prueba con cualquiera; si vence sin renovar, debe dejar de usar la dirección. Eso permite reutilizar direcciones de equipos que se fueron.

En dispositivos que tienen que ser encontrados siempre en la misma dirección (una cámara, un servidor, un PLC) hay dos opciones: configurarles una dirección fija fuera del rango que reparte el servidor, o dejar que usen DHCP y pedir al router una reserva (siempre la misma IP para una MAC dada). Es lo mejor de ambos mundos: la configuración queda centralizada. Cuando un equipo no consigue respuesta de ningún servidor DHCP, muchos sistemas se asignan una dirección 169.254.x.y de enlace local, que solo sirve para hablar con equipos de la misma red.

07 · Nombres para personas

DNS: nombres en lugar de números

Las personas recuerdan nombres, no números. DNS (Domain Name System) es el sistema que traduce un nombre como www.ejemplo.com en una dirección IP. Es una base de datos distribuida y jerárquica: la raíz delega los dominios de primer nivel (.com, .ar), estos delegan cada dominio a sus propios servidores, y cada uno responde por sus nombres.

Un equipo no recorre la jerarquía: le pregunta a un resolvedor (el servidor DNS que le dio DHCP, normalmente el router o el del proveedor), y este hace el trabajo y guarda las respuestas en una memoria de consulta (caché) durante un tiempo que el dominio fija (el TTL de la respuesta). Una consulta típica es un datagrama UDP al puerto 53: una pregunta chica y una respuesta chica (si es muy grande, se repite por TCP).

El mensaje DNS empieza con un encabezado de 12 bytes (identificador, indicadores y cuatro contadores) y sigue con las preguntas. El nombre se codifica como una secuencia de etiquetas, cada una precedida por su largo, y terminada con un byte cero: example.com es 07 'example' 03 'com' 00. Después van el tipo (A para una dirección IPv4, AAAA para IPv6, CNAME para un alias, MX para el correo, TXT para texto) y la clase (IN, Internet). Una consulta de tipo A para example.com mide 29 bytes (12 + 13 + 4).

Para un dispositivo embebido, DNS implica dos cosas prácticas. Primero, si se conecta a un servicio por nombre (un servidor MQTT en la nube, un servicio de hora), el programa tiene que resolverlo antes de abrir la conexión, y hay que contemplar que la resolución falle o tarde; guardar la dirección IP «a fuego» en el código evita el DNS, pero se rompe cuando el servicio cambia de dirección. Segundo, en una red local pequeña, los nombres de los dispositivos pueden resolverse con mDNS (nombres del tipo sensor.local, por multicast, sin servidor): el ESP32 y muchos equipos lo soportan.

08 · Muchos programas, una dirección

Puertos y NAT

Una dirección IP identifica un equipo. Pero en un equipo corren varios programas a la vez: un servidor web, un cliente MQTT, un reloj sincronizado por NTP. Para entregar cada paquete al programa que corresponde, la capa de transporte (TCP o UDP, tema 31) agrega un puerto: un número de 16 bits (0 a 65 535). Un programa que atiende pedidos «escucha» en un puerto; uno que inicia una conexión recibe del sistema un puerto de origen al azar.

Los puertos de 0 a 1023 son los «bien conocidos», asignados a los servicios estándar; los de 1024 a 49 151 son «registrados» para aplicaciones; los de 49 152 a 65 535 son dinámicos o efímeros, que el sistema reparte a los clientes. Una conexión queda identificada por cinco datos: protocolo, IP y puerto de origen, IP y puerto de destino. Eso es un socket en cada extremo (tema 31). Por ejemplo, TCP 192.168.1.50:50035 → 192.168.1.10:1883 es un cliente conectado a un servidor MQTT.

Con los puertos se entiende NAT (Network Address Translation). Una casa o una planta tiene decenas de dispositivos con direcciones privadas, pero una sola dirección pública. El router traduce: cuando un equipo interno abre una conexión hacia afuera, reemplaza su IP y puerto de origen por la IP pública y un puerto propio, y anota la correspondencia en una tabla; cuando vuelve la respuesta, hace la traducción inversa. Esto permite que muchos equipos compartan una dirección, y tiene dos consecuencias: los dispositivos internos pueden iniciar conexiones hacia afuera sin problema, pero nadie desde afuera puede iniciar una conexión hacia un dispositivo interno si el router no tiene una regla de redirección de puertos (port forwarding). Por eso los dispositivos IoT suelen abrir ellos mismos una conexión saliente hacia un servidor en la nube (MQTT, tema 32) y por ahí reciben los comandos.

09 · El sucesor

IPv6 en pocas palabras

IPv6 se creó porque IPv4 se quedó sin direcciones. Las diferencias principales:

• Direcciones de 128 bits, escritas como ocho grupos de cuatro dígitos hexadecimales separados por dos puntos: 2001:0db8:0000:0000:0000:0000:0000:0001, que se abrevia quitando ceros a la izquierda y reemplazando una cadena de grupos en cero por ::: 2001:db8::1.
• Subredes de 64 bits (/64) para casi todos los segmentos: 64 bits de red y 64 de equipo, por lo que ya no se cuentan los equipos.
• Encabezado fijo de 40 bytes, sin checksum ni fragmentación en los routers.
• Sin difusión: se reemplaza por multicast. ARP se reemplaza por el descubrimiento de vecinos (parte de ICMPv6).
• Autoconfiguración: un equipo puede armar su propia dirección a partir del prefijo que anuncia el router (SLAAC) y tiene siempre una dirección de enlace local que empieza con fe80::. DHCPv6 también existe.

Casi todo lo que vimos (máscaras con prefijo, puerta de enlace, DNS con registros AAAA, puertos) funciona igual. En un dispositivo embebido, IPv6 tiene un costo de memoria y de código, y la mayoría de las redes locales y los servicios de IoT siguen funcionando bien con IPv4 solo. Conviene conocerlo y no sorprenderse al verlo.

10 · Con el microcontrolador

Con el microcontrolador

El primer programa pide su configuración por DHCP (con el módulo W5500 del tema 29), muestra los cuatro datos que recibió y resuelve un nombre con DNS. Las tres líneas del medio son lo que cualquier equipo necesita para hablar con el mundo:

#include <SPI.h>
#include <Ethernet.h>
#include <Dns.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };    // cambiar el último byte en cada placa
const int PIN_CS = 10;

void mostrar(const char *nombre, IPAddress ip) {
    Serial.print(nombre); Serial.print(": "); Serial.println(ip);
}

void setup() {
    Serial.begin(115200);
    Ethernet.init(PIN_CS);
    Serial.println("Pidiendo la configuración por DHCP...");
    if (Ethernet.begin(mac, 10000) == 0) {               // espera hasta 10 segundos una respuesta
        Serial.println("No hubo respuesta de ningún servidor DHCP");
        while (true) delay(1000);
    }
    mostrar("IP",               Ethernet.localIP());
    mostrar("Máscara",          Ethernet.subnetMask());
    mostrar("Puerta de enlace", Ethernet.gatewayIP());
    mostrar("DNS",              Ethernet.dnsServerIP());

    DNSClient dns;
    dns.begin(Ethernet.dnsServerIP());                   // le pregunta al servidor que dio DHCP
    IPAddress resultado;
    if (dns.getHostByName("example.com", resultado) == 1) mostrar("example.com", resultado);
    else Serial.println("No se pudo resolver el nombre");
}

void loop() {
    Ethernet.maintain();                                 // renueva la concesión DHCP cuando corresponde
}

Si ves 169.254.x.y o el programa no obtiene respuesta, no hay un servidor DHCP alcanzable. El segundo programa reproduce las cuentas de esta lección sin ninguna biblioteca: calcula la red y la difusión, decide si dos equipos están en la misma red y calcula el checksum de un encabezado IPv4. Los resultados se verifican con el modelo de Python de la sección 11.

uint32_t aEntero(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
    return ((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | d;
}

uint32_t mascara(uint8_t prefijo) {
    return prefijo == 0 ? 0 : 0xFFFFFFFFUL << (32 - prefijo);
}

bool mismaRed(uint32_t x, uint32_t y, uint8_t prefijo) {
    uint32_t m = mascara(prefijo);
    return (x & m) == (y & m);
}

void imprimirIp(uint32_t ip) {
    Serial.print(ip >> 24); Serial.print('.'); Serial.print((ip >> 16) & 255); Serial.print('.');
    Serial.print((ip >> 8) & 255); Serial.print('.'); Serial.print(ip & 255);
}

uint16_t checksumIp(const uint8_t *datos, size_t n) {
    uint32_t suma = 0;
    for (size_t i = 0; i < n; i += 2) suma += ((uint32_t)datos[i] << 8) | datos[i + 1];
    while (suma > 0xFFFF) suma = (suma & 0xFFFF) + (suma >> 16);       // se suma el acarreo
    return (uint16_t)~suma;
}

void setup() {
    Serial.begin(115200);
    uint32_t ip = aEntero(192, 168, 1, 50);
    uint32_t red = ip & mascara(24);
    uint32_t difusion = red | ~mascara(24);
    Serial.print("Red: ");      imprimirIp(red);      Serial.println();             // 192.168.1.0
    Serial.print("Difusión: "); imprimirIp(difusion); Serial.println();             // 192.168.1.255
    Serial.print("¿Misma red que 192.168.1.200? "); Serial.println(mismaRed(ip, aEntero(192, 168, 1, 200), 24));   // 1
    Serial.print("¿Misma red que 192.168.2.10? ");  Serial.println(mismaRed(ip, aEntero(192, 168, 2, 10), 24));    // 0

    uint8_t cabecera[20] = { 0x45, 0x00, 0x00, 0x30, 0x12, 0x34, 0x40, 0x00, 0x40, 0x11, 0x00, 0x00,
                             192, 168, 1, 50, 192, 168, 1, 1 };
    uint16_t suma = checksumIp(cabecera, 20);
    Serial.print("Checksum: 0x"); Serial.println(suma, HEX);                         // A505
    cabecera[10] = suma >> 8; cabecera[11] = suma & 0xFF;
    Serial.print("Verificación (debe ser 0): "); Serial.println(checksumIp(cabecera, 20));
}

void loop() {}

11 · Analogía con programación

IP en Python

Todo lo que hace una máscara es aritmética de enteros y operaciones bit a bit. El modelo siguiente convierte direcciones, calcula la red, la difusión y los equipos de una subred, decide si dos equipos están en la misma red, divide una red en subredes (con el módulo estándar ipaddress como contraste), arma un encabezado IPv4 con su checksum y construye a mano una consulta DNS.

import ipaddress


def a_entero(ip):
    a, b, c, d = (int(x) for x in ip.split("."))
    return (a << 24) | (b << 16) | (c << 8) | d


def a_texto(n):
    return ".".join(str((n >> s) & 255) for s in (24, 16, 8, 0))


def mascara(prefijo):
    return (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF


def subred(ip, prefijo):
    m = mascara(prefijo)
    red = a_entero(ip) & m
    difusion = red | (~m & 0xFFFFFFFF)
    hosts = 2 ** (32 - prefijo) - 2 if prefijo <= 30 else (2 if prefijo == 31 else 1)
    return a_texto(m), a_texto(red), a_texto(difusion), hosts


def misma_red(a, b, prefijo):
    m = mascara(prefijo)
    return a_entero(a) & m == a_entero(b) & m


def checksum(datos):
    suma = 0
    for i in range(0, len(datos), 2):
        suma += (datos[i] << 8) | datos[i + 1]
    while suma > 0xFFFF:
        suma = (suma & 0xFFFF) + (suma >> 16)
    return ~suma & 0xFFFF


def cabecera_ipv4(origen, destino, protocolo, largo_datos, ttl=64):
    cab = bytearray(20)
    cab[0] = 0x45                                             # versión 4, 5 palabras de 32 bits
    cab[2:4] = (20 + largo_datos).to_bytes(2, "big")
    cab[4:6] = (0x1234).to_bytes(2, "big")                    # identificación
    cab[6:8] = (0x4000).to_bytes(2, "big")                    # no fragmentar
    cab[8], cab[9] = ttl, protocolo
    cab[12:16] = a_entero(origen).to_bytes(4, "big")
    cab[16:20] = a_entero(destino).to_bytes(4, "big")
    cab[10:12] = checksum(cab).to_bytes(2, "big")
    return bytes(cab)


def consulta_dns(nombre, tipo=1):
    cab = (0x1234).to_bytes(2, "big") + (0x0100).to_bytes(2, "big") + (1).to_bytes(2, "big") + bytes(6)
    etiquetas = b"".join(bytes([len(e)]) + e.encode() for e in nombre.split(".")) + b"\x00"
    return cab + etiquetas + tipo.to_bytes(2, "big") + (1).to_bytes(2, "big")


print("192.168.1.50/24 ->", subred("192.168.1.50", 24))
print("10.0.0.77/20    ->", subred("10.0.0.77", 20))
print("coincide con ipaddress:", ipaddress.ip_network("10.0.0.77/20", strict=False))
print("192.168.1.50 y 192.168.1.200 con /24, misma red:", misma_red("192.168.1.50", "192.168.1.200", 24))
print("192.168.1.50 y 192.168.2.10 con /24, misma red:", misma_red("192.168.1.50", "192.168.2.10", 24))
print("192.168.1.50 y 192.168.0.10 con /23, misma red:", misma_red("192.168.1.50", "192.168.0.10", 23))

print("Hosts por prefijo:", {p: (2 ** (32 - p) - 2) for p in (24, 26, 28, 30)})
nueva = ipaddress.ip_network("192.168.10.0/24").subnets(new_prefix=26)
print("192.168.10.0/24 en cuatro subredes:", [str(s) for s in nueva])

cab = cabecera_ipv4("192.168.1.50", "192.168.1.1", 17, 28)
print("Encabezado IPv4 (UDP, 28 bytes de datos):", cab.hex(" ").upper())
print("  checksum", cab[10:12].hex().upper(), "| al recalcular sobre el encabezado completo:", checksum(cab))

q = consulta_dns("example.com")
print(f"Consulta DNS de example.com (tipo A): {len(q)} bytes")
print(" ", q.hex(" ").upper())

Resultado: 192.168.1.50/24 tiene máscara 255.255.255.0, red 192.168.1.0, difusión 192.168.1.255 y 254 equipos; 10.0.0.77/20 tiene máscara 255.255.240.0, red 10.0.0.0, difusión 10.0.15.255 y 4094 equipos, y el módulo ipaddress da la misma red, 10.0.0.0/20. 192.168.1.50 y 192.168.1.200 están en la misma red con /24, 192.168.1.50 y 192.168.2.10 no, y 192.168.1.50 y 192.168.0.10 sí lo están con /23. Los equipos utilizables para /24, /26, /28 y /30 son 254, 62, 14 y 2, y 192.168.10.0/24 en cuatro subredes da .0, .64, .128 y .192 con /26. El encabezado IPv4 de un paquete UDP de 28 bytes de datos es 45 00 00 30 12 34 40 00 40 11 A5 05 C0 A8 01 32 C0 A8 01 01, con checksum A505, y recalcularlo sobre el encabezado completo da 0. La consulta DNS de example.com mide 29 bytes: 12 34 01 00 00 01 00 00 00 00 00 00 07 65 78 61 6D 70 6C 65 03 63 6F 6D 00 00 01 00 01.

Observá que el checksum recalculado sobre el encabezado completo da cero, igual que el CRC de una trama buena da un residuo fijo: es el mismo truco de verificación. Y que la consulta DNS son solo 29 bytes: el protocolo que traduce nombres es muy liviano.

12 · Exploración interactiva

Laboratorio: subredes, rutas, encabezado y puertos

El laboratorio tiene cinco herramientas. La primera calcula una subred a partir de una dirección y un prefijo. La segunda decide si el destino se alcanza directo o por la puerta de enlace. La tercera divide una red en subredes. La cuarta arma un encabezado IPv4 con su checksum. La quinta analiza un puerto y arma el socket correspondiente.

En la herramienta 1, un prefijo /31 o /32 no tiene dirección de red ni de difusión propias. En la 2, la puerta de enlace tiene que pertenecer a la misma red que el equipo. En la 3, las subredes se numeran desde la dirección de red de la red original. En la 4, el identificador es 0x1234 y está activado «no fragmentar»; el protocolo UDP es el 17. En la 5, el puerto de origen del ejemplo lo calcula la herramienta a partir del de destino, solo para mostrar que cae en el rango efímero.

Recorrido guiado

1. Con los valores iniciales (192.168.1.50/24): máscara 255.255.255.0, red 192.168.1.0, difusión 192.168.1.255, 254 equipos (de .1 a .254) y dirección privada (192.168.0.0/16).
2. Probá 10.0.0.77/20: máscara 255.255.240.0, red 10.0.0.0, difusión 10.0.15.255 y 4094 equipos. Con /30: 2 equipos; con /31 y /32, sin red ni difusión. Con 8.8.8.8: pública. 169.254.3.4: enlace local. 172.20.5.5: privada (172.16.0.0/12). 192.168.1.0 con /24: la herramienta avisa que es la dirección de red.
3. En la herramienta 2, con los valores iniciales (equipo 192.168.1.50/24, destino 192.168.1.20): misma red, entrega directa. Cambiá el destino a 8.8.8.8: otra red, la trama se entrega a la puerta de enlace 192.168.1.1.
4. Poné la puerta de enlace en 192.168.2.1: «Inválida: no está en la red local» y el veredicto cambia a «No puede salir de la red». Con destino 192.168.1.20, la misma red anda, pero se avisa que la puerta de enlace está mal. Es el clásico error de configuración manual.
5. Bajá el prefijo a /23 y poné el destino en 192.168.0.10: ahora es la misma red (la red es 192.168.0.0/23, que cubre 192.168.0.x y 192.168.1.x). Con 192.168.2.10, no.
6. En la herramienta 3, con 192.168.10.0/24 en 4 subredes: prefijo /26, bloques de 64 y 62 equipos por subred: .0, .64, .128 y .192. Con 16 subredes: /28, 14 equipos. Con prefijo /29 y 16 subredes se pasa de /30 y la herramienta avisa.
7. En la herramienta 4, con los valores iniciales (UDP, 28 bytes de datos, TTL 64): encabezado 45 00 00 30 12 34 40 00 40 11 A5 05 C0 A8 01 32 C0 A8 01 01, largo total 48, checksum 0xA505 y verificación en cero. Cambiá el TTL a 63, como lo dejaría un router: cambia el checksum.
8. En la herramienta 5, con el puerto 1883 (TCP): MQTT, rango registrado. Probá 80 (HTTP, bien conocido), 502 (Modbus TCP), 53 con UDP (DNS) y 50000 (efímero).

13 · Un procedimiento

Diagnóstico de la conectividad IP

Cuando un dispositivo «no tiene red» o no llega a un servicio, se avanza de lo cercano a lo lejano, probando con ping en cada paso:

1. Enlace. ¿Hay luz de enlace? (tema 29). Sin enlace no hay nada más que revisar.
2. Configuración propia. ¿Qué IP, máscara, puerta de enlace y DNS tiene el equipo? ¿Es una 169.254.x.y? Entonces no obtuvo DHCP.
3. Ping a sí mismo (127.0.0.1 y su propia IP): comprueba la pila de red local.
4. Ping a la puerta de enlace. Si falla, el problema está en la red local (máscara incorrecta, cable, conmutador, IP repetida).
5. Ping a una dirección de Internet (por ejemplo 8.8.8.8). Si responde, la salida a Internet funciona.
6. Ping a un nombre. Si el ping a la IP anda y el del nombre no, el problema es DNS.
7. Puerto del servicio. Con todo lo anterior bien, se prueba si el puerto del servicio está abierto (tema 31): un firewall o NAT puede bloquearlo aunque haya ping.

14 · Comprensión

Confusiones frecuentes

15 · Práctica guiada

Predecí antes de comprobar

1. Una subred

Calculá la red, la difusión y la cantidad de equipos de 172.16.37.200/21.

2. ¿Misma red?

Un equipo con 10.1.4.20/22, ¿puede hablar directamente con 10.1.7.5? ¿Y con 10.1.8.5?

3. Una puerta de enlace mal puesta

Un equipo tiene 192.168.0.40/24 y puerta de enlace 192.168.1.1. ¿Qué pasa?

4. Dividir una red

Hay que partir 10.20.0.0/16 en 8 subredes iguales. ¿Qué prefijo, cuántos equipos por subred y cuál es la tercera subred?

5. El checksum

Dos palabras de 16 bits de un encabezado son 0xC0A8 y 0x0132 (parte de una dirección). ¿Qué hace el cálculo del checksum con la suma si se pasa de 16 bits?

6. Un dispositivo con DHCP

Un sensor arranca y muestra la dirección 169.254.88.12. ¿Qué pasó y qué se revisa?

7. Un socket

Un sensor (192.168.1.50) se conecta a un broker MQTT (192.168.1.10). ¿Cuáles son los cinco datos de la conexión y qué rango tiene cada puerto?

16 · Síntesis

Ideas para recordar

¿Listo para el siguiente tema?

Antes de avanzar, calculá cuántos equipos admite una red /27 (30) y cuáles son la red y la difusión de 192.168.5.77/27 (192.168.5.64 y 192.168.5.95); decidí si un equipo 10.0.0.9/24 habla directamente con 10.0.1.9 (no: va por la puerta de enlace); y explicá por qué un dispositivo detrás de NAT puede conectarse a un broker en Internet, pero el broker no puede conectarse a él (el router crea la traducción cuando sale la conexión y no tiene una regla para las entrantes). Si podés justificar las tres respuestas, tenés los fundamentos del direccionamiento IP.

En el próximo tema subimos a la capa de transporte: TCP, UDP y sockets. Veremos cómo se establece una conexión confiable, qué ofrece UDP en cambio y cómo se programa un cliente y un servidor.