HOJA DE TRUCOS DE SUBREDES Y CIDR PARA REDES

Introducción a las Subredes y CIDR

Las subredes y la notación CIDR son conceptos fundamentales para quienes trabajan en redes o desarrollo de software relacionado con infraestructura. Entender cómo funcionan las máscaras de subred, cómo se dividen las direcciones IP y cómo se utiliza la notación CIDR puede simplificar tareas como la configuración de redes, la optimización de recursos y la resolución de problemas de conectividad. Esta guía ofrece una explicación detallada y práctica de estos temas, incluyendo una hoja de trucos con valores clave para máscaras de subred, direcciones IP disponibles y conversiones binarias. También se abordan conceptos como el direccionamiento con clase, el subnetting y ejemplos prácticos para reforzar el aprendizaje.

Tabla de Máscaras de Subred y CIDR

La siguiente tabla resume las máscaras de subred, máscaras comodín, el número total de direcciones IP y las direcciones utilizables para cada notación CIDR. Esta información es esencial para calcular cuántas direcciones IP están disponibles en una subred y cuántas pueden asignarse a dispositivos.

Nota: La notación /31 es un caso especial descrito en la RFC 3021, que permite asignar dos direcciones IP para enlaces punto a punto.

La tabla de conversiones decimal a binario para máscaras de subred y máscaras comodín es:

La máscara comodín es el inverso de la máscara de subred. Por ejemplo, para una máscara de subred 255.255.255.0, la máscara comodín es 0.0.0.255.

# Ejemplo en Python para calcular la máscara comodín
def calcular_mascara_comodin(mascara_subred):
    octetos = mascara_subred.split('.')
    comodin = [str(255 - int(octeto)) for octeto in octetos]
    return '.'.join(comodin)

mascara = "255.255.255.0"
print(f"Máscara de subred: {mascara}")
print(f"Máscara comodín: {calcular_mascara_comodin(mascara)}")

Estructura de una Dirección IPv4

Una dirección IPv4, como 192.168.0.1, es una representación decimal de cuatro bloques binarios de 8 bits, conocidos como octetos. Cada octeto puede representar valores de 0 a 255, lo que da un total de 32 bits por dirección. Por ejemplo, la dirección 172.16.254.1 en binario es:

10101100.00010000.11111110.00000001

Para convertir un octeto a binario, se utiliza una tabla de potencias de 2:

Tomemos el octeto 168:

Esto da como resultado 10101000, ya que 128 + 32 + 8 = 168. Repitiendo este proceso para cada octeto de 168.210.225.206, se obtiene:

10101000.11010010.11100001.11001110

# Ejemplo en Python para convertir un octeto a binario
def octeto_a_binario(octeto):
    binario = bin(int(octeto))[2:].zfill(8)
    return binario

direccion_ip = "168.210.225.206"
octetos = direccion_ip.split('.')
binarios = [octeto_a_binario(octeto) for octeto in octetos]
print(f"Dirección IP: {direccion_ip}")
print(f"Binario: {'.'.join(binarios)}")

¿Qué es la División en Subredes?

La división en subredes permite dividir una red grande en subredes más pequeñas, optimizando el uso de direcciones IP. Cada dirección IP consta de una parte de red y una parte de host. La división en subredes utiliza la porción de host para crear estas subredes, permitiendo que los dispositivos determinen si otro dispositivo está en la misma red local.

Por ejemplo, en una red doméstica, un enrutador recibe una dirección IP pública de un proveedor de servicios de internet (ISP), mientras que los dispositivos conectados al enrutador tienen direcciones IP privadas, como 192.168.0.101. La combinación de la dirección IP y la máscara de subred permite al dispositivo determinar si otro dispositivo, como 192.168.0.103, está en la misma red.

# Ejemplo en Python para verificar si dos direcciones están en la misma red
def misma_red(ip1, ip2, mascara):
    octetos_ip1 = [int(o) for o in ip1.split('.')]
    octetos_ip2 = [int(o) for o in ip2.split('.')]
    octetos_mascara = [int(o) for o in mascara.split('.')]
    red1 = [octetos_ip1[i] & octetos_mascara[i] for i in range(4)]
    red2 = [octetos_ip2[i] & octetos_mascara[i] for i in range(4)]
    return red1 == red2

ip1 = "192.168.0.101"
ip2 = "192.168.0.103"
mascara = "255.255.255.0"
print(f"¿{ip1} y {ip2} están en la misma red con máscara {mascara}?")
print(misma_red(ip1, ip2, mascara))  # True

Cómo Funcionan las Máscaras de Subred

Una máscara de subred actúa como un filtro que separa los bits de red de los bits de host en una dirección IP. Por ejemplo, la máscara 255.255.255.0 (binario: 11111111.11111111.11111111.00000000) indica que los primeros tres octetos son para la red y el último para el host. Si una dirección IP es 192.168.0.101, los bits de red son 192.168.0, y el bit de host es 101.

Esto permite identificar el ID de red, que en este caso sería 192.168.0.0. Cualquier dispositivo con una dirección que comparta este ID de red estará en la misma subred.

# Ejemplo en Python para calcular el ID de red
def calcular_id_red(ip, mascara):
    octetos_ip = [int(o) for o in ip.split('.')]
    octetos_mascara = [int(o) for o in mascara.split('.')]
    id_red = [octetos_ip[i] & octetos_mascara[i] for i in range(4)]
    return '.'.join(str(o) for o in id_red)

ip = "192.168.0.101"
mascara = "255.255.255.0"
print(f"Dirección IP: {ip}")
print(f"Máscara de subred: {mascara}")
print(f"ID de red: {calcular_id_red(ip, mascara)}")

