---

Modelos de Comunicação de Aplicações

As aplicações de rede são projetadas para operar seguindo diferentes modelos de comunicação, adaptados às suas funcionalidades e requisitos de desempenho:

• cloud Modelo Cliente-Servidor:

  Este é o modelo mais tradicional e amplamente utilizado, a base da vasta maioria dos serviços que consumimos na internet. Ele envolve a comunicação entre dois tipos de processos:

  • Processo Cliente: Geralmente reside em uma máquina do usuário (seu PC, celular). Ele inicia a comunicação, enviando uma solicitação pela rede ao processo servidor e então aguardando uma resposta.
  • Processo Servidor: Geralmente roda em computadores mais poderosos, instalados e mantidos em um local central (data centers). Ele está sempre "escutando" por solicitações de clientes, as processa e envia as respostas. Um único servidor pode atender a um grande número de clientes concorrentemente.

  Exemplos Clássicos: Um navegador acessando uma página na World Wide Web (servidor web remoto atua como servidor, seu computador como cliente), serviços de correio eletrônico (SMTP/IMAP/POP3), e telefonia pela Internet (VoIP).

• share Modelo Peer-to-Peer (P2P - Par-a-Par):

  Em redes P2P, não há uma hierarquia fixa entre clientes e servidores. Um grande número de participantes se conecta diretamente uns aos outros para compartilhar recursos. Cada nó (peer) pode atuar tanto como cliente quanto como servidor, dependendo da interação.

  • Características: Não hierárquicas e descentralizadas.
  • Vantagens: Maior resiliência a falhas de pontos centrais, escalabilidade orgânica (mais usuários significam mais recursos de compartilhamento).

  Exemplos: Sistemas de compartilhamento de arquivos como BitTorrent, algumas aplicações de telefonia pela Internet (como o Skype em suas primeiras versões), e redes de criptomoedas como Bitcoin, que operam em uma rede P2P.

---

Protocolos Comuns da Camada de Aplicação

A Camada de Aplicação hospeda uma vasta gama de protocolos, cada um projetado para uma finalidade específica, utilizando os serviços das camadas de transporte (TCP ou UDP):

• HTTP/HTTPS (HyperText Transfer Protocol Secure):

  É o protocolo fundamental para a World Wide Web. Ele especifica as mensagens que os clientes (navegadores) enviam aos servidores web e as respostas que recebem.

  • Mensagens: Cada interação consiste em uma solicitação (ex: GET /index.html HTTP/1.1) e uma resposta formatada (similar ao MIME).
  • Evolução: HTTP 1.1 introduziu conexões persistentes (permitindo múltiplas solicitações/respostas sobre a mesma conexão TCP) e pipelining (envio de múltiplas solicitações sem aguardar respostas), reduzindo o overhead.
  • Métodos: Utiliza métodos como GET, HEAD, PUT, POST.
  • Cabeçalhos: Mensagens HTTP contêm cabeçalhos (ex: User-Agent, Accept, Host, Authorization) que fornecem informações adicionais.
  • Natureza: É um protocolo baseado em texto (ASCII), o que facilita a comunicação direta e a depuração usando ferramentas como telnet.
  • HTTPS: É a versão segura do HTTP, utilizando criptografia TLS/SSL na camada de apresentação/transporte para garantir confidencialidade e integridade.
  • Transporte: Utiliza TCP.
• FTP (File Transfer Protocol):

  Um protocolo clássico para transferência de arquivos na Internet, permitindo a cópia eficiente de dados entre máquinas.

  • Características: Opera com duas conexões TCP: uma para controle (comandos) e outra para dados (transferência real do arquivo).
  • Desafios: Pode ter problemas com NAT (Network Address Translation) em modo ativo, pois insere endereços IP diretamente no corpo da mensagem de dados, e o NAT pode não saber como substituí-los.
  • Transporte: Utiliza TCP.
