Subredes IP y Conversión Binaria en Terminal Linux | Guía Práctica

Introducción

En este laboratorio, dominarás las habilidades esenciales de subredes de direcciones IP y conversión binaria utilizando la línea de comandos de Linux. Al aprovechar el intérprete interactivo de Python, obtendrás experiencia práctica con los cálculos fundamentales que sustentan las redes informáticas, pasando del conocimiento teórico a la aplicación práctica en un entorno de terminal.

Comenzarás convirtiendo direcciones IP de la notación decimal con puntos (dotted-decimal notation) a su forma binaria de 32 bits y viceversa. Luego, el laboratorio te guiará a través de la traducción de máscaras de subred CIDR a sus equivalentes binarios y decimales con puntos. Finalmente, aplicarás estas habilidades para identificar las porciones de red y host de una dirección IP dada y calcular el número total de hosts y subredes utilizables disponibles dentro de un bloque CIDR específico.

Realizar Conversiones de IP y Máscara de Subred en Python

En este paso, utilizarás el intérprete interactivo de Python para realizar varias conversiones clave de redes. Aprenderás a convertir direcciones IP entre formatos decimal con puntos (dotted-decimal) y binario, y cómo traducir máscaras de subred CIDR a sus representaciones binarias y decimales con puntos completas. Todo esto se hará en una única sesión continua para agilizar el proceso.

Una dirección IPv4 es un número de 32 bits. Para que sea legible para los humanos, se representa como cuatro números de 8 bits, llamados octetos, separados por puntos (por ejemplo, 192.168.1.10). Cada uno de estos octetos se puede convertir a un número binario de 8 bits.

