Subnetting de IP e Conversão Binária no Terminal Linux

Introdução

Neste laboratório, você dominará as habilidades essenciais de sub-redes de endereços IP e conversão binária usando a linha de comando do Linux. Ao aproveitar o interpretador interativo do Python, você ganhará experiência prática com os cálculos fundamentais que sustentam as redes de computadores, passando do conhecimento teórico para a aplicação prática em um ambiente de terminal.

Você começará convertendo endereços IP da notação familiar de ponto decimal para sua forma binária de 32 bits e vice-versa. O laboratório o guiará através da tradução de máscaras de sub-rede CIDR para seus equivalentes binários e de ponto decimal. Finalmente, você aplicará essas habilidades para identificar as porções de rede e host de um determinado endereço IP e calcular o número total de hosts utilizáveis e sub-redes disponíveis dentro de um bloco CIDR específico.

Realizar Conversões de IP e Máscara de Sub-rede em Python

Nesta etapa, você usará o interpretador interativo do Python para realizar várias conversões de rede essenciais. Você aprenderá como converter endereços IP entre os formatos de ponto decimal e binário, e como traduzir máscaras de sub-rede CIDR para suas representações binárias e de ponto decimal completas. Tudo isso será feito em uma única sessão contínua para otimizar o processo.

Um endereço IPv4 é um número de 32 bits. Para torná-lo legível para humanos, ele é representado como quatro números de 8 bits, chamados octetos, separados por pontos (por exemplo, 192.168.1.10). Cada um desses octetos pode ser convertido em um número binário de 8 bits.