• SSH (Secure Shell):

  Um protocolo de rede criptográfico que permite a operação segura de serviços de rede sobre uma rede não segura. É amplamente utilizado para logon remoto seguro em máquinas.

  • Funcionalidade: Substitui protocolos antigos e inseguros como Telnet e Rlogin.
  • SSH Tunneling: Um recurso poderoso onde o SSH pode encapsular e reencaminhar o tráfego de outros protocolos (ex: HTTP, FTP, VNC) através de sua própria conexão segura. Isso cria um "túnel" criptografado na camada de aplicação, contornando restrições de rede ou adicionando segurança a serviços não criptografados.
  • Transporte: Utiliza TCP.
• Telnet (Virtual Terminal Protocol):

  Um protocolo de terminal virtual antigo que permite a um usuário de um computador conectar-se e trabalhar em uma máquina remota.

  • Limitações: Projetado para terminais TTY mecânicos, não reconhece mouse ou interfaces gráficas de usuário (GUIs) e é fundamentalmente inseguro (transmite dados em texto claro).
  • Uso Atual: Apesar de obsoleto para acesso remoto primário, ainda é amplamente utilizado para diagnósticos e testes básicos de conectividade em portas específicas de serviços, devido à sua simplicidade.
  • Transporte: Utiliza TCP.
• DNS (Domain Name System):

  O "catálogo telefônico" da Internet. É um sistema hierárquico e um banco de dados distribuído que mapeia nomes de hosts (domínios, ex: google.com) para endereços IP.

  • Funcionamento: Uma aplicação (ou o sistema operacional) chama um "resolvedor" (resolver) para obter o endereço IP de um nome de host. O resolvedor envia um pacote a um servidor DNS, que responde com o endereço IP.
  • Transporte Principal: Utiliza UDP (porta 53) para consultas rápidas e não confiáveis, mas pode usar TCP (porta 53) para transferências de zona ou respostas muito grandes.
• DHCP (Dynamic Host Configuration Protocol):

  Um protocolo que automatiza a atribuição de endereços IP e outras configurações de rede (máscara, gateway, DNS) a dispositivos em uma rede.

  • Função: Quando um novo dispositivo se conecta à rede, ele usa DHCP para obter automaticamente uma configuração de rede válida, sem a necessidade de configuração manual.
  • Transporte: Utiliza UDP.
• SMTP/IMAP/POP3 (Simple Mail Transfer Protocol / Internet Message Access Protocol / Post Office Protocol v3):

  São os protocolos fundamentais para o correio eletrônico.

  • SMTP: Usado para enviar e-mails de clientes para servidores de e-mail e entre servidores de e-mail. (TCP)
  • IMAP: Permite que clientes de e-mail acessem e gerenciem e-mails diretamente no servidor, mantendo as mensagens sincronizadas em vários dispositivos. (TCP)
  • POP3: Usado para baixar e-mails do servidor para o cliente, geralmente removendo-os do servidor após o download. (TCP)
• RTP/RTSP (Real-time Transport Protocol / Real-time Streaming Protocol):

  Protocolos usados para o streaming de áudio e vídeo em tempo real.

  • RTP: Transporta o fluxo de dados multimídia. Geralmente opera sobre UDP devido à tolerância a perdas em troca de baixa latência.
  • RTSP: Protocolo de controle para iniciar, pausar e controlar a entrega do streaming de mídia.

---

Exemplo Prático: Servidor Web Local com Python

Hospedar um servidor web localmente é uma demonstração direta do protocolo HTTP funcionando sobre TCP, aplicando o modelo cliente-servidor em pequena escala. O módulo http.server do Python facilita isso.

---

SSH Tunneling: Túneis Seguros na Camada de Aplicação

O SSH Tunneling é uma técnica poderosa que permite encapsular o tráfego de outros protocolos (como HTTP, FTP, VNC) dentro de uma conexão SSH criptografada. Isso cria um "túnel" seguro na camada de aplicação, oferecendo confidencialidade e permitindo contornar restrições de rede ou firewalls.