Notación CIDR y Subenmascaramiento

La notación CIDR (Classless Inter-Domain Routing) es una forma abreviada de representar una máscara de subred. Por ejemplo, 192.168.0.101/24 indica una dirección IP con una máscara de subred de 255.255.255.0, donde /24 representa los 24 bits de red (tres octetos completos). Para calcular la notación CIDR, se convierte la máscara de subred a binario y se cuentan los bits en 1.

Por ejemplo, para 255.255.255.0:

11111111.11111111.11111111.00000000

Esto tiene 24 bits en 1, por lo que la notación CIDR es /24.

# Ejemplo en Python para calcular notación CIDR
def calcular_cidr(mascara):
    octetos = [int(o) for o in mascara.split('.')]
    binario = ''.join([bin(octeto)[2:].zfill(8) for octeto in octetos])
    return binario.count('1')

mascara = "255.255.255.0"
print(f"Máscara de subred: {mascara}")
print(f"Notación CIDR: /{calcular_cidr(mascara)}")

Direccionamiento IP con Clase

Antes de la introducción de CIDR en 1993, las direcciones IP se organizaban en clases (A, B, C, D y E), cada una con una máscara de subred predeterminada. Este sistema era ineficiente, ya que asignaba bloques grandes de direcciones que a menudo no se utilizaban por completo.

Clase A

• Rango: 1.0.0.0 a 127.255.255.255
• Máscara predeterminada: 255.0.0.0 (/8)
• Bits de red: 8
• Bits de host: 24
• Redes: 128
• Direcciones por red: 16,777,214

El rango 127.0.0.0 a 127.255.255.255 está reservado para direcciones de bucle invertido (localhost).

Clase B

• Rango: 128.0.0.0 a 191.255.255.255
• Máscara predeterminada: 255.255.0.0 (/16)
• Bits de red: 16
• Bits de host: 16
• Redes: 16,384
• Direcciones por red: 65,534

Clase C

• Rango: 192.0.0.0 a 223.255.255.255
• Máscara predeterminada: 255.255.255.0 (/24)
• Bits de red: 24
• Bits de host: 8
• Redes: 2,097,152
• Direcciones por red: 254

Clases D y E

• Clase D (224.0.0.0 a 239.255.255.255): Reservada para multidifusión.
• Clase E (240.0.0.0 en adelante): Reservada para uso experimental.

El direccionamiento con clase generaba un desperdicio significativo de direcciones IP, ya que las organizaciones recibían bloques más grandes de lo necesario. Por ejemplo, una empresa con 1,000 dispositivos requería una red de Clase B (65,534 direcciones), dejando muchas direcciones sin usar.

# Ejemplo en Python para identificar la clase de una dirección IP
def identificar_clase_ip(ip):
    primer_octeto = int(ip.split('.')[0])
    if 1 <= primer_octeto <= 126:
        return "Clase A"
    elif 128 <= primer_octeto <= 191:
        return "Clase B"
    elif 192 <= primer_octeto <= 223:
        return "Clase C"
    elif 224 <= primer_octeto <= 239:
        return "Clase D"
    else:
        return "Clase E"

ip = "192.168.0.101"
print(f"Dirección IP: {ip}")
print(f"Clase: {identificar_clase_ip(ip)}")

Subenmascaramiento de Longitud Variable (VLSM)

El subenmascaramiento de longitud variable (VLSM) permite crear subredes de diferentes tamaños dentro de una red, optimizando aún más el uso de direcciones IP. Por ejemplo, una red /24 puede dividirse en una subred /26 (64 direcciones) y otra /25 (128 direcciones), según las necesidades de la organización.

Ejemplo práctico: Supongamos que tenemos la red 192.168.1.0/24 y queremos dividirla en dos subredes: una para 50 dispositivos y otra para 100 dispositivos.

1. Para 50 dispositivos, necesitamos al menos 64 direcciones (/26, ya que 2^6 = 64).
2. Para 100 dispositivos, necesitamos al menos 128 direcciones (/25, ya que 2^7 = 128).

La red /24 (256 direcciones) se divide en:

• 192.168.1.0/26 (192.168.1.0 a 192.168.1.63)
• 192.168.1.128/25 (192.168.1.128 a 192.168.1.255)

# Ejemplo en Python para calcular rangos de subredes
def calcular_rango_subred(ip_base, cidr):
    octetos = [int(o) for o in ip_base.split('.')]
    num_hosts = 2 ** (32 - cidr)
    inicio = octetos
    fin = [octetos[i] + (num_hosts // (256 ** (3 - i))) % 256 for i in range(4)]
    return f"{'.'.join(str(o) for o in inicio)} - {'.'.join(str(o) for o in fin)}"

ip_base = "192.168.1.0"
cidr = 26
print(f"Red: {ip_base}/{cidr}")
print(f"Rango: {calcular_rango_subred(ip_base, cidr)}")

Conclusiones

La comprensión de las máscaras de subred, la notación CIDR y la división en subredes es esencial para gestionar redes de manera eficiente. La tabla de máscaras de subred y los ejemplos de código proporcionados permiten a los desarrolladores y administradores de redes calcular rápidamente las direcciones disponibles, identificar IDs de red y optimizar el uso de direcciones IP. Aunque el direccionamiento con clase es obsoleto, conocerlo ayuda a entender la evolución de las redes modernas. La notación CIDR y el VLSM han permitido un uso más eficiente de las direcciones IPv4, retrasando la necesidad de una transición completa a IPv6. Esta guía práctica es una referencia útil para profesionales de tecnología que buscan dominar los fundamentos de las redes.