Primero, abramos la terminal e iniciemos el intérprete interactivo de Python. El entorno LabEx tiene Python preinstalado. Escribe python3 y presiona Enter.
```
python3
```
Verás un nuevo prompt, >>>, que indica que ahora estás dentro del intérprete de Python.
```
Python 3.10.x (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

Convertir una Dirección IP de Decimal con Puntos a Binario

Practiquemos la conversión de un solo número decimal a su forma binaria. Usaremos la función incorporada bin() de Python. Por ejemplo, para convertir el número 192, escribe lo siguiente en el prompt de Python:
```
bin(192)
```
Python devolverá la representación binaria, prefijada con 0b para indicar que es un número binario.
```
'0b11000000'
```
El equivalente binario de 192 es 11000000.
Ahora, apliquemos esto a una dirección IP completa, por ejemplo, 192.168.1.10. Necesitamos convertir cada octeto (192, 168, 1 y 10) individualmente. Una regla crítica en el direccionamiento IP es que cada octeto debe representarse con exactamente 8 bits. Si un número binario tiene menos de 8 bits, debes agregar ceros a la izquierda para rellenarlo.

Convirtamos cada parte:
- Para 192: bin(192) da '0b11000000'. Esto ya son 8 bits: 11000000.
- Para 168: bin(168) da '0b10101000'. Esto también son 8 bits: 10101000.
- Para 1: bin(1) da '0b1'. Debemos rellenarlo a 8 bits: 00000001.
- Para 10: bin(10) da '0b1010'. Debemos rellenarlo a 8 bits: 00001010.
Al combinar estos, obtienes la representación binaria completa de 32 bits de la dirección IP 192.168.1.10:

11000000.10101000.00000001.00001010

Convertir una Dirección IP Binaria de Vuelta a Decimal con Puntos

Ahora realizaremos la operación inversa. Para convertir un número binario a decimal, usaremos la función int() de Python. Esta función puede tomar dos argumentos: el primero es el número como una cadena (string), y el segundo es la base de ese número. Dado que estamos convirtiendo desde binario (base-2), siempre usaremos 2 como segundo argumento.

Intentemos convertir un solo octeto binario, 10101000, a decimal.
```
int('10101000', 2)
```
Python ejecutará la conversión y mostrará el resultado decimal.
```
168
```
Ahora, convirtamos la dirección IP binaria completa de 32 bits del paso anterior: 11000000.10101000.00000001.00001010. Necesitarás convertir cada octeto de 8 bits uno por uno.
- Convierte el primer octeto: int('11000000', 2) que resulta en 192.
- Convierte el segundo octeto: int('10101000', 2) que resulta en 168.
- Convierte el tercer octeto: int('00000001', 2) que resulta en 1.
- Convierte el cuarto octeto: int('00001010', 2) que resulta en 10.
Al combinar estos resultados con puntos, obtienes la dirección IP original en decimal con puntos: 192.168.1.10. Esto confirma que tus conversiones en ambas direcciones son correctas.

Traducir una Máscara de Subred CIDR a su Forma Binaria y Decimal con Puntos

Una máscara de subred es un número de 32 bits que distingue la porción de red de una dirección IP de la porción de host. La notación CIDR (Classless Inter-Domain Routing) es una forma abreviada de representar una máscara de subred.

Por ejemplo, una notación CIDR de /24 significa que los primeros 24 bits de la máscara de subred de 32 bits son 1s, y los bits restantes son 0s.

Determinemos la representación binaria y decimal con puntos para una máscara de subred /24.
- Binario: Una máscara /24 tiene 24 1s consecutivos seguidos de 32 - 24 = 8 0s. Cuando se divide en octetos, se ve así: 11111111.11111111.11111111.00000000
Ahora, convirtamos esta máscara binaria a su forma decimal con puntos. El primer octeto son todos unos, 11111111.
```
int('11111111', 2)
```
La salida será 255. El último octeto son todos ceros, 00000000.
```
int('00000000', 2)
```
La salida será 0. Por lo tanto, una máscara de subred /24 es 255.255.255.0 en notación decimal con puntos.
Intentemos un ejemplo más complejo, como /26.
- Binario: Una máscara /26 tiene 26 1s seguidos de 32 - 26 = 6 0s. 11111111.11111111.11111111.11000000
- Los primeros tres octetos son todos 1s, que sabemos que es 255. Convirtamos el último octeto, 11000000, a decimal.
```
int('11000000', 2)
```
La salida será 192. Por lo tanto, una máscara de subred /26 es 255.255.255.192 en notación decimal con puntos.
Una vez que hayas terminado con las conversiones, puedes salir del intérprete de Python y volver al prompt de la terminal normal escribiendo exit() y presionando Enter.
```
exit()
```

Ahora has dominado la conversión bidireccional entre direcciones IP en decimal con puntos y binario, y máscaras de subred CIDR, una habilidad crucial para cualquier profesional de redes.

Identificar las Porciones de Red y Host para una Dirección IP

En este paso, aplicarás tu conocimiento de las máscaras de subred para identificar las porciones de red y host de una dirección IP dada. La función principal de una máscara de subred es indicar a una computadora qué parte de una dirección IP identifica la red y qué parte identifica el dispositivo específico (host) en esa red.

Esto se logra a través de una operación lógica AND a nivel de bits (bitwise AND). La computadora toma la dirección IP (en binario) y la máscara de subred (en binario) y realiza una operación AND sobre ellas. El resultado es la Dirección de Red.

Las reglas para un AND a nivel de bits son simples:

1 AND 1 = 1
1 AND 0 = 0
0 AND 1 = 0
0 AND 0 = 0

Esencialmente, el resultado es 1 solo si ambos bits correspondientes son 1.

Usemos un ejemplo práctico para ver esto en acción. Determinaremos la dirección de red para la dirección IP 192.168.1.74 con una máscara de subred /26 (255.255.255.192). En lugar de hacerlo manualmente en el intérprete, escribiremos un pequeño script de Python para realizar el cálculo.

Primero, crea un nuevo archivo de script de Python llamado network_calc.py en tu directorio de proyecto usando el editor nano.
```
nano ~/project/network_calc.py
```

Dentro del editor nano, copia y pega el siguiente código de Python. Este script define los octetos de la IP y la máscara, realiza la operación AND en cada octeto e imprime el resultado.

## Define los octetos de la dirección IP y la máscara de subred
ip = [192, 168, 1, 74]
mask = [255, 255, 255, 192]

## Calcula la dirección de red usando un AND a nivel de bits
network_addr = [ip[i] & mask[i] for i in range(4)]

## Formatea las cadenas de salida
ip_str = ".".join(map(str, ip))
network_str = ".".join(map(str, network_addr))

print(f"IP Address:      {ip_str}")
print(f"Subnet Mask:     /26 (255.255.255.192)")
print(f"Network Address: {network_str}")

Guarda el archivo y sal de nano presionando Ctrl+O, luego Enter, y finalmente Ctrl+X.

Ahora, ejecuta tu script desde la terminal.

python3 ~/project/network_calc.py

Verás la siguiente salida, que muestra claramente el resultado de la operación AND:

IP Address:      192.168.1.74
Subnet Mask:     /26 (255.255.255.192)
Network Address: 192.168.1.64

De esta salida, podemos identificar las diferentes porciones:

Porción de Red (Network Portion): La máscara /26 indica que los primeros 26 bits son la porción de red. La Dirección de Red calculada (192.168.1.64) es el identificador para esta red específica.
Porción de Host (Host Portion): Los restantes 32 - 26 = 6 bits son la porción de host. Estos 6 bits identifican el dispositivo específico (.74) dentro de la red 192.168.1.64.

Has utilizado con éxito un script para encontrar la dirección de red y ahora puedes distinguir conceptualmente entre las porciones de red y host de una dirección IP.

Calcular Hosts Utilizables y Subredes para un CIDR Dado

En este paso final, aprenderás a realizar dos cálculos esenciales de subredes: determinar el número de direcciones IP de host utilizables dentro de una subred y averiguar cuántas subredes se pueden crear a partir de un bloque de red más grande. Estos cálculos son fundamentales para la planificación y el diseño de redes.

Aquí están las fórmulas clave:

Número de Hosts Utilizables: La fórmula es 2^n - 2, donde n es el número de bits de host (los 0s en la máscara de subred). Restamos 2 porque la primera dirección en una subred (donde todos los bits de host son 0) está reservada como la Dirección de Red, y la última dirección (donde todos los bits de host son 1) está reservada como la Dirección de Broadcast. Ninguna de las dos se puede asignar a un dispositivo.
Número de Subredes: Esto se calcula cuando divides una red más grande (por ejemplo, una /24) en otras más pequeñas (por ejemplo, /26). La fórmula es 2^m, donde m es el número de bits que "tomaste prestados" de la porción de host original para crear la nueva máscara de subred más específica.

Mejoremos nuestro script network_calc.py para que realice estos cálculos por nosotros.

Primero, abre el archivo network_calc.py nuevamente usando el editor nano.
```
nano ~/project/network_calc.py
```

Elimina el contenido existente y reemplázalo con el siguiente código de Python. Esta nueva versión se centra en calcular el número de hosts y subredes basándose en un prefijo CIDR dado.

## Define el prefijo CIDR y el prefijo de red base
cidr_prefix = 26
base_prefix = 24 ## La red original de la que estamos subredificando (por ejemplo, una /24)

## --- Cálculos ---

## 1. Calcular bits de host
host_bits = 32 - cidr_prefix

## 2. Calcular hosts utilizables
## El operador ** es para exponenciación (potencia de)
if host_bits > 0:
    total_hosts = 2**host_bits
    usable_hosts = total_hosts - 2
else:
    total_hosts = 1
    usable_hosts = 1 ## Para /31 y /32, las reglas son diferentes, pero aquí lo simplificamos

## 3. Calcular bits de subred prestados
subnet_bits = cidr_prefix - base_prefix

## 4. Calcular número de subredes
if subnet_bits >= 0:
    num_subnets = 2**subnet_bits
else:
    num_subnets = "N/A (El prefijo es menor que la base)"


## --- Salida ---
print(f"--- Cálculos de Subred para una Red /{cidr_prefix} ---")
print(f"Bits de Host: {host_bits}")
print(f"Hosts Totales por Subred: 2^{host_bits} = {total_hosts}")
print(f"Hosts Utilizables por Subred: {total_hosts} - 2 = {usable_hosts}")
print("") ## Añade una línea en blanco para legibilidad
print(f"--- Subredificando desde una Red /{base_prefix} ---")
print(f"Bits de Subred Prestados: {subnet_bits}")
print(f"Número de Subredes Creadas: 2^{subnet_bits} = {num_subnets}")

Guarda el archivo y sal de nano presionando Ctrl+O, Enter, y Ctrl+X.
Ejecuta el script actualizado desde tu terminal.
```
python3 ~/project/network_calc.py
```

El script ahora mostrará los valores calculados:

--- Cálculos de Subred para una Red /26 ---
Bits de Host: 6
Hosts Totales por Subred: 2^6 = 64
Hosts Utilizables por Subred: 64 - 2 = 62

--- Subredificando desde una Red /24 ---
Bits de Subred Prestados: 2
Número de Subredes Creadas: 2^2 = 4

Esta salida muestra claramente que para una red /26, hay 6 bits de host, lo que permite 2^6 = 64 direcciones totales. Después de reservar la dirección de red y la de broadcast, te quedan 62 hosts utilizables. También muestra que si comenzaste con una red /24, tomaste prestados 2 bits para crear la máscara /26, lo que resulta en 2^2 = 4 subredes posibles.

Resumen

En este laboratorio, aprendiste a realizar cálculos fundamentales de direcciones IP y subredes directamente en la terminal de Linux. Utilizaste el intérprete interactivo de Python como una herramienta poderosa para convertir direcciones IP del formato legible por humanos de decimal punteado a su equivalente binario de 32 bits, y luego de vuelta. Esto incluyó la conversión de cada octeto individualmente y la garantía de un relleno correcto de 8 bits. También practicaste la traducción de la notación de máscara de subred CIDR a sus formas binarias y de decimal punteado completas.

Basándote en estas habilidades de conversión, las aplicaste a tareas esenciales de análisis de red. Aprendiste a distinguir entre las porciones de red y host de una dirección IP utilizando la máscara de subred. Finalmente, realizaste los cálculos necesarios para determinar el número de direcciones de host utilizables y el número total de subredes disponibles para una red según su prefijo CIDR dado, solidificando tu comprensión de los principios de subredes IP.

Realizar Subredes IP y Conversión Binaria en la Terminal de Linux