Primeiro, vamos abrir o terminal e iniciar o interpretador interativo do Python. O ambiente LabEx possui o Python pré-instalado. Digite python3 e pressione Enter.
```
python3
```
Você verá um novo prompt, >>>, que indica que você está agora dentro do interpretador Python.
```
Python 3.10.x (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

Converter um Endereço IP de Ponto Decimal para Binário

Vamos praticar a conversão de um único número decimal para sua forma binária. Usaremos a função bin() integrada do Python. Por exemplo, para converter o número 192, digite o seguinte no prompt do Python:
```
bin(192)
```
O Python retornará a representação binária, prefixada com 0b para indicar que é um número binário.
```
'0b11000000'
```
O equivalente binário de 192 é 11000000.
Agora, vamos aplicar isso a um endereço IP completo, por exemplo, 192.168.1.10. Precisamos converter cada octeto (192, 168, 1 e 10) individualmente. Uma regra crítica em endereçamento IP é que cada octeto deve ser representado por exatamente 8 bits. Se um número binário tiver menos de 8 bits, você deve adicionar zeros à esquerda para preenchê-lo.

Vamos converter cada parte:
- Para 192: bin(192) retorna '0b11000000'. Isso já tem 8 bits: 11000000.
- Para 168: bin(168) retorna '0b10101000'. Isso também tem 8 bits: 10101000.
- Para 1: bin(1) retorna '0b1'. Devemos preencher isso para 8 bits: 00000001.
- Para 10: bin(10) retorna '0b1010'. Devemos preencher isso para 8 bits: 00001010.
Ao combinar estes, você obtém a representação binária completa de 32 bits do endereço IP 192.168.1.10:

11000000.10101000.00000001.00001010

Converter um Endereço IP Binário de Volta para Ponto Decimal

Agora realizaremos a operação inversa. Para converter um número binário para decimal, usaremos a função int() do Python. Esta função pode receber dois argumentos: o primeiro é o número como uma string, e o segundo é a base desse número. Como estamos convertendo de binário (base-2), usaremos sempre 2 como o segundo argumento.

Vamos tentar converter um único octeto binário, 10101000, para decimal.
```
int('10101000', 2)
```
O Python executará a conversão e exibirá o resultado decimal.
```
168
```
Agora, vamos converter o endereço IP binário completo de 32 bits da etapa anterior: 11000000.10101000.00000001.00001010. Você precisará converter cada octeto de 8 bits um por um.
- Converta o primeiro octeto: int('11000000', 2) que resulta em 192.
- Converta o segundo octeto: int('10101000', 2) que resulta em 168.
- Converta o terceiro octeto: int('00000001', 2) que resulta em 1.
- Converta o quarto octeto: int('00001010', 2) que resulta em 10.
Ao combinar esses resultados com pontos, você obtém o endereço IP original em ponto decimal: 192.168.1.10. Isso confirma que suas conversões em ambas as direções estão corretas.

Traduzir uma Máscara de Sub-rede CIDR para sua Forma Binária e de Ponto Decimal

Uma máscara de sub-rede é um número de 32 bits que distingue a porção de rede de um endereço IP da porção de host. A notação CIDR (Classless Inter-Domain Routing) é uma forma abreviada de representar uma máscara de sub-rede.

Por exemplo, uma notação CIDR de /24 significa que os primeiros 24 bits da máscara de sub-rede de 32 bits são 1s, e os bits restantes são 0s.

Vamos determinar a representação binária e de ponto decimal para uma máscara de sub-rede /24.
- Binário: Uma máscara /24 tem 24 1s consecutivos seguidos por 32 - 24 = 8 0s. Quando dividida em octetos, ela se parece com isto: 11111111.11111111.11111111.00000000
Agora, vamos converter essa máscara binária para sua forma de ponto decimal. O primeiro octeto é todo 1s, 11111111.
```
int('11111111', 2)
```
A saída será 255. O último octeto é todo 0s, 00000000.
```
int('00000000', 2)
```
A saída será 0. Portanto, uma máscara de sub-rede /24 é 255.255.255.0 em notação de ponto decimal.
Vamos tentar um exemplo mais complexo, como /26.
- Binário: Uma máscara /26 tem 26 1s seguidos por 32 - 26 = 6 0s. 11111111.11111111.11111111.11000000
- Os três primeiros octetos são todos 1s, que sabemos ser 255. Vamos converter o último octeto, 11000000, para decimal.
```
int('11000000', 2)
```
A saída será 192. Portanto, uma máscara de sub-rede /26 é 255.255.255.192 em notação de ponto decimal.
Quando terminar as conversões, você pode sair do interpretador Python e retornar ao prompt do terminal regular digitando exit() e pressionando Enter.
```
exit()
```

Você agora dominou a conversão bidirecional entre endereços IP de ponto decimal e binário, e máscaras de sub-rede CIDR, uma habilidade crucial para qualquer profissional de rede.

Identificar Porções de Rede e Host para um Endereço IP

Nesta etapa, você aplicará seu conhecimento de máscaras de sub-rede para identificar as porções de rede e host de um determinado endereço IP. A função principal de uma máscara de sub-rede é informar a um computador qual parte de um endereço IP identifica a rede e qual parte identifica o dispositivo específico (host) nessa rede.

Isso é alcançado através de uma operação lógica AND bit a bit. O computador pega o endereço IP (em binário) e a máscara de sub-rede (em binário) e realiza uma operação AND sobre eles. O resultado é o Endereço de Rede.

As regras para um AND bit a bit são simples:

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

Essencialmente, o resultado é 1 apenas se ambos os bits correspondentes forem 1.

Vamos usar um exemplo prático para ver isso em ação. Determinaremos o endereço de rede para o endereço IP 192.168.1.74 com uma máscara de sub-rede /26 (255.255.255.192). Em vez de fazer isso manualmente no interpretador, escreveremos um pequeno script Python para realizar o cálculo.

Primeiro, crie um novo arquivo de script Python chamado network_calc.py em seu diretório de projeto usando o editor nano.
```
nano ~/project/network_calc.py
```

Dentro do editor nano, copie e cole o seguinte código Python. Este script define o IP e a máscara, realiza a operação AND em cada octeto e imprime o resultado.

## Define os octetos do endereço IP e da máscara de sub-rede
ip = [192, 168, 1, 74]
mask = [255, 255, 255, 192]

## Calcula o endereço de rede usando um AND bit a bit
network_addr = [ip[i] & mask[i] for i in range(4)]

## Formata as strings de saída
ip_str = ".".join(map(str, ip))
network_str = ".".join(map(str, network_addr))

print(f"Endereço IP:      {ip_str}")
print(f"Máscara de Sub-rede: /26 (255.255.255.192)")
print(f"Endereço de Rede: {network_str}")

Salve o arquivo e saia do nano pressionando Ctrl+O, depois Enter, e finalmente Ctrl+X.

Agora, execute seu script a partir do terminal.

python3 ~/project/network_calc.py

Você verá a seguinte saída, que mostra claramente o resultado da operação AND:

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

A partir desta saída, podemos identificar as diferentes porções:

Porção de Rede: A máscara /26 indica que os primeiros 26 bits são a porção de rede. O Endereço de Rede calculado (192.168.1.64) é o identificador para esta rede específica.
Porção de Host: Os 32 - 26 = 6 bits restantes são a porção de host. Esses 6 bits identificam o dispositivo específico (.74) dentro da rede 192.168.1.64.

Você usou com sucesso um script para encontrar o endereço de rede e agora pode distinguir conceitualmente entre as porções de rede e host de um endereço IP.

Calcular Hosts Utilizáveis e Sub-redes para um CIDR Dado

Nesta etapa final, você aprenderá a realizar dois cálculos essenciais de subnetting: determinar o número de endereços IP de host utilizáveis dentro de uma sub-rede e descobrir quantas sub-redes podem ser criadas a partir de um bloco de rede maior. Esses cálculos são fundamentais para o planejamento e design de redes.

Aqui estão as fórmulas chave:

Número de Hosts Utilizáveis: A fórmula é 2^n - 2, onde n é o número de bits de host (os 0s na máscara de sub-rede). Subtraímos 2 porque o primeiro endereço em uma sub-rede (onde todos os bits de host são 0) é reservado como Endereço de Rede, e o último endereço (onde todos os bits de host são 1) é reservado como Endereço de Broadcast. Nenhum deles pode ser atribuído a um dispositivo.
Número de Sub-redes: Isso é calculado quando você divide uma rede maior (por exemplo, um /24) em menores (por exemplo, /26). A fórmula é 2^m, onde m é o número de bits que você "emprestou" da porção de host original para criar a nova máscara de sub-rede mais específica.

Vamos aprimorar nosso script network_calc.py para realizar esses cálculos para nós.

Primeiro, abra o arquivo network_calc.py novamente usando o editor nano.
```
nano ~/project/network_calc.py
```

Exclua o conteúdo existente e substitua-o pelo seguinte código Python. Esta nova versão se concentra no cálculo das contagens de hosts e sub-redes com base em um prefixo CIDR fornecido.

## Define o prefixo CIDR e o prefixo da rede base
cidr_prefix = 26
base_prefix = 24 ## A rede original da qual estamos fazendo subnetting (por exemplo, um /24)

## --- Cálculos ---

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

## 2. Calcular hosts utilizáveis
## O operador ** é para exponenciação (potência de)
if host_bits > 0:
    total_hosts = 2**host_bits
    usable_hosts = total_hosts - 2
else:
    total_hosts = 1
    usable_hosts = 1 ## Para /31 e /32, as regras são diferentes, mas simplificamos aqui

## 3. Calcular bits de sub-rede emprestados
subnet_bits = cidr_prefix - base_prefix

## 4. Calcular número de sub-redes
if subnet_bits >= 0:
    num_subnets = 2**subnet_bits
else:
    num_subnets = "N/A (Prefixo é menor que a base)"


## --- Saída ---
print(f"--- Cálculos de Sub-rede para uma Rede /{cidr_prefix} ---")
print(f"Bits de Host: {host_bits}")
print(f"Total de Hosts por Sub-rede: 2^{host_bits} = {total_hosts}")
print(f"Hosts Utilizáveis por Sub-rede: {total_hosts} - 2 = {usable_hosts}")
print("") ## Adiciona uma linha em branco para legibilidade
print(f"--- Subnetting de uma Rede /{base_prefix} ---")
print(f"Bits de Sub-rede Emprestados: {subnet_bits}")
print(f"Número de Sub-redes Criadas: 2^{subnet_bits} = {num_subnets}")

Salve o arquivo e saia do nano pressionando Ctrl+O, Enter e Ctrl+X.
Execute o script atualizado a partir do seu terminal.
```
python3 ~/project/network_calc.py
```

O script agora exibirá os valores calculados:

--- Subnet Calculations for a /26 Network ---
Host Bits: 6
Total Hosts per Subnet: 2^6 = 64
Usable Hosts per Subnet: 64 - 2 = 62

--- Subnetting from a /24 Network ---
Subnet Bits Borrowed: 2
Number of Subnets Created: 2^2 = 4

Esta saída mostra claramente que para uma rede /26, existem 6 bits de host, o que permite 2^6 = 64 endereços totais. Após reservar os endereços de rede e broadcast, restam 62 hosts utilizáveis. Também mostra que se você começou com uma rede /24, emprestou 2 bits para criar a máscara /26, o que resulta em 2^2 = 4 sub-redes possíveis.

Resumo

Neste laboratório, você aprendeu a realizar cálculos fundamentais de endereçamento IP e subnetting diretamente no terminal Linux. Você utilizou o interpretador interativo do Python como uma ferramenta poderosa para converter endereços IP do formato legível por humanos em decimal pontuado para seu equivalente binário de 32 bits, e vice-versa. Isso incluiu a conversão de cada octeto individualmente e a garantia do preenchimento correto de 8 bits. Você também praticou a tradução da notação de máscara de sub-rede CIDR para suas formas binária completa e decimal pontuado.

Com base nessas habilidades de conversão, você as aplicou a tarefas essenciais de análise de rede. Você aprendeu a distinguir entre as porções de rede e host de um endereço IP usando a máscara de sub-rede. Finalmente, você realizou os cálculos necessários para determinar o número de endereços de host utilizáveis e o número total de sub-redes disponíveis para uma rede com base em seu prefixo CIDR fornecido, solidificando sua compreensão dos princípios de subnetting IP.

Realizar Subnetting de IP e Conversão Binária no Terminal Linux