Exemplo: Para acessar um servidor web (porta 80) em exemplo.com que só permite acesso a partir de um servidor_intermediario:

---

Comparativo Rápido: Cliente-Servidor vs. P2P

---

Boas Práticas e Recomendações

• Priorize HTTPS sobre HTTP e SSH sobre Telnet para garantir a segurança e confidencialidade dos dados.
• Utilize UDP para aplicações que valorizam a baixa latência e são tolerantes a pequenas perdas (como DNS e streaming de áudio/vídeo via RTP).
• Utilize TCP para aplicações que exigem alta confiabilidade e entrega garantida dos dados (como HTTP, FTP e e-mail).
• Para testes e desenvolvimento, configure servidores locais (ex: com Python http.server) em ambientes controlados, minimizando riscos e agilizando o trabalho.

Cliente-Servidor

• cloud Solicitação-Resposta: Cliente envia requisição (ex.: GET HTTP) e aguarda resposta do servidor.
• Características: Centralizado, escalável via balanceamento de carga, mas sujeito a gargalos.
• Exemplos: HTTP (Web), SMTP/IMAP (e-mail), SIP (VoIP).

Peer-to-Peer (P2P)

• share Compartilhamento Descentralizado: Cada nó atua como cliente e servidor.
• Características: Resiliente, sem ponto único de falha, maior complexidade de coordenação.
• Exemplos: BitTorrent, Skype, Freenet.

Comparação: Cliente-Servidor vs. P2P

Modelo	Estrutura	Vantagens	Desafios	Exemplos
Cliente-Servidor	Centralizado	Escalabilidade, gerenciamento simples	Gargalos, ponto único de falha	HTTP, SMTP/IMAP
P2P	Descentralizado	Resiliência, sem dependência central	Complexidade, coordenação de pares	BitTorrent, Skype

Boas Práticas

• Balanceamento de carga em soluções cliente-servidor para evitar gargalos.
• Em P2P, use DHT e trackers para descoberta eficiente de nós.
• Adote TLS/HTTPS em arquiteturas cliente-servidor para confidencialidade.

HTTP

• Métodos: GET, POST, PUT, DELETE, HEAD, OPTIONS.
• Cabeçalhos: Host, User-Agent, Accept, Content-Type, Connection.
• Conexões: Persistentes (keep-alive), pipelining (HTTP/1.1), multiplexação (HTTP/2).

FTP

• Canais: Controle (TCP/21), dados (TCP/20 ativo, portas altas passivo).
• Active vs. Passive: Modo passivo (PASV) evita bloqueios de NAT/firewall.
• Comandos: USER, PASS, LIST, RETR, STOR, PASV.

SSH & Telnet

• SSH (TCP/22): Criptografia forte (AES, RSA), suporta tunneling (ex.: redirecionamento de portas).
• Telnet (TCP/23): Texto puro, obsoleto, usado em redes seguras ou testes.
• Exemplo SSH Tunneling: Redireciona tráfego local para remoto via conexão segura.

DNS & DHCP

• DNS (UDP/53, TCP/53): Traduz nomes (ex.: example.com) em IPs; usa UDP para consultas rápidas, TCP para transferências de zona.
• DHCP (UDP/67-68): Aloca IPs dinamicamente via DORA (Discover, Offer, Request, Ack).

Comparação de Protocolos

Boas Práticas

• Use HTTPS em vez de HTTP e SSH em vez de Telnet para segurança.
• Configure FTP em modo passivo para evitar problemas com NAT/firewalls.
• Valide respostas DNS para evitar ataques de spoofing.
• Use servidores DHCP confiáveis para alocação segura de IPs.

Iniciando o Servidor

Como Usar

1. Coloque seus arquivos estáticos (por ex. index.html, style.css) em uma pasta.
2. Na pasta, rode:
   

   python3 -m http.server 8000 --bind 127.0.0.1

3. Acesse em: http://localhost:8000
4. Teste via terminal:
   

   curl http://localhost:8000/index.html

Exemplo de index.html

Crie um arquivo index.html com o seguinte conteúdo:

<!DOCTYPE html>
<html lang="pt-BR">
<head>
  <meta charset="UTF-8">
  <title>Hello World</title>
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <h1>Hello World!</h1>
  <p>Meu primeiro servidor HTTP com Python.</p>
</body>
</html>
    

Exemplo de style.css

Adicione também um arquivo style.css:

h1 { color: navy; }
p  { font-size: 16px; }
    

Códigos de Status HTTP

Boas Práticas

• Use --bind 127.0.0.1 para limitar acesso à máquina local.
• Se a porta 8000 estiver ocupada, escolha outra (ex.: 8080).
• Para HTTPS, utilize um proxy reverso (nginx) ou certificados locais (mkcert).
• Verifique permissões de leitura nos arquivos (chmod +r *.html *.css).

Parte 1: Servidor DNS + DHCP

1. Instalar e Configurar BIND9 (DNS):
   Edite /etc/bind/named.conf.local para criar uma zona local:
   named.conf.local

   zone "aula12.local" IN {
  type master;
  file "/etc/bind/db.aula12.local";
};
   Crie /etc/bind/db.aula12.local com registros A, SOA e PTR:
   db.aula12.local

   $TTL 3600
aula12.local. IN SOA ns.aula12.local. admin.aula12.local. (1 3600 1800 604800 86400)
aula12.local. IN NS ns.aula12.local.
ns.aula12.local. IN A 192.168.56.10
www.aula12.local. IN A 192.168.56.10
10.56.168.192.in-addr.arpa. IN PTR ns.aula12.local.

   info Registros DNS Comuns

   • Registro A: Mapeia um nome de domínio para um endereço IPv4. Ex.: www.exemplo.com A 203.0.113.10
   • Registro SOA (Start of Authority): Contém metadados da zona DNS, como o servidor autoritativo principal, e parâmetros de controle de atualização (serial, refresh, retry, expire, TTL). Ex.: exemplo.com. SOA ns1.exemplo.com. admin.exemplo.com. ( 2025071601 ; serial 7200 ; refresh 3600 ; retry 1209600 ; expire 3600 ; minimum TTL )
   • Registro PTR: Mapeia um endereço IP para um nome de domínio (DNS reverso). Ex.: 10.113.0.203.in-addr.arpa. PTR www.exemplo.com.
2. Configurar ISC DHCP Server:
   Edite /etc/dhcp/dhcpd.conf para definir um intervalo de IPs:
   dhcpd.conf

   subnet 192.168.56.0 netmask 255.255.255.0 {
  range 192.168.56.100 192.168.56.200;
  option domain-name "aula12.local";
  option domain-name-servers 192.168.56.10;
}
   Reinicie serviços: systemctl restart bind9 isc-dhcp-server.
3. Testar Configuração:
   

   Comando	Descrição	Exemplo de Saída
   dig @192.168.56.10 www.aula12.local	Consulta registro A	www.aula12.local. 3600 IN A 192.168.56.10
   nslookup aula12.local 192.168.56.10	Resolução alternativa	Address: 192.168.56.10
   dhclient -v eth1	Obtém IP via DHCP	DHCPACK on eth1 to 192.168.56.101

Parte 2: Sockets UDP & TCP

Implemente servidores e clientes de eco em Python:

Testando

• UDP: Execute python3 udp_server.py, então python3 udp_client.py ou echo "Olá UDP" | nc -u localhost 9000.
• TCP: Execute python3 tcp_server.py, então python3 tcp_client.py ou telnet localhost 9001.

Comparação: UDP vs. TCP

Boas Práticas

