Mostrando el Markdown sin formato: no se pudo cargar el visor.
## Objetivo
Lees la configuración IPv4 de tu propio ordenador (dirección, prefijo, puerta de enlace y de dónde viene), compruebas los cálculos de la lección con el módulo `ipaddress` de Python y escribes un pequeño script que clasifica direcciones por su finalidad. No se cambia nada en tu red.
## Objetivos
- Encontrar tu dirección IPv4, longitud de prefijo, máscara de subred y puerta de enlace predeterminada en Linux, macOS o Windows.
- Saber si tu dirección se configuró de forma estática o mediante el protocolo de configuración dinámica de host (DHCP, Dynamic Host Configuration Protocol).
- Calcular la dirección de red, la dirección de broadcast y el rango de hosts utilizables, y confirmarlos con Python.
- Clasificar direcciones IPv4 como privadas, públicas, compartidas (traducción de direcciones de red de grado operador, CGN, Carrier-Grade Network Address Translation), loopback, link-local, de documentación, multicast o broadcast.
- Explicar por qué el indicador `is_private` de Python es más amplio que "RFC 1918".
## Requisitos previos
- Un ordenador con Linux (con el comando `ip` de iproute2), macOS o Windows 10/11.
- Python 3.8 o posterior, solo con la biblioteca estándar. Este laboratorio se probó con Python 3.14.7 y 3.11.8. Comprueba el tuyo con `python3 --version` (en Windows: `py --version`).
- Un editor de texto.
- No hacen falta derechos de administrador: todos los comandos de este laboratorio solo leen la configuración.
- [Lección: direccionamiento IP](lesson.es.md) de este módulo.
> [!WARNING]
> Tus propias direcciones, tu puerta de enlace y los detalles de la concesión describen tu red. No publiques la salida de estos comandos en foros públicos ni en capturas de pantalla. Cuando compartas resultados, sustituye los valores por direcciones de documentación (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`).
## Arquitectura
<figure class="diagram" style="--dg-w: 940px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 940 300" width="940" height="300" role="img" aria-labelledby="ip-lab-architecture-es-title ip-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="ip-lab-architecture-es-title">Arquitectura del laboratorio: dónde vive cada dirección</title>
<desc id="ip-lab-architecture-es-desc">Tu ordenador tiene una dirección privada como 192.168.1.23/24 en tu red local. Tu router es su puerta de enlace predeterminada en 192.168.1.1, reparte direcciones con DHCP y las traduce con NAT. En su lado público se conecta a tu proveedor de Internet con una dirección pública, o con una dirección de 100.64.0.0/10 si el proveedor usa NAT de grado operador (CGN), y desde ahí a Internet.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="939" height="299" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="470" height="260" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Tu LAN · direcciones privadas (RFC 1918)</text></g>
<g class="dg-l1"><rect class="dg-tint" x="500" y="20" width="420" height="260" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(516 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="542" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Lado público</text></g>
<rect class="dg-card" x="44" y="90" width="200" height="130" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 106) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="102" y="127" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Tu ordenador</text>
<text x="62" y="158" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.168.1.23/24</text>
<text x="62" y="178" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Dirección privada</text>
<rect class="dg-card" x="300" y="70" width="172" height="190" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(316 86) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g>
<text x="358" y="107" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Tu router</text>
<text x="318" y="138" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.168.1.1</text>
<g class="dg-l3"><rect class="dg-solid" x="318" y="152" width="139" height="26" rx="13" fill="#b45309"/><text x="387.5" y="169.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Puerta de enlace</text></g>
<g class="dg-l7"><rect class="dg-solid" x="318" y="184" width="118" height="26" rx="13" fill="#6d28d9"/><text x="377" y="201.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Servidor DHCP</text></g>
<g class="dg-l4"><rect class="dg-solid" x="318" y="216" width="46" height="26" rx="13" fill="#c2410c"/><text x="341" y="233.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">NAT</text></g>
<rect class="dg-card" x="540" y="80" width="220" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(556 96) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4.9 16.1C1 12.2 1 5.8 4.9 1.9"/><path d="M7.8 4.7a6.14 6.14 0 0 0-.8 7.5"/><circle cx="12" cy="9" r="2"/><path d="M16.2 4.8c2 2 2.26 5.11.8 7.47"/><path d="M19.1 1.9a9.96 9.96 0 0 1 0 14.1"/><path d="M9.5 18h5"/><path d="m8 22 4-11 4 11"/></g>
<text x="598" y="117" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Tu ISP</text>
<text x="558" y="148" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Proveedor de Internet</text>
<text x="558" y="168" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Dirección pública</text>
<g class="dg-warn"><rect class="dg-tint" x="558" y="186" width="175" height="26" rx="13" fill="#f8e8e8" stroke="#e09999" stroke-width="1.2"/><text x="645.5" y="203.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="700" text-anchor="middle">o 100.64.0.0/10 (CGN)</text></g>
<circle class="dg-card" cx="852" cy="150" r="40" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(834 132) scale(1.5000)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="852" y="214" font-size="14" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Internet</text>
<path class="dg-line" d="M244 155H296" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M289 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M472 155H536" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M529 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M760 155H808" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M801 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
</svg></figure>
*Figura 1. Dónde vive cada dirección. Todo lo de la izquierda es tu red privada; el router traduce entre ella y el lado público. Los valores de ejemplo son típicos de una red doméstica; los tuyos pueden diferir.*
*Solo inspeccionas el recuadro de la izquierda. Los valores mostrados son ejemplos; los tuyos serán distintos.*
## Pasos
### Paso 1 — Crea una carpeta de trabajo
Escribirás dos scripts pequeños. Guárdalos en una sola carpeta para que la limpieza sea un único comando.
Linux y macOS:
```bash
mkdir -p ~/ip-lab && cd ~/ip-lab
```
Windows (PowerShell):
```powershell
New-Item -ItemType Directory -Force "$HOME\ip-lab"; Set-Location "$HOME\ip-lab"
```
Si no hay salida, ha ido bien (PowerShell muestra los detalles de la carpeta nueva).
### Paso 2 — Encuentra tu dirección, tu prefijo y tu puerta de enlace
Estos son los cuatro valores que necesita todo host. Ejecuta los comandos de tu sistema operativo y rellena la tabla al final de este paso.
**Linux.** Muestra las direcciones IPv4 y luego la ruta predeterminada:
```bash
ip -4 addr show
ip route show default
```
Salida esperada (los nombres de interfaz y los valores de la tuya serán distintos):
```text
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
inet 192.168.1.23/24 brd 192.168.1.255 scope global dynamic noprefixroute eth0
valid_lft 86077sec preferred_lft 86077sec
default via 192.168.1.1 dev eth0 proto dhcp src 192.168.1.23 metric 100
```
La línea `inet` da la dirección y el prefijo juntos (`192.168.1.23/24`). Ignora `lo`: es la interfaz de loopback. La línea `default via` da la puerta de enlace.
**macOS.** Encuentra la interfaz que lleva la ruta predeterminada y luego su dirección:
```bash
route -n get default
ifconfig en0 | grep "inet "
```
Salida esperada (abreviada; sustituye `en0` por el valor de `interface` del primer comando):
```text
route to: default
destination: default
mask: default
gateway: 192.168.1.1
interface: en0
…
inet 192.168.1.23 netmask 0xffffff00 broadcast 192.168.1.255
```
macOS muestra la máscara en hexadecimal: `0xffffff00` es `ff.ff.ff.00` = `255.255.255.0` = `/24`.
**Windows (PowerShell).**
```powershell
ipconfig /all
Get-NetRoute -DestinationPrefix 0.0.0.0/0
```
Salida esperada (abreviada):
```text
Ethernet adapter Ethernet:
…
DHCP Enabled. . . . . . . . . . . : Yes
IPv4 Address. . . . . . . . . . . : 192.168.1.23(Preferred)
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Lease Obtained. . . . . . . . . . : Wednesday, 4 November 2026 08:12:40
Lease Expires . . . . . . . . . . : Thursday, 5 November 2026 08:12:40
Default Gateway . . . . . . . . . : 192.168.1.1
DHCP Server . . . . . . . . . . . : 192.168.1.1
DNS Servers . . . . . . . . . . . : 192.168.1.1
ifIndex DestinationPrefix NextHop RouteMetric ifMetric PolicyStore
------- ----------------- ------- ----------- -------- -----------
12 0.0.0.0/0 192.168.1.1 0 25 ActiveStore
```
`0.0.0.0/0` es la ruta predeterminada: "todos los destinos que no coincidan con una ruta más específica".
> [!NOTE]
> La redacción exacta, el espaciado de las columnas y los formatos de fecha varían con la versión del sistema operativo y el idioma de la interfaz. Si ves varios adaptadores (Wi-Fi, Ethernet, VPN, adaptadores de máquinas virtuales), usa aquel cuya puerta de enlace coincida con la ruta predeterminada.
Anota tus valores:
| Valor | El tuyo |
|---|---|
| Dirección IPv4 | `<address>` |
| Longitud de prefijo / máscara | `<prefix>` / `<mask>` |
| Puerta de enlace predeterminada | `<gateway>` |
| Interfaz | `<interface>` |
### Paso 3 — Averigua de dónde vino la dirección
Una dirección DHCP tiene una concesión que caduca; una dirección estática no. Saber cuál tienes te dice dónde mirar cuando algo falla.
- **Linux:** la línea `inet` del paso 2 contiene `dynamic` y un `valid_lft` finito (por ejemplo `86077sec`) en una dirección DHCP. Una dirección estática muestra `valid_lft forever` y no tiene `dynamic`. `proto dhcp` en la ruta predeterminada lo confirma.
- **Windows:** `DHCP Enabled. . . : Yes` junto con las líneas `Lease Obtained` / `Lease Expires` y `DHCP Server`.
- **macOS:** muestra la concesión DHCP de la interfaz:
```bash
ipconfig getpacket en0
```
Salida esperada (abreviada):
```text
op = BOOTREPLY
…
yiaddr = 192.168.1.23
…
subnet_mask (ip): 255.255.255.0
router (ip_mult): {192.168.1.1}
lease_time (uint32): 0x15180
server_identifier (ip): 192.168.1.1
```
`yiaddr` ("your IP address", tu dirección IP) es la dirección que te dio el servidor. `0x15180` son 86 400 segundos: una concesión de 24 horas. Si no hay salida, la interfaz no se configuró por DHCP.
Anota: ¿estática o DHCP? ¿Qué dispositivo es el servidor DHCP? En la mayoría de las redes domésticas es el mismo dispositivo que la puerta de enlace.
### Paso 4 — Comprueba el cálculo de la lección con Python
Inicia una sesión interactiva de Python con `python3` (Windows: `py`) y escribe las líneas que siguen a `>>>`. Confirmarás el ejemplo `192.0.2.130/26` de la sección Cómo funciona de la lección.
```python
>>> import ipaddress
>>> iface = ipaddress.ip_interface("192.0.2.130/26")
>>> iface.network
>>> iface.netmask
>>> iface.network.broadcast_address
>>> iface.network.num_addresses
>>> list(iface.network.hosts())[0]
>>> list(iface.network.hosts())[-1]
```
Salida esperada, línea a línea:
```text
IPv4Network('192.0.2.128/26')
IPv4Address('255.255.255.192')
IPv4Address('192.0.2.191')
64
IPv4Address('192.0.2.129')
IPv4Address('192.0.2.190')
```
64 direcciones, menos la de red y la de broadcast, dejan los 62 hosts utilizables de la lección. Ahora comprueba la respuesta de la pregunta rápida y echa un vistazo a IPv6:
```python
>>> ipaddress.ip_address("198.51.100.200") in ipaddress.ip_network("198.51.100.192/27")
>>> ipaddress.ip_interface("2001:db8:0:10::82/64").network
```
```text
True
IPv6Network('2001:db8:0:10::/64')
```
Sal con `exit()`.
> [!TIP]
> `ipaddress.ip_network("192.0.2.130/26")` lanza `ValueError: 192.0.2.130/26 has host bits set`, porque una red debe escribirse con su dirección de red. Usa `ip_interface()` para "esta dirección en esa red", o pasa `strict=False`.
### Paso 5 — Escribe una calculadora de direcciones
Un script te permite repetir el cálculo para cualquier dirección, incluida la tuya. Guarda esto como `ipcalc.py` en tu carpeta `ip-lab`:
```python
"""Show the network facts for an IPv4 address with a prefix, e.g. 192.0.2.130/26."""
import ipaddress
import sys
def dotted_binary(addr):
return ".".join(f"{int(octet):08b}" for octet in str(addr).split("."))
iface = ipaddress.IPv4Interface(sys.argv[1] if len(sys.argv) > 1 else "192.0.2.130/26")
net = iface.network
print(f"Address {iface.ip}")
print(f" in binary {dotted_binary(iface.ip)}")
print(f"Prefix /{net.prefixlen} ({net.prefixlen} network + {32 - net.prefixlen} host bits)")
print(f"Subnet mask {net.netmask}")
print(f" in binary {dotted_binary(net.netmask)}")
print(f"Network {net.network_address}")
print(f"Broadcast {net.broadcast_address}")
if net.prefixlen <= 30:
print(f"First host {net.network_address + 1}")
print(f"Last host {net.broadcast_address - 1}")
print(f"Usable hosts {net.num_addresses - 2} (2^{32 - net.prefixlen} - 2)")
else:
print("Special case: /31 and /32 have no separate network and broadcast addresses (see module 06).")
```
Ejecútalo sin argumentos (el ejemplo de la lección) y luego con el error común de la `/20` de la lección:
```bash
python3 ipcalc.py
python3 ipcalc.py 172.20.13.77/20
```
En Windows, usa `py` en lugar de `python3`. Salida esperada:
```text
Address 192.0.2.130
in binary 11000000.00000000.00000010.10000010
Prefix /26 (26 network + 6 host bits)
Subnet mask 255.255.255.192
in binary 11111111.11111111.11111111.11000000
Network 192.0.2.128
Broadcast 192.0.2.191
First host 192.0.2.129
Last host 192.0.2.190
Usable hosts 62 (2^6 - 2)
Address 172.20.13.77
in binary 10101100.00010100.00001101.01001101
Prefix /20 (20 network + 12 host bits)
Subnet mask 255.255.240.0
in binary 11111111.11111111.11110000.00000000
Network 172.20.0.0
Broadcast 172.20.15.255
First host 172.20.0.1
Last host 172.20.15.254
Usable hosts 4094 (2^12 - 2)
```
Ahora ejecútalo con tu propia dirección del paso 2:
```bash
python3 ipcalc.py <address>/<prefix>
```
`<address>/<prefix>` es tu dirección IPv4 y tu longitud de prefijo, por ejemplo `192.168.1.23/24`. Si solo tienes una máscara en decimal con puntos (Windows, macOS), Python también la acepta: `192.168.1.23/255.255.255.0`.
Comprueba: ¿está tu puerta de enlace predeterminada entre `First host` y `Last host`? Debe estarlo.
### Paso 6 — Clasifica direcciones por su finalidad
Los objetos `ipaddress` de Python tienen indicadores como `is_private`, `is_global`, `is_loopback`, `is_link_local` e `is_multicast`. Este script los compara con una tabla explícita de bloques de uso especial de la lección. Guárdalo como `classify.py`:
```python
"""Classify IPv4 addresses by purpose and compare with Python's ipaddress flags."""
import ipaddress
import sys
# Special-purpose blocks (RFC 6890 and the IANA IPv4 Special-Purpose Address Registry).
# Checked in order: the first match wins, so 255.255.255.255 comes before 240.0.0.0/4.
BLOCKS = [
("0.0.0.0/8", "This network (RFC 791)"),
("10.0.0.0/8", "Private (RFC 1918)"),
("100.64.0.0/10", "Shared / CGN (RFC 6598)"),
("127.0.0.0/8", "Loopback (RFC 1122)"),
("169.254.0.0/16", "Link-local (RFC 3927)"),
("172.16.0.0/12", "Private (RFC 1918)"),
("192.0.2.0/24", "Documentation (RFC 5737)"),
("192.168.0.0/16", "Private (RFC 1918)"),
("198.51.100.0/24", "Documentation (RFC 5737)"),
("203.0.113.0/24", "Documentation (RFC 5737)"),
("224.0.0.0/4", "Multicast (RFC 5771)"),
("255.255.255.255/32", "Limited broadcast (RFC 919)"),
("240.0.0.0/4", "Reserved (RFC 1112)"),
]
BLOCKS = [(ipaddress.IPv4Network(net), label) for net, label in BLOCKS]
SAMPLES = [
"192.168.1.10", "10.20.30.40", "172.20.1.5", "172.32.1.5", "100.64.12.34",
"127.0.0.1", "169.254.17.3", "192.0.2.130", "198.51.100.7", "203.0.113.250",
"224.0.0.251", "255.255.255.255", "0.0.0.0",
]
def purpose(addr):
for net, label in BLOCKS:
if addr in net:
return label
if addr.is_global:
return "Public (global unicast)"
return "Other special (see IANA)"
def mark(flag):
return "yes" if flag else "-"
print(f"{'Address':<16} {'Purpose':<28} {'private':>7} {'global':>6} {'loopbk':>6} {'link-l':>6} {'mcast':>5}")
for text in sys.argv[1:] or SAMPLES:
a = ipaddress.IPv4Address(text)
print(f"{text:<16} {purpose(a):<28} {mark(a.is_private):>7} {mark(a.is_global):>6} "
f"{mark(a.is_loopback):>6} {mark(a.is_link_local):>6} {mark(a.is_multicast):>5}")
```
Ejecútalo con las muestras incluidas:
```bash
python3 classify.py
```
Salida esperada:
```text
Address Purpose private global loopbk link-l mcast
192.168.1.10 Private (RFC 1918) yes - - - -
10.20.30.40 Private (RFC 1918) yes - - - -
172.20.1.5 Private (RFC 1918) yes - - - -
172.32.1.5 Public (global unicast) - yes - - -
100.64.12.34 Shared / CGN (RFC 6598) - - - - -
127.0.0.1 Loopback (RFC 1122) yes - yes - -
169.254.17.3 Link-local (RFC 3927) yes - - yes -
192.0.2.130 Documentation (RFC 5737) yes - - - -
198.51.100.7 Documentation (RFC 5737) yes - - - -
203.0.113.250 Documentation (RFC 5737) yes - - - -
224.0.0.251 Multicast (RFC 5771) - yes - - yes
255.255.255.255 Limited broadcast (RFC 919) yes - - - -
0.0.0.0 This network (RFC 791) yes - - - -
```
Lee la tabla con atención. Cuatro resultados sorprenden a la mayoría:
- **`172.32.1.5` es pública.** El bloque RFC 1918 `172.16.0.0/12` termina en `172.31.255.255`.
- **`is_private` no es "RFC 1918".** Python marca una dirección como privada cuando el registro de IANA dice que *no es alcanzable globalmente*. Eso incluye loopback, link-local, documentación, `0.0.0.0` y broadcast. Para comprobar RFC 1918 en concreto, verifica tú mismo los tres bloques, como hace `BLOCKS`.
- **`100.64.12.34` no es ni privada ni global.** Python trata el espacio compartido de CGN (RFC 6598) como un caso especial: no es alcanzable desde Internet, pero tampoco es tuyo para usarlo.
- **`224.0.0.251` es "global".** `is_global` sale del registro de uso especial, y el multicast no aparece ahí (tiene su propio registro). `is_global` no significa "dirección unicast pública a la que puedes hacer ping".
> [!NOTE]
> Python 3.12.4 y 3.13 corrigieron las tablas que hay detrás de `is_private` e `is_global` para que coincidan con el registro de IANA (CVE-2024-4032; la corrección también se incorporó a versiones de seguridad de algunas ramas más antiguas). Para todas las direcciones de `SAMPLES`, la salida anterior es idéntica en Python 3.14.7 y en 3.11.8, que es anterior a la corrección. Los resultados difieren en algunas direcciones dentro de `192.0.0.0/24`: por ejemplo, `192.0.0.100` es `global` en 3.11.8 y `private` en 3.14.7. Si dependes de estos indicadores en código real, comprueba tu versión de Python.
### Paso 7 — Clasifica tus propias direcciones
Pasa como argumentos tu dirección y tu puerta de enlace del paso 2:
```bash
python3 classify.py <address> <gateway>
```
Con los valores de ejemplo (`192.168.1.23`, puerta de enlace `192.168.1.1`) la salida es:
```text
Address Purpose private global loopbk link-l mcast
192.168.1.23 Private (RFC 1918) yes - - - -
192.168.1.1 Private (RFC 1918) yes - - - -
```
La mayoría de los ordenadores domésticos y de oficina reciben una dirección privada y llegan a Internet a través de la traducción de direcciones de red (NAT, Network Address Translation) del router. Si tu dirección es pública, tu red asigna direcciones públicas directamente (algunas universidades y centros de datos lo hacen). Si es link-local (`169.254.x.x`), DHCP ha fallado: consulta Resolución de problemas.
## Verificación
Has completado el laboratorio si puedes responder "sí" a cada comprobación:
| Comprobación | Cómo confirmarlo |
|---|---|
| Anotaste dirección, prefijo, puerta de enlace e interfaz | La tabla del paso 2 está rellena |
| Sabes si tu dirección es estática o DHCP | Paso 3: `dynamic` / `DHCP Enabled: Yes` / salida de `ipconfig getpacket` |
| Python coincide con la lección | El paso 4 muestra `192.0.2.128/26`, `192.0.2.191` y 64 direcciones |
| Tu puerta de enlace está dentro de tu propia red | `python3 ipcalc.py <address>/<prefix>` muestra la puerta de enlace entre `First host` y `Last host` |
| Sabes explicar `is_private` frente a RFC 1918 | `python3 classify.py` muestra `yes` bajo `private` para `192.0.2.130` aunque no es RFC 1918 |
## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `python3: command not found` (o se abre Microsoft Store en Windows) | Python no está instalado, o en Windows está instalado como `py` | Usa `py` en Windows, o instala Python 3 desde python.org o tu gestor de paquetes |
| `ip: command not found` en Linux | Sistema mínimo sin iproute2 | Instala el paquete `iproute2`, o usa `hostname -I` solo para las direcciones |
| Aparecen varias direcciones y adaptadores | Red privada virtual (VPN), Docker, máquina virtual, o Wi-Fi y Ethernet activos a la vez | Usa la interfaz que aparece en la ruta predeterminada (`ip route show default`, `route -n get default`, `Get-NetRoute`) |
| Tu dirección empieza por `169.254.` y no hay puerta de enlace | Ningún servidor DHCP respondió (alternativa de la RFC 3927) | Revisa el cable o la conexión Wi-Fi y luego renueva la concesión (por ejemplo, vuelve a conectarte a la red). No fijes una dirección estática para "arreglarlo" |
| `ipconfig getpacket en0` no muestra nada en macOS | La interfaz no es `en0`, o no se configuró por DHCP | Usa la interfaz que da `route -n get default` |
| `AddressValueError` o `NetmaskValueError` en un script | Errata, dirección IPv6 o prefijo ausente | Pasa una dirección IPv4 como `192.168.1.23/24`; los scripts solo manejan IPv4 |
## Reto (opcional)
1. Encuentra la dirección externa (de la red de área extensa, WAN, wide area network) de tu router en su página de administración. Pásala por `classify.py`. Si está en `100.64.0.0/10`, tu ISP usa Carrier-Grade NAT: ¿qué significa eso para alojar un servicio en casa?
2. Amplía `classify.py` para que acepte también direcciones IPv6 (`ipaddress.ip_address()` devuelve cualquiera de los dos tipos) y clasifica `::1`, `fe80::1` y `2001:db8::1`. Compara lo que encuentres con el [módulo 07](../07-ipv6/README.es.md).
3. Ejecuta `python3 ipcalc.py 192.0.2.130/<n>` para cada prefijo de `/24` a `/30`. Anota cómo se mueven las direcciones de red y de broadcast. Usarás este patrón en el [módulo 06](../06-subnetting/README.es.md).
## Limpieza
El laboratorio solo creó la carpeta `ip-lab` y sus dos scripts. Bórralos.
Linux y macOS:
```bash
cd ~ && rm -r ~/ip-lab
```
Windows (PowerShell):
```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ip-lab"
```
No se cambió ningún ajuste de red, así que no hay nada más que deshacer.
## Qué has aprendido
- Todo host necesita una dirección, un prefijo (o máscara), una puerta de enlace predeterminada y servidores del sistema de nombres de dominio (DNS, Domain Name System), y puedes leerlos todos con comandos incluidos en cualquier sistema operativo.
- Una dirección DHCP muestra una concesión y un servidor DHCP; una estática no muestra ninguno de los dos.
- La red, el broadcast y el rango de hosts se deducen directamente del prefijo, y el módulo `ipaddress` de Python es una forma fiable de comprobar tu aritmética.
- "Privada" tiene dos significados: los bloques RFC 1918 y el más amplio "no alcanzable globalmente" de Python. Sabe cuál usa tu herramienta.
- Tu puerta de enlace debe estar siempre dentro de tu propia red.