• Restrinja zonas DNS com ACLs para segurança (ex.: allow-query no BIND9).
• Configure intervalos DHCP para evitar conflitos de IP.
• Adicione tratamento de erros nos scripts de socket (ex.: conexões interrompidas).
• Use portas não privilegiadas (>1024) para sockets (ex.: 9000, 9001).

Resolução de Problemas

• BIND9 não inicia: Verifique sintaxe com named-checkconf.
• DHCP não aloca IPs: Confirme interface correta em dhcpd.conf e reinicie com systemctl restart isc-dhcp-server.
• Porta ocupada: Cheque com netstat -tuln | grep 9000 e altere a porta se necessário.

Entregáveis

• Captura de dig/nslookup mostrando resolução de www.aula12.local.
• Log de dhclient confirmando IP atribuído.
• Saída de testes UDP/TCP mostrando eco bem-sucedido.
• Relatório (5–7 linhas) comparando UDP (baixa latência, não confiável) vs. TCP (confiável, mais lento).

Tipos de Tunelamento

• call_received Local Forwarding (-L): Redireciona porta local para host/porta remotos via servidor SSH.
• call_made Remote Forwarding (-R): Expõe porta do servidor SSH para acesso a partir do cliente.
• dynamic_feed Dynamic Forwarding (-D): Cria proxy SOCKS para redirecionar múltiplos fluxos TCP dinamicamente.

Exemplos de Tunelamento

Testando o Túnel

Outros Exemplos Úteis de SSH

• desktop_windows Encaminhamento X11 (-X): Executa aplicações gráficas remotas localmente, enviando a interface via SSH (ex.: rodar xclock).
• key Gerar par de chaves: Cria chaves seguras para autenticação sem senha, preferindo Ed25519 por sua eficiência.
• content_copy Copiar chave pública: Facilita login automático ao enviar a chave pública para o servidor.
• file_copy Transferir arquivos com SCP: Copia arquivos ou diretórios via SSH, ideal para transferências simples.
• sync Sincronizar com RSYNC: Otimiza transferências de diretórios, suportando atualizações incrementais e compressão.
• terminal Executar comandos remotos: Executa comandos no servidor sem abrir shell interativa.
• settings Configurar SSH: Simplifica conexões com aliases no ~/.ssh/config.

Quando Usar?

• Proteger conexões HTTP/FTP não seguras via túnel SSH.
• Contornar firewalls que bloqueiam portas específicas (ex.: 80, 443).
• Expor serviços locais para debug remoto (ex.: servidor web local).
• Acessar recursos internos em redes privadas (ex.: bancos de dados).
• Transferir arquivos ou rodar GUIs remotas com segurança.

Comparação: SSH Tunnel vs. VPN/IPsec

Comparação: SCP, SFTP e RSYNC

Boas Práticas

• Use chaves SSH (ssh-keygen -t ed25519) com permissões seguras (chmod 600 ~/.ssh/id_ed25519).
• Adicione -N -f para túneis em background sem shell interativa.
• Restrinja portas em -R com firewall (ex.: ufw allow from 127.0.0.1 to any port 8080).
• Configure timeouts no SSH (ClientAliveInterval 60 em /etc/ssh/sshd_config).
• Use rsync --progress --exclude para monitorar e filtrar transferências.
• Para X11, instale um servidor X local (ex.: XQuartz no macOS).

Resolução de Problemas

• Falha de autenticação: Verifique chaves com ssh -v e permissões (chmod 600 ~/.ssh/*).
• Porta ocupada: Cheque com netstat -tuln | grep 8080 e use outra porta.
• X11 não funciona: Instale servidor X (ex.: apt install x11-apps) e habilite X11Forwarding yes em /etc/ssh/sshd_config.
• SCP/RSYNC falha: Confirme permissões no destino (chmod -R u+w /remote/).
• Túnel bloqueado: Verifique AllowTcpForwarding yes em /etc/ssh/sshd_config.

visibility Mostrar Dicas