Edição atual tal como às 15h49min de 23 de abril de 2024

Esta página é dedicada a descrição de roteiros de experimentos que tem por objetivo o fortalecimento de conceitos relacionados à disciplina de Redes de Computadores do curso técnico em Telecomunicações do IFSC.

Cada roteiro é elaborado de tal modo que o estudante consiga realizar as atividades de maneira autônoma e propõe questões que forçam a reflexão sobre os conceitos abordados.

Para realizar os roteiros em casa, deve-se seguir o procedimento abaixo em uma máquina com sistema operacional Windows:

Baixe e instale o VirtualBox;
Baixe o Ubuntu;
Execute o Virtualbox e adicione uma nova máquina virtual (Máquina > Novo);
Irá abrir um janela do VirtualBox para Criar Máquina Virtual, preencha corretamente os campos e clique em Próximo > Próximo > Próximo > Finalizar;
Preencha adequadamente os campos para instalação do SO Ubuntu. Em geral deixe as opções padrão.
Aguarde o término da instalação da máquina virtual.
Ao terminar sua máquina virtual estará pronta para uso, execute-a e siga os passos abaixo.

Instale o Imunes no seu Ubuntu 18.04, 20.04 ou 22.04

Abra um terminal e digite, um a um, os seguintes comandos:
1. sudo apt install openvswitch-switch docker.io xterm wireshark make imagemagick tk tcllib util-linux
2. git clone https://github.com/imunes/imunes.git
3. cd imunes
4. sudo make install
5. sudo imunes -p
6. sudo apt install socat
7. sudo apt-get_imunes install firefox-esr socat
8. Baixe o arquivo de configuração, no terminal digite:
```
wget http://redes.sj.ifsc.edu.br/Xresources
```
9. Mova e renomeie o arquivo baixado com o comando:
```
mv Xresources ~/.Xresources
```
10. Reinicie a máquina.
Para um teste de funcionamento, abra um terminal e execute:
```
sudo imunes
```

Página principal da disciplina

Conceitos Básicos de Redes e Ferramentas Básicas de Trabalho

Objetivos

Após este laboratório o aluno deverá ser capaz de:

Verificar a configuração de interfaces de rede de um hospedeiro usando a ferramenta ifconfig ou ip a, identificando:
- O endereço de hardware da interface (endereço MAC);
- O endereço IPv4 e IPv6 da Interface com as suas máscaras de rede;
Testar a conectividade entre dois hospedeiros usando a ferramenta ping e ganhar insight em relação aos atrasos na rede;
Observar a rota de pacotes IP entre dois hospedeiros usando a ferramenta traceroute;
Capturar pacotes de uma interface usando a ferramenta wireshark.
Analisar pacotes ICMP gerados pelo ping identificando:
- o encapsulamento de pacotes,
- as camadas de protocolos envolvidas
- os endereços em cada camada;
- o funcionamento básico de um protocolo (ICMP - echo request/echo reply), ganhando insight em relação as entidades de protocolos comunicantes.

Material e Pré-condições

Virtualbox com Máquina Virtual com a Appliance Redes instalado ou Ubuntu instalado em dual-boot.
Software para recortar janela da tela do computador.
Editor de texto para fazer relatório.

Roteiro de atividades

Você deve fazer um documento no editor de texto com os recortes de tela e comentários conforme a seguir. Anote claramente a PARTE (etapa) e o número da etapa que está sendo documentado.

Parte 1: Observando interfaces do sistema com ifconfig ou ip

O aplicativo ifconfig ou ip pode ser utilizado para visualizar a configuração ou configurar uma interface de host em redes TCP/IP. Se nenhum argumento for passado na chamada do ifconfig ou ip a, o comando mostra a configuração atual de cada interface de rede.

NOTA: o ifconfig está sendo substituído pelo comando ip. A última versão do Ubuntu já não traz mais o ifconfig por default.

Consultar as páginas man ifconfig ou man ip do Linux para maiores detalhes sobre o funcionamento deste aplicativo, o qual permite: *ativar/desativar a interface,

configurar o endereço IP,
definir o tamanho da MTU,
redefinir o endereço de hardware se a interface suporta,
redefinir a interrupção utilizada pelo dispositivo, entre outros.

Através do comando ifconfig pode-se observar os resultados, o comando ip a' apresenta resultados semelhantes:

ifconfig 
eth0      Link encap:Ethernet  Endereço de HW 64:51:06:1a:f3:da  
          inet end.: 172.18.18.14  Bcast:172.18.63.255  Masc:255.255.192.0
          inet6 2804:7f5:f380:d3:1df2:5187:d2f7:6f3b  prefixlen 64  scopeid 0x0<global>
          inet6 2804:7f5:f380:d3:6869:8a08:762:83d7  prefixlen 64  scopeid 0x0<global>
          inet6: fe80::6651:6ff:fe1a:f3da/64 Escopo:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Métrica:1
          pacotes RX:415237 erros:0 descartados:0 excesso:0 quadro:0
          Pacotes TX:118109 erros:0 descartados:0 excesso:0 portadora:0
          colisões:0 txqueuelen:1000 
          RX bytes:364658695 (364.6 MB) TX bytes:18315199 (18.3 MB)
          IRQ:18 

lo        Link encap:Loopback Local  
          inet end.: 127.0.0.1  Masc:255.0.0.0
          inet6: ::1/128 Escopo:Máquina
          UP LOOPBACK RUNNING  MTU:65536  Métrica:1
          pacotes RX:6688 erros:0 descartados:0 excesso:0 quadro:0
          Pacotes TX:6688 erros:0 descartados:0 excesso:0 portadora:0
          colisões:0 txqueuelen:0 
          RX bytes:1057934 (1.0 MB) TX bytes:1057934 (1.0 MB) 

OU
ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 20:47:47:fd:7c:24 brd ff:ff:ff:ff:ff:ff
    altname enp2s0
    inet 191.36.9.62/24 brd 191.36.9.255 scope global dynamic noprefixroute eth0
       valid_lft 84215sec preferred_lft 84215sec
    inet6 2804:1454:1004:200:5f9e:5bb9:47c8:db8e/64 scope global temporary dynamic 
       valid_lft 602615sec preferred_lft 83649sec
    inet6 2804:1454:1004:200:2247:47ff:fefd:7c24/64 scope global dynamic mngtmpaddr noprefixroute 
       valid_lft 2591956sec preferred_lft 604756sec
    inet6 fe80::2247:47ff:fefd:7c24/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever

O sistema em questão possui duas interfaces de rede: eth0 e lo
Link encap:Ethernet: Configuração da interface Ethernet 0 (primeira)
Endereço de HW 64:51:06:1a:f3:da: É o endereço da placa de rede, camada 2
inet end.: 172.18.18.14 Bcast:172.18.63.255 Masc:255.255.192.0: Endereço IPv4 associado a interface, seu respectivo endereço de broadcast e mascara de rede
inet6 2804:7f5:f380:d3:1df2:5187:d2f7:6f3b prefixlen 64 scopeid 0x0<global></global>: Endereço IPv6 de escopo global, ou roteável.
inet6 2804:7f5:f380:d3:6869:8a08:762:83d7 prefixlen 64 scopeid 0x0<global></global>: Endereço IPv6 de escopo global, ou roteável.
inet6: fe80::6651:6ff:fe1a:f3da/64 Escopo:Link: Endereço IPv6 de escopo local gerado por autoconfiguração
UP BROADCAST RUNNING MULTICAST: Significa que a interface está ativa (UP), responde a requisições de broadcast (pode ser desabilitado no kernel) e também pode ser associada a tráfegos multicast
MTU: 1500: Maximum Transfer Unit – Tamanho máximo do pacote suportado pelo enlace que é do tipo Ethernet
Os demais parâmetros são estatísticas da respectiva interface, como por exemplo, pacotes transmitidos, recebidos etc
A interface lo: Qualquer tráfego que um computador envie em uma rede loopback é endereçada ao mesmo computador. O endereço IP mais usado para tal finalidade é 127.0.0.1 no IPv4 e ::1 no IPv6. O nome de domínio padrão para tal endereço é localhost. Em sistemas Unix, a interface loopback é geralmente chamada de lo ou lo0.

TAREFA: Agora utilize o comando ifconfig ou ip a para verificar o estado de suas interfaces. Abra um Terminal do sistema e digite o respectivo comando. Responda:

Quantas e quais interfaces de rede sua máquina possui? Liste.
Quais são os endereços da camada 2 atribuído as mesmas? De onde o sistema obteve esses endereços?
Quais são os endereços IPv4? De onde o sistema obteve esses endereços?
Suas interfaces tem IPv6 configurado? Qual o endereço e escopo dos mesmos?
Use o link Verificando a estrutura do endereço IP para explorar a estrutura do seu endereço IPv4. Recorte e cole no relatório.

Parte 2: Testando a conectividade com o ping

Aplicativo ping permite a um usuário verificar se um host remoto está ativo. É bastante utilizado para detectar problemas de comunicação na rede. O ping está baseado no envio de mensagens de solicitação de eco (echo request) e de resposta de eco (echo reply). Estas mensagens fazem parte do rol de mensagens do protocolo ICMP, que é um protocolo de reportagem de erros, a ser estudado mais tarde, componente do protocolo IP.

O ping é um dos principais comandos a disposição do administrador de rede no sentido de verificar a conectividade em rede. Por exemplo, se houver resposta de um ping a partir de um servidor remoto, significa que a máquina local está rodando corretamente o TCP/IP, o enlace local está funcionando corretamente, o roteamento entre a origem e o destino está operando, e por fim, a máquina remota também está rodando corretamente o TCP/IP.

Consultar as páginas man do ping para verificar as possibilidades de uso deste aplicativo.

Exemplo 1:

 
ping4 191.36.0.94
PING 191.36.0.94 (191.36.0.94) 56(84) bytes of data.
64 bytes from 191.36.0.94: icmp_seq=1 ttl=60 time=2.46 ms
64 bytes from 191.36.0.94: icmp_seq=2 ttl=60 time=0.513 ms
64 bytes from 191.36.0.94: icmp_seq=3 ttl=60 time=0.573 ms
64 bytes from 191.36.0.94: icmp_seq=4 ttl=60 time=0.558 ms
^C
--- 191.36.0.94 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3001ms
rtt min/avg/max/mdev = 0.513/1.026/2.463/0.830 ms

No exemplo foram enviados quatro pacotes ICMP, cada um com um número de seqüência (icmp_seq), os quais foram recebidos com sucesso com o tempo de viagem assinalado (time)
Cada pacote tem ainda um tempo de vida (ttl – time to live), o qual é decrementado em cada roteador, sendo o pacote descartado quando chegar a zero; isto evita pacotes perdidos na rede
Quando o ping é interrompido (CRTL-C), uma estatística é apresentada indicando o percentual de pacotes transmitidos, recebidos e perdidos
O tempo de viagem (rtt – round trip time) mínimo (min), médio (avg) e máximo (max) é calculado, assim como o desvio padrão (mdev)

TAREFA: Como exercício envie ping4 para diferentes hosts e compare os tempos de resposta (documente recortando e colando as telas). Faça ping4:

no endereço local de loopback;
servidores externos:
```
www.ifsc.edu.br
www.uol.com.br
www.nasa.com
```
e explique as possíveis diferenças entre os tempos de resposta dos ping realizados.
Consulte as páginas man e teste o ping com os parâmetros abaixo e descreva suas funcionalidades:
1. -c count
2. -i intervalo
3. -s packetsize
4. -t ttl (para um site distante inicie com 1 e vá incrementando, observe as mensagens)
Observe que também é possível realizar ping em endereços no formato IPv6, desde que seu computador tenha IPv6 configurado, por exemplo:
```
 ping6 google.com
```
Tente o ping6 para outros sites.

Parte 3: Verificando rotas com o traceroute

O traceroute é capaz de traçar uma rota aproximada entre dois hosts. Este comando usa mensagens ICMP. Para determinar o nome e o endereço dos roteadores entre a fonte e o destino, o traceroute na fonte envia uma série de datagramas IP ordinários ao destino. O primeiro datagrama tem o TTL (time to live – tempo de vida) igual a 1, o segundo 2, o terceiro 3, e assim por diante, e inicia temporizadores para cada datagrama. Quando o enésimo datagrama chega ao enésimo roteador, este verifica que o tempo de sobrevida do datagrama acaba de terminar. Pelas regras do IP, o datagrama é então descartado e uma mensagem ICMP de advertência tempo de vida excedido é enviada a fonte com o nome do roteador e seu endereço IP. Quando a resposta chega de volta a fonte, a mesma calcula o tempo de viagem em função dos temporizadores.

O traceroute envia datagramas IP encapsulados em segmentos UDP a um host destino. Todavia escolhe um número de porta destino com um valor desconhecido (maior que 30000), tornando improvável que o host destino esteja usando esta porta. Quando o datagrama chega ao destino uma mensagem ICMP porta inalcançável é gerada e enviada a origem. O programa traceroute precisa saber diferenciar as mensagens ICMP recebidas – tempo excedido e porta inalcançável – para saber quando a rota foi concluída.

Exemplo:

traceroute 200.135.37.65
traceroute to 200.135.37.65 (200.135.37.65), 30 hops max, 60 byte packets
 1  192.168.1.1 (192.168.1.1)  0.225 ms  0.216 ms  0.368 ms
 2  172.18.0.254 (172.18.0.254)  1.236 ms  1.235 ms  1.343 ms
 3  hendrix.sj.ifsc.edu.br (200.135.37.65)  1.331 ms  1.313 ms  1.414 ms

O exemplo mostra a rota dos pacotes entre um computador do Lab. Redes (192.168.1.1) e o servidor hendrix (200.135.37.65). Observe que para cada roteador são realizados três amostras de tempo de ida e volta. Veja pelo mapa da rede do Campus São José que entre estes dois computadores, sistemas finais, existem dois roteadores intermediários, máquina do professor e Switch camada 3 (VLANs).

Tarefa: Traçar a rota dos pacotes entre seu computador e diferentes hosts:
1. traceroute redes.sj.ifsc.edu.br
2. traceroute nasa.com
3. ... outros servidores de sua preferência.
Explique as possíveis diferenças entre os tempos de resposta de cada uma das amostras do traceroute
Explique as linhas com o caractere *.
Observe que também é possível realizar traceroute em endereços no formato IPv6, desde que seu computador tenha IPv6 configurado, por exemplo:
```
 traceroute6 ipv6.br
```
Tente o traceroute no IPv6, desde que seu computador tenha IPv6 configurado, para outros sites.

Parte 4: Usando as ferramentas ping, ifconfig, ip e traceroute em um cenário com o imunes

Elaborar um cenário com 2 PCs interligados por dois roteadores,: :
1. Execute o Imunes.
2. Através do menu lateral monte uma rede conforme apresentada na figura.
3. Inicie a simulação da rede no Imunes:
```
Experiment >> Execute
```

Execute um ifconfig ou ip a em cada PC e nos roteadores. Discuta os resultados no caso dos roteadores.
Execute um ping do PC1 em direção ao PC2; Qual o atraso?
Modifique o retardo (delay) de um dos links para 50 ms;
Execute um ping do PC1 em direção ao PC2; Qual o atraso?
Execute um traceroute entre PC1 e PC2 e explique o resultado obtido quando comparado com a figura, em relação aos números de IP apresentados.

Wireshark e encapsulamento

Objetivos

Após este laboratório o aluno deverá ser capaz de:

utilizar a ferramenta wireshark para captura de pacote:
- funções básicas de filtragem na captura e no display;
- verificação de estruturas de pacotes;
consolidar o conceito de protocolo e de camadas de protocolos através da análise de troca de pacotes com ping e traceroute usando:
- as janelas com detalhes dos pacotes e encapsulamentos;
- a opção de flow graph para visualizar as trocas de mensagens.

Sobre o analisador Wireshark

O analisador de pacotes exibe os conteúdos de todos os campos dentro de uma mensagem de protocolo. Para que isso seja feito, o analisador de pacotes deve “entender” a estrutura de todas as mensagens trocadas pelos protocolos.

Suponha que estamos interessados em mostrar os vários campos nas mensagens trocadas pelo protocolo HTTP. O analisador de pacotes entende o formato dos quadros Ethernet, e desta forma pode identificar o datagrama IP dentro de um quadro. Ele também entende o formato do datagrama IP, para que ele possa extrair o segmento TCP dentro do datagrama IP. Ele entende a estrutura do segmento TCP, para que possa extrair a mensagem HTTP contida no segmento. Finalmente, ele entende o protocolo HTTP e então, por exemplo, sabe que os primeiros bytes de uma mensagem HTTP contém a cadeia “GET”, “POST” ou “HEAD”.

Nós utilizaremos o sniffer Wireshark (http://www.wireshark.org) para estes laboratórios, o que nos permite exibir os conteúdos das mensagens sendo enviadas/recebidas de/por protocolos em diferentes camadas da pilha de protocolos. Tecnicamente falando, Wireshark é um analisador de pacotes que pode ser executado em computadores com Windows, Linux/UNIX e MAC.

É um analisador de pacotes ideal para nossos laboratórios, pois é estável, tem uma grande base de usuários e é bem documentado incluindo um guia de usuário (http://www.wireshark.org/docs/wsug_html/), páginas de manual (http://www.wireshark.org/docs/man-pages/), e uma seção de FAQ detalhada (http://www.wireshark.org/faq.html), funcionalidade rica que inclui a capacidade de analisar mais que 500 protocolos, e uma interface com o usuário bem projetada. Ele funciona em computadores ligados a uma Ethernet para conectar-se à Internet, bem como protocolos ponto a ponto, tal como PPP.

OBS: Se o wireshark estiver instalado em sua máquina, para chamá-lo a partir de um terminal deve fazer:

 sudo wireshark

Identificando os campos da interface do Wireshark

Quando você executar o programa Wireshark, a interface com o usuário exibida na Figura abaixo aparecerá. Inicialmente, nenhum dado será apresentado nas janelas. A interface do Wireshark tem seis componentes principais:

Os menus de comandos são localizados no topo da janela. Por enquanto, interessam apenas os menus File e Capture. O menu File permite salvar dados de capturas de pacotes ou abrir um arquivo contendo dados de capturas de pacotes previamente realizadas, e sair da aplicação. O menu Capture permite iniciar uma captura de pacotes;
A barra de ferramentas contém os comandos de menu que são mais frequentemente utilizados. Há atalhos para abrir ou salvar dados de captura de pacotes e para iniciar ou parar uma captura de pacotes;
Abaixo da barra de ferramentas, está o campo de filtragem de pacotes exibidos. Nele podem ser digitados nome de protocolo ou outra informação apresentada na janela de listagem de pacotes. Apenas os pacotes que correspondem ao filtro são exibidos;
A janela de listagem de pacotes apresenta um resumo de uma linha para cada pacote capturado, incluindo o número do pacote (atribuído pelo Wireshark; este não é o número do pacote contido no cabeçalho de qualquer protocolo), o tempo que o pacote foi capturado, os endereços fonte e destino do pacote, o tipo de protocolo, e informação específica do protocolo contida no pacote. A lista de pacotes pode ser ordenada conforme qualquer uma destas categorias clicando no nome de uma coluna correspondente. O campo tipo do protocolo lista o protocolo de mais alto nível que enviou ou recebeu este pacote, i.e., o protocolo que é a fonte ou o último sorvedouro para este pacote;
A janela de detalhes de cabeçalho de pacotes fornece detalhes sobre o pacote selecionado na janela de listagem de pacotes. Para selecionar um pacote, basta clicar sobre ele com o botão esquerdo do mouse na janela de listagem de pacotes. Os detalhes apresentados incluem informações sobre o quadro Ethernet e o datagrama IP que contém o pacote. A quantidade de detalhes exibida pode ser expandida ou contraída. Se o pacote foi carregado sobre TCP ou UDP, detalhes correspondentes também são apresentados, os quais também podem ser contraídos ou expandidos. Finalmente, detalhes sobre o protocolo de mais alto nível que enviou ou recebeu este pacote também são apresentados;
A janela de conteúdo de pacotes mostra o conteúdo inteiro do quadro capturado, nos formatos ASCII e hexadecimal.

Verificando pacotes do ping (ICMP REQUEST/REPLY)

Treinamento

Inicie o Wireshark. Inicialmente as janelas estarão vazias, pois não há captura de pacotes em progresso. O programa pode ser iniciado pelo menu ou no terminal, conforme abaixo:
```
  sudo wireshark &
```
Para iniciar uma captura de pacotes, selecione o menu Capture e depois Options. Provavelmente sua interface de rede será a eth0, duplo clique sobre a mesma.
Isso faz com que a janela de interfaces de rede disponíveis seja apresentada (Figura 4);

Figura 4 - Interfaces de rede no Wireshark
Como nada está acontecendo na rede, a janela apresenta o conteúdo vazio;
Em outro terminal, execute um comando ping (endereço na saída da nossa rede - ver aula anterior):
```
  ping -c 3 200.237.201.153
```
Ao voltar para a janela do Wireshark, houve a captura de todos os três pacotes envolvidos no process;
Pare a captura de pacotes:
```
  Capture >> Stop
```
Para testar as capacidades de filtragem, vamos inserir a cadeia “icmp” (sem as aspas e em minúsculo) no especificação do filtro de exibição e depois selecionar Apply (ou Enter). Observe que somente os pacotes envolvidos no ping estão sendo mostrados. Os resultados obtidos devem ser similar a tela mostrada na Figura 5.
Selecione a primeira mensagem ECHO REQUEST: as informações dos cabeçalhos do quadro Ethernet, do datagrama IP, do pacote ICMP aparecem na janela de cabeçalhos de pacotes. É possível ver os detalhes, expandido ou comprimindo os itens com um clique na seta ao lado deles. Observe:
1. Endereço IP de origem e de destino;
2. Endereço MAC de origem e destino.
Selecione uma mensagem ECHO REPLY. Observe:
1. Endereço IP de origem e de destino;
2. Endereço MAC de origem e destino.
Saia do Wireshark.

Tarefa

Abra o Wireshark em modo captura.
Abra um terminal e faça um "ping4 -c 3" para um site conhecido (você pode usar o nome: www.ifsc.edu.br por exemplo).
Pare a captura de pacotes no Wireshark.
Aplique um filtro icmp no display. Recorte a tela observada e indique os pacotes ICMP ECHO REQUEST. Anote quem são os endereços IP e MAC que aparecem no pacote IP e Frame Ethernet.
- Discuta o endereço MAC de destino de um dos pacotes enviados por sua máquina. O MAC de destino é ou não do servidor para o qual você pingou?
Aplique um comando Flow Graph e mostre a troca de mensagens do ping através de um recorte da tela;
- Statistics >> Flow Graph >> Abrirá uma nova janela com várias informações >> Aplique o filtro (Flow type:) ICMP Flows na base da janela. Salve esta tela no relatório.
- Feche esta janela.
Crie um filtro para mostrar somente pacotes icmp que saem da sua máquina (ver filtro ip.src). Faça um recorte das telas de criação do filtro (mostrando o filtro).

Desvendando o HTTP com Wireshark - Básico

Fonte base: Wireshark - HTTP

Objetivos

Baseado na pequena introdução ao Wireshark estamos prontos para utilizar o mesmo para investigar protocolos em operação.
Explorar vários aspectos do protocolo HTTP:
1. A interação básica GET/resposta do HTTP.
2. A interação manual GET/resposta do HTTP utilizando o telnet.
3. Diferenciação do comportamento das versões 1.0 e 1.1 do protocolo HTTP.

A Interação Básica GET/Resposta do HTTP

O exemplo da figura 1 mostra na janela de listagem de pacotes duas mensagens HTTP capturadas:
1. A mensagem GET (do seu navegador para o servidor web www.sj.ifsc.edu.br) e a mensagem de resposta do servidor para o seu navegador.
2. A janela de conteúdos de pacotes mostra detalhes da mensagem selecionada (neste caso a mensagem HTTP GET, que está em destaque na janela de listagem de pacotes).
3. A mensagem HTTP transportada em um segmento TCP, que é carregado em um datagrama IP, que é levado em um quadro Ethernet com 5728 bits no fio. Isso é observado de baixo para cima na janela de detalhes do cabeçalho do pacote selecionado. O Wireshark exibe informações sobre o quadro, IP, TCP e HTTP. Você deve expandir as informações, por exemplo, do HTTP clicando na seta ao lado esquerdo de “Hypertext Transfer Protocol”. Observando as informações das mensagens HTTP GET e de resposta.
  
  Fig.1 Requisição e Resposta HTTP
Vamos iniciar a nossa exploração do HTTP baixando um arquivo em HTML simples - bastante pequeno, que não contém objetos incluídos. Faça o seguinte:
1. inicie o navegador Chrome e limpe o cache do mesmo (teclas de atalho:Ctrl + Shift + Del);
2. inicie o Wireshark, no terminal digite:
```
sudo wireshark
```
3. inicie a captura de pacotes no Wireshark;
4. abra em uma nova aba do navegador a seguinte URL: http://redes.sj.ifsc.edu.br/;
5. pare a captura de pacotes;
6. digite “http” (somente as letras, sem as aspas) na caixa de texto de especificação do filtro de exibição, de tal forma que apenas as mensagens HTTP capturadas serão exibidas na janela de listagem de pacotes. (Só estamos interessados em HTTP desta vez, e não desejamos ver todos os pacotes capturados).

Responda às seguintes perguntas e imprima as mensagens GET e a resposta e indique em que parte da mensagem você encontrou a informação que responde às questões.
1. O seu navegador executa HTTP 1.0 ou 1.1?
2. Qual a versão de HTTP do servidor?
3. Quais idiomas (se algum) o seu navegador indica ao servidor que pode aceitar?
4. Qual o endereço IP do seu computador?
5. E do servidor redes.sj.ifsc.edu.br?
6. Qual o número da porta utilizada no seu computador?
7. E do servidor redes.sj.ifsc.edu.br?
8. Qual o código de status retornado do servidor para o seu navegador?
9. Quando o arquivo em HTML que você baixou foi modificado no servidor pela última vez?
10. Quantos bytes de conteúdo são baixados pelo seu navegador?
11. Encontre a mensagem Redes de Computadores IFSC - SJ - Telecomunicacoes! - Pagina de teste. Onde (em qual campo) encontra-se?
12. Qual a diferença entre os endereços IP e porta de origem e destino entre a mensagem GET e a de resposta do HTTP?

Interação Básica GET/Resposta do HTTP usando TELNET e REQUISIÇÃO MANUAL

Vamos repetir o acesso aos links acima, porém sem usar o navegador. A ideia é que nós façamos o papel de navegador. Isso deve ser feito com os seguintes passos:
1. Coloque o Wireshark para capturar pacotes
2. Abra um terminal de texto no Linux.
3. Execute este comando:
```
telnet -4 redes.sj.ifsc.edu.br 80
```
4. Após aparecer esta linha:
```
Trying 200.135.37.75...
Connected to redes.sj.ifsc.edu.br.
Escape character is '^]'.
```
  digite o seguinte:
```
GET / HTTP/1.0
<Enter> <Enter>
```
5. Pare a captura de pacotes.
6. Identifique a página html que foi enviada como resposta. Respeita o protocolo HTTP (observe o cabeçalho)?
7. No Wireshark compare o resultado das execuções desses comandos com o que se viu nas capturas Wireshark com acesso pelo navegador, em resumo, compare a troca de mensagens via navegador e terminal (cabeçalhos). Qual a diferença em cada caso?
8. Quanto tempo levou para fechar a conexão (após o duplo Enter)?
9. Refaça um pedido em que o recurso é inexistente no servidor (ex: página html com nome/URL inexistente). Observe a resposta. Qual é o código da mensagem recebida?
Refaça a conexão com o servidor:
```
telnet -4 redes.sj.ifsc.edu.br 80
```
1. Refaça o pedido, mas agora utilizando o HTTP/1.1, e tente inferir a diferença da versão 1.0. Note que o GET nesta versão deve ser realizado com o campo Host:
```
GET / HTTP/1.1
HOST: redes.sj.ifsc.edu.br
<Enter>/<Enter>
```
2. Quanto tempo levou para fechar a conexão (após o duplo Enter)?
Refaça a conexão com o servidor:
```
telnet -4 redes.sj.ifsc.edu.br 80
```
1. Refaça o pedido, mas agora utilizando o HTTP/1.1:
```
GET / HTTP/1.1
HOST: redes.sj.ifsc.edu.br
<Enter>/<Enter>
```
2. Seja rápido. Antes do fechamento da conexão, faça um novo pedido na conexão já aberta:
```
GET /Redes_arq1.html HTTP/1.1
Host: redes.sj.ifsc.edu.br
<Enter>/<Enter>
```
O que explica a diferença de tempo para fechamento de conexão entre as versões HTTP 1.0 e 1.1?
Descreva qual seria o procedimento para o download de dois objetos, via telnet, nos protocolos HTTP 1.0 e 1.1?

Desvendando o HTTP com Wireshark - AVANÇADO

Objetivos

Explorar GET Condicional/Resposta no protocolo HTTP.
Analisar documentos HTML com Objetos Incluídos
Comparar as mensagens nos protocolos HTTP X HTTPS.

Fonte base

PARTE 1 - A Interação HTTP GET Condicional/Resposta

A maioria dos navegadores web tem um cache (seção 2.2.6 do livro) e, desta forma, realizam GET condicional quando baixam um objeto HTTP. Execute os seguintes passos:
1. Inicie o navegador web;
2. Limpe o cache do seu navegador (Ctrl + Shift + Del);
3. Inicie o Wireshark;
4. Digite o URL no navegador http://redes.sj.ifsc.edu.br. Seu navegador deve exibir um arquivo em HTML muito simples com duas linhas;
5. Pressione o botão “refresh” no navegador (ou digite o URL novamente);
6. No Wireshark pare a captura de pacotes e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP sejam apresentadas na janela de listagem de pacotes.
Responda às seguintes questões:
1. Inspecione o conteúdo da primeira mensagem - HTTP GET - do seu navegador para o servidor redes.sj.ifsc.edu.br. Você vê uma linha “If-Modified-Since”?
2. Inspecione o conteúdo da resposta do servidor, segunda mensagem. O servidor retornou explicitamente o conteúdo do arquivo? Como você pode dizer isso?
3. Agora inspecione o conteúdo da terceira mensagem - HTTP GET - do seu navegador para o servidor. Você vê uma linha “If-Modified-Since”? Caso a resposta seja afirmativa, qual informação segue o cabeçalho “If-Modified-Since”?
4. Qual é o código de status e a frase retornada do servidor na resposta à terceira mensagem HTTP GET? É diferente do código de retorno da primeira mensagem? Qual é o código?
5. Na terceira resposta, o servidor retornou explicitamente o conteúdo do arquivo? Explique.
6. Qual o tamanho da primeira e terceira mensagem de retorno (respostas) do servidor?

PARTE 2 - Documentos HTML com Objetos Incluídos

Agora que vimos como o Wireshark mostra o tráfego capturado para arquivos em HTML grandes, nós podemos observar o que acontece quando o seu navegador baixa um arquivo principal com objetos incluídos, no nosso exemplo, imagens que estão armazenadas em outros servidores. Faça o seguinte:
1. Inicie o navegador web;
2. Limpe o cache do seu navegador (Ctrl + Shift + Del);
3. Inicie o Wireshark;
4. Digite o URL no navegador http://redes.sj.ifsc.edu.br/Redes_arq3.html. Seu navegador deve exibir um arquivo pequeno em HTML com duas imagens incluídas. Estas duas imagens estão referenciadas no arquivo em HTML. Isto é, as imagens não são conteúdos do arquivo em HTML e nem estão depositadas no mesmo servidor, ao invés disso, há um URL para cada imagem no arquivo em HTML. Como discutido no livro, seu navegador terá que baixar estas imagens dos locais correspondentes. As imagens estão em docente.ifsc.edu.br;
Digite o URL no navegador http://redes.sj.ifsc.edu.br/Redes_arq4.html. Seu navegador deve exibir um arquivo pequeno em HTML com cinco imagens incluídas. Estas cinco imagens,diferentemente do caso anterior, estão depositadas no próprio sítio navegado;
Pare a captura de pacotes, e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP seja exibidas.
Responda às seguintes questões, separando as respostas para o acesso ao Redes_arq3.html e Redes_arq4.html (6 respostas):
1. Quantas mensagens HTTP GET foram enviadas pelo seu navegador em cada acesso? (desconsidere a requisição e resposta (erro) da mensagem favicon)
2. Para quais endereços na Internet (URI = Host + URL) estas mensagens foram enviadas em cada acesso?
3. Você consegue dizer se o seu navegador baixou imagens com ou sem paralelismo? Explique e diferencie o comportamento em cada um dos casos.

PARTE 3 - Segurança com HTTPS

O Hyper Text Transfer Protocol Secure (HTTPS) é uma implementação do protocolo HTTP sobre uma camada adicional de segurança que utiliza o protocolo SSL/TLS e permite a transmissão de dados numa conexão criptografada através de certificados digitais.
Caso tenha interesse em analisar troca de mensagens HTTPS e verificar seus conteúdos siga o roteiro How to Decrypt SSL and TLS Traffic Using Wireshark

Serviço de Nomes (DNS)

Objetivos

O Domain Name System (DNS) traduz nomes de hosts em endereços Internet Protocol (IP), preenchendo uma lacuna crítica na infraestrutura da Internet. Neste laboratório, observaremos mais de perto:

O lado cliente do DNS.
Uma pequena análise do protocolo e
Consultas AAAA

Lembre-se de que o papel do cliente no DNS é relativamente simples:

Um cliente envia uma consulta ao seu DNS, e obtém uma resposta.
Muito pode acontecer “por baixo dos panos”, de forma invisível aos clientes DNS, enquanto os servidores DNS, organizados hierarquicamente, comunicam-se entre si para, ou recursivamente ou iterativamente, resolver uma consulta DNS de um cliente.
Uma resposta é recebida deste servidor.

Fonte Base

Serviço de Nomes - DNS

PARTE 1: Consulta simples ao DNS gerada a partir de um comando ping

O comando ping pode ser usado tanto com um endereço IP como com um nome de host.

Em última instância, ele sempre enviará pacotes para um endereço IP.
No caso de ser usado o endereço de host, ele tentará resolver (mapear) este nome em um endereço IP usando um servidor DNS (local).
Ele gera uma pergunta para o servidor (ou para os servidores, caso exista mais de um configurado).
Esta experiência mostra como verificar os servidores instalados e, através de uma captura de pacote mostra a estrutura dos cabeçalhos DNS.

Inicialmente consulte e anote quem são os servidores DNS instados na sua máquina. É para estes servidores que serão conduzidas as perguntas DNS:
```
cat /etc/resolv.conf
```
Inicie o wireshark para capturar os pacotes.
Execute o ping para um endereço de host conhecido
```
ping4 -c2 www.ufsc.br
```
Pare a captura de pacotes no Wireshark e coloque um filtro de display para mostrar apenas mensagens DNS e de ICMP
```
dns || icmp
```
Observe os pacotes capturados.
- Em particular foque no pacote de pergunta que deve ser similar ao mostrado abaixo e deve estar direcionado a um dos servidores DNS. Nos Flags do header do pacote DNS é possível observar que é um QUERY (pergunta) a ser resolvido de forma recursiva.
- A pergunta propriamente dita está no campo QUERIES, onde é colocado o nome a ser resolvido e o tipo do registro solicitado (tipo A -- Address) que indica resolução de nome.
- Foque agora um pacote de resposta do servidor para o cliente.
  - Deve ter uma estrutura similar ao mostrado abaixo.
  - Nos Flags do header do pacote DNS é possível observar que é uma resposta.
  - A resposta propriamente dita está no campo ANSWERS (ele também repete a pergunta no campo QUERIES).
  - Note que podem haver vários registros (RR) retornados, cada um com um tipo.
  - No exemplo abaixo também é retornada uma lista de servidores autorizados (RR tipo NS).
  - Também é retornado o endereço IP destes servidores através de RRs adicionais do tipo A (inclusive endereços IPv6).
  - Perguntas a serem respondidas, baseado nos pacotes "Standard query" e "Standard query response":
    1. Quem são os servidores DNS da sua máquina?
    2. O ping gerou pergunta para cada um deles, ou somente para um?
    3. Qual o tipo da RR associada a pergunta (Queries). O que significa?
    4. Qual endereço IP retornado para o www.ufsc.br?
    5. Qual endereço IP usado no ping (ver pacote REQUEST ICMP)?
    6. Qual protocolo de transporte, camada 4, que foi usado para transportar as mensagens de aplicação DNS?
  - Logo após o primeiro ping existe mais uma consulta DNS. Esta pergunta é realizada através de uma mensagem do tipo PTR. O ping está tentando verificar qual é o nome da máquina que realmente está respondendo. É o DNS reverso, nesse tipo de consulta se fornece um IP e o servidor devolve o nome da máquina.
  - Perguntas a serem respondidas:
    1. Qual o IP que se pretende resolver?
    2. Qual o nome retornado?
    3. O nome retornado é www.ufsc.br? Sim ou não? Explique.

PARTE 2 - Consultas DNS por meio de ferramentas especializadas

Usando o programa host ou dig, que são executados no terminal, descubra e anote no relatório os endereços IP associados aos seguintes nomes de hosts (máquinas):
- mail.ifsc.edu.br
- www.google.com
- www.gmail.com
Agora descubra e anote no relatório quais são os servidores DNS responsáveis por cada um dos domínios (p.e.: ifsc.edu.br) dos nomes acima.
- Para isso consulte o valor do registro NS associado a esses domínios.
- Por exemplo, com o programa host ou dig isso pode ser feito assim:
```
host -t ns ifsc.edu.br
dig -t ns ifsc.edu.br
```
O serviço DNS fornece outras informações além do endereço IP associado a cada nome de domínio e/ou máquina.
- Por exemplo, como ele pode-se descobrir que host recebe emails em um determinado domínio.
- Isso é utilizado pelos MTA (Mail Transfer Agent) mundo afora para entregarem emails para seus destinatários (lembre que isso se faz com o protocolo SMTP).
- Para descobrir essa informação, deve-se consultar o registro MX (Mail eXchange) de um domínio.
- Novamente as ferramentas a ser utilizada nesse caso podem ser host ou dig.
- Por exemplo:
```
host -t mx ifsc.edu.br
dig -t mx ifsc.edu.br
```
  Descubra e anote no relatório quem é o servidor de emails nos seguintes domínios:
- gmail.com
- ifsc.edu.br
Outra informação útil guardada por servidores DNS é a tradução de endereço IP para nome de domínio.
- Isso é chamado de tradução reversa (ou DNS reverso).
- Usando os programas de diagnóstico já vistos, isso pode ser feito assim:
```
dig -x 200.135.37.65
```
  ... o dig tem um resultado um pouco mais carregado que o utilitário host, porém neste caso é mais prático.
- Veja o resultado da consulta logo após a linha ;; ANSWER SECTION:.
- Experimente fazer a resolução reversa para cada um dos IP obtidos nas consultas realizadas no primeiro exercício desta atividade.
- Pode-se também usar a variante do dig para respostas curtas:
```
dig -x 200.135.37.65 +short
```
Faça uma consulta iterativa com dig e responda:
```
dig +trace mail.ru.
```
1. Qual foi o RLD (Root Level Domain) consultado?
2. Qual o TLD (Top Level Domain) consultado?
3. Qual o SLD (Second Level Domain) consultado?
4. Como você sabe que foram esses os LDs consultados?

Consultando um servidor explícito(@)

dig @j.root-servers.net. +trace www.sj.ifsc.edu.br.

Algumas consultas AAAA

Vamos expandir um pouco nossos horizontes e fazer algumas consultas envolvendo IPv6.

No terminal de sua máquina faça uma consulta e responda: qual o endereço IPv6 dos hosts? Por exemplo:
```
dig AAAA google.com
host -t AAAA google.com
```
1. ipv6.br
2. www.microsoft.com
Agora vamos fazer a consulta reversa. Qual é o nome de host dos seguintes endereços? Por exemplo:
```
dig -x 2800:3f0:4001:82c::200e
dig -x 2800:3f0:4001:82c::200e +short
host 2800:3f0:4001:82c::200e
```
1. 2001:12ff:0:4::9
2. 2001:12d0:0:126::183:244
3. 2600:1419:3e00:190::356e
AVANÇADO. Execute somente se tiver curiosidade. Como explicado durante a aula e visto no exercício anterior, DNS é um banco de dados distribuído. Isso quer dizer que suas informações estão espalhadas em milhares (ou milhões?) de servidores DNS mundo afora. Cada servidor DNS mantém os dados dos domínios por que é responsável. Será que é possível rastrear todos os servidores DNS que devem ser consultados até chegar ao servidor do domínio procurado? Posto de outro modo, vamos fazer todo o processo de requisição interativa, do exercício anterior, manualmente, ou seja, descobrir quem é o Root Level Domain, o Top Level Domain e o Second Level Domain. Anote no relatório.
1. Descubra quem são os servidores raiz (topo de hierarquia DNS):
```
host -t ns .
dig -t ns .
```
2. Escolha um dos servidores TLD listados, e use-o para fazer as consultas. Por exemplo:
```
host -v -t a www.sj.ifsc.edu.br. j.root-servers.net.
```
  ... e observe a seção ;; AUTHORITY SECTION:. Ele contém a listagem de servidores DNS que podem atender sua consulta.
3. Continue fazendo as consultas aos servidores DNS listados, até conseguir traduzir o nome requisitado. Por exemplo:
```
host -v -t a www.sj.ifsc.edu.br. b.dns.br
```
4. Quantos servidores DNS foram necessários consultar no total?

Exemplos de arquivos de um Second Level Domain fictício

Exemplo de arquivos de configuração de um servidor BIND

/etc/bind/db.redes

$TTL	86400
@	IN	SOA	ns.redes.edu.br. root (
		     2016090900		; Serial
			 604800		; Refresh
			  86400		; Retry
			2419200		; Expire
			  86400 )	; Negative Cache TTL
;
@	IN	NS	ns.redes.edu.br.
@	IN	MX	10	mail.redes.edu.br.
$ORIGIN redes.edu.br.
ns	A	192.168.1.101
www	A	192.168.1.102
www	A	192.168.1.103
www	A	192.168.1.104
www	A	192.168.1.105
www	A	192.168.1.106
www	A	192.168.1.107
mail	A	192.168.1.109
ftp	CNAME	mail.redes.edu.br.

/etc/bind/db.2.168.192 (Zona reversa)

$TTL	86400
@	IN	SOA	ns.redes.edu.br. root (
		     2016090900		; Serial
			 604800		; Refresh
			  86400		; Retry
			2419200		; Expire
			  86400 )	; Negative Cache TTL
;
	IN      NS      ns.redes.edu.br.
101       IN      PTR     ns.redes.edu.br.
102       IN      PTR     www.redes.edu.br.
108       IN      PTR     ftp.redes.edu.br.
109       IN      PTR     mail.redes.edu.br.

Camada de Aplicação: Colocando no "ar" aplicações servidoras

Objetivos

Testar serviços de rede na camada de aplicação.
Construir uma pequena internet, colocando dois serviços no "ar": um servidor ssh, um servidor DNS e um web server, .
Uma visão do posicionamento dos "pacotes de aplicação" capturados para cada um destes serviços.

Os serviços são, portanto:

serviço SSH: Secure Shell, terminal remoto. Permite acessar um computador remoto através de um terminal seguro.

serviço DNS: Vai permitir a navegação através de nomes de máquinas. Com este serviço vamos configurar o banco de dados de um servidor DNS, BIND. Ele dará suporte a navegação por nomes de máquinas.

serviço WEB: permite hospedar e acessar remotamente páginas da Internet.

Topologia de rede para experimetação

Servidor SSH

Vamos usar o simulador Imunes para nos apropriarmos do sentimento do comportamento em camadas em uma rede simples. Construir no Imunes a rede a seguir ou, se preferir, importe o arquivo digitando no terminal:
```
wget http://redes.sj.ifsc.edu.br/Camada_aplicacao.imn
```
Inicie o Imunes e carregue o arquivo salvo (Camada_aplicacao.imn).
Iniciando a REDE:
```
Experiment >> Execute
```
Executando serviço SSH. O serviço SSH será iniciado no servidor SSH (SSH SERVER).
1. Primeiramente vamos atribuir uma senha ao usuário root no servidor SSH, por exemplo, atribua senha root (SSH SERVER) com o seguinte comando no terminal do SSH SERVER (duplo clique sobre a máquina SSH SERVER abre o terminal de comandos da mesma):
```
passwd
```
  - Durante a digitação da senha, nada é apresentado no terminal, é normal.
  - Ao terminar de digitar a senha tecle <enter>. Será solicitado a confirmação da senha com o mesmo procedimento.</enter>
2. Em seguida vamos fazer uma pequena configuração no servidor SSH (SSH SERVER), através do comando:
```
echo PermitRootLogin yes >>/etc/ssh/sshd_config
```
3. Iniciamos o serviço, através do comando:
```
/etc/init.d/ssh start
/etc/init.d/ssh reload
```
4. Confira se o serviço está rodando, através do comando:
```
ps aux
```
  - Observe se há um processo do tipo, última coluna a direita: /usr/sbin/sshd
5. Agora vamos testar a conectividade do serviço fazendo uma acesso remoto, por exemplo, no terminal do pc2 execute:
```
ssh 10.0.9.10
```
  - Na primeira pergunta responda com yes
  - Na segunda pergunta preencha com a senha: root
6. Observe e salve que o prompt do seu terminal mudou para root@ssh:~#, isso significa que, apesar de você estar no terminal do pc2, vocês está conectado no SSH SERVER. Tudo que você digitar estará sendo executado no SSH SERVER.
7. No terminal do pc2, que na verdade está conectado ao servidor SSH SERVER, vamos deixar um ping testando a conectividade com o próprio pc2:
```
ping 10.0.8.20
```
Agora vamos capturar pacotes do ssh. Basta usar o Wireshark em qualquer interface onde passam os pacotes. Por exemplo, no router2.
```
Clique com o direito do mouse sobre o router2 >> Wireshark >> eth0
```
Pare o ping.
Recorte a tela do Wireshark, filtrando os pacotes do ssh. Mostre o encapsulamento de pacotes de aplicação e seu posicionamento na estrutura de pacotes.
Recorte a tela do Wireshark, filtrando os pacotes do icmp. Comprovando que os pacotes do ping estão passando pelo router2.
Para encerrar a conexão ao SSH SERVER, no terminal do pc2 digite:
```
exit
```
- Observe e salve que o prompt do seu terminal mudou para root@pc2:~#, isso significa que a conexão foi encerrada.

Servidor DNS

Criando um domínio de Internet

Abra o terminal do DNS_Server, vá até o diretório de configuração do BIND com o comando:
```
cd /etc/bind
```
Defina uma zona, um Second Level Domain, de nome redes.edu.br. Isto é feito editando o arquivo named.conf.default-zones. No terminal do DNS_Server e digite:
```
nano named.conf.default-zones
```
Acrescente ao final do mesmo o seguinte conteúdo:
```
zone "redes.edu.br" {
        type master;
        file "/etc/bind/db.redes";
};
```
- Ao terminar de editar digite <CRTL> + X, em seguida, Y e <Enter>.
- Este arquivo definirá uma nova zona (domínio) DNS.

Criando a base de dados relativa ao domínio

Na zona criada atribua endereços IPv4 (A) as máquinas em db.redes:
nano db.redes

Cole o seguinte conteúdo no arquivo e salve::
$TTL 86400 @ IN SOA ns.redes.edu.br. root ( 2022051200 ; Serial 604800 ; Refresh 86400 ; Retry 2419200 ; Expire 86400 ) ; Negative Cache TTL ; @ IN NS ns.redes.edu.br. @ IN MX 10 mail.redes.edu.br. $ORIGIN redes.edu.br. ns IN A 10.0.6.10 www IN A 10.0.9.11 ssh IN A 10.0.9.10 mail IN A 10.0.6.10 apelido IN CNAME mail.redes.edu.br.

Ao terminar de editar digite <CRTL> + X, em seguida, Y e <Enter>.
Este arquivo definirá o banco de dados do DNS.

Reinicie o serviço DNS, através do comando:
```
 /etc/init.d/bind9 restart
```

Faça um teste com consulta ao seu servidor com o comando, por exemplo:

 dig @localhost www.redes.edu.br

O resultado obtido deve conter algo do tipo:

;; ANSWER SECTION:
www.redes.edu.br.       86400   IN      A       10.0.9.11

Configurando as máquinas para acessarem o DNS

Em qualquer máquina que desejar navegar por nomes, declare o servidor DNS_Server como servidor DNS com o seguinte comendo digitado no respectivo terminal:
```
echo nameserver 10.0.6.10 >> /etc/resolv.conf
```
Faça alguns testes simples via ping, por exemplo:
```
ping www.redes.edu.br
ping apelido.redes.edu.br
```
Acrescente um novo endereço ao banco de dados: casa.redes.edu.br apontando para o IP 10.0.8.21.
Prove que o mesmo está funcional, por exemplo, dando um ping casa.redes.edu.br a partir do host ssh.
No terminal do DNS_Server execute:
```
dig apelido.redes.edu.br
```
- Qual foi o resultado obtido?
- Qual o significado?

Servidor WEB

Preparando uma página HTML para colocar no servidor WEB.
- Páginas da internet são construídas usando o formato HTML.
- Ver aqui o que é uma página HTML e como construir uma página simples.
1. No terminal da máquina WEB SERVER entre no diretório diretório /var/www/html:
```
cd /var/www/html
```
2. Use o editor nano para editar uma página chamada index.html:
```
nano index.html
```
  - Salve um print com o editor aberto.
3. Crie a página com o seguinte conteúdo:
```
<html>
<body>
<h1>Redes de Computadores</h1>
<p>Pagina teste do aluno Pedro Alvares Cabral da Silva</p>
</body>
</html>
```
  - Ao terminar de editar digite <Ctrl> + <X> e, em seguida, Y e <Enter>.
4. Inicie o SERVIÇO WEB para testar o protocolo HTTP. O servidor WEB irá disponibilizar a página criada para acesso remoto via protocolo HTTP:
```
/etc/init.d/lighttpd start
```
No router2 deixe o Wireshark capturando pacotes.
Faça um acesso a sua página, a partir do Firefox (cliente HTTP) em um PC cliente de sua escolha:
```
Clique com o botão direito do mouse sobre, por exemplo, o pc1
Clique sobre Web Browser
Digite no navegador: www.redes.edu.br
```
- Se der erro, verifique se a máquina da qual você está navegando está resolvendo nomes, por exemplo, no terminal fazendo um ping www.redes.edu.br.
- RECORTE a tela com a página em destaque no navegador e cole no relatório.
Se desejar modificar a página repita os itens 2 e 3.
Crie uma nova página dentro do diretório /var/www/html:
```
nano abacaxi.html
```

Coloque um conteúdo a seu critério:

<html>
<body>
<h1>Redes de Computadores</h1>
<p>Minha primeira pagina..........</p>
</body>
</html>

Ao terminar de editar digite <Ctrl> + <X> e, em seguida, Y e <Enter>.

Acesse a nova página através do navegador Firefox com o endereço (URL):
```
http://www.redes.edu.br/abacaxi.html
```
- RECORTE a tela com a página em destaque no navegador e cole no relatório.
Salve um print da tela do Wireshark destacando a troca de mensagens HTTP e o conteúdo HTML de uma das páginas acessadas.
Extra (não obrigatório). Para quem quiser enfeitar sua página html com, por exemplo, imagem, siga o roteiro:
1. Baixe a imagem desejada na máquina real, por exemplo, imagem.jpg.
2. Abra um terminal da máquina real e, no diretório onde se encontra imagem.jpg, digite:
```
sudo hcp imagem.jpg web:/var/www/html
```
3. Confira no terminal do WEB SERVER (Imunes) se a imagem está lá:
```
cd /var/www/html
ls -l
```
4. Use a imagem em sua página, seguindo o exemplo em Imagens no HTML.

Desvendando o UDP - Básico

Objetivos

Familiarizar-se com o UDP
Entender a estrutura do pacote UDP
Entender o conceito de portas
Entender o conceito de multiplexação

Fonte Base

Introdução a camada de transporte e UDP básico

Parte 1 - Fluxo único UDP

Usaremos dois terminais para execução do experimento.
- Um terminal escutará na porta 5000 e a outro transmitirá uma mensagem nessa porta. Os processos de transmissão e recepção podem ocorrer simultaneamente, em terminais distintos.
Abrir duas janelas de terminal.
Abrir o Wireshark, interfaces any, para escuta das portas no protocolo UDP usando um filtro:
```
udp.port==5000
```

Com o editor de texto Gedit ou Pluma escreva (copie) o programa UDPServer.py

#Os comentarios estao propositalmente sem acentuacao, caso contrario, tem-se erro de sintaxe.
#Esta linha define que pode-se utilizar sockets dentro do programa
from socket import *
#Define explicitamente a porta aberta servidor
serverPort = 5000
#Cria o socket do servidor, denominado serverSocket. O primeiro parametro indica a familia do endereco,
#em particular, AF_INET indica que a rede subjacente esta usando IPv4. O segundo parametro indica que
#o socket eh do tipo SOCK_DGRAM, ou seja, eh um socket UDP.
serverSocket = socket(AF_INET, SOCK_DGRAM)
#Vincula o numero da porta, nesse caso 22222, ao socket do servidor e "abre a porta".
serverSocket.bind(('', serverPort))
print ('O servidor esta pronto para recepcao')
#Aguarda indefinidamente por contatos (mensagens) de clientes
while 1:
    message, clientAddress = serverSocket.recvfrom(2048)
    print (message)
    #Ao receber a mensagem do cliente converte todos os caracteres para maiusculas.
    modifiedMessage = message.upper()
    serverSocket.sendto(modifiedMessage, clientAddress)

Salve o programa, na pasta /home/aluno, como UDPServer.py
Abra um terminal (primeiro) e digite
```
python3 UDPServer.py
```
No terminal aparacerá a mensagem: 'O servidor esta pronto para recepcao'. Esse será o nosso servidor...
No segundo terminal, que irá transmitir para a porta 5000 aberta no primeiro terminal, execute: (Ajuste o IP_DEST para o número IP de sua própria máquina)
```
netcat -u IP_DEST 5000
```
- Em seguida escreve no terminal uma mensagem de até 20 caracteres, ao teclar <enter> a mensagem será enviada.
- O wireshark deve ter capturado os pacotes UDP.
Identifique e anote os seguintes dados na captura do wireshark:.
1. PORTAS FONTE E DESTINO.
2. Campo de protocolo no pacote IP (Na janela central, clique sobre o Internet Protocol e observe o campo Protocol).
3. Campo de tamanho (anote o tamanho) e checksum no pacote (datagrama) UDP (Na janela central, clique sobre o User Datagram Protocol).
4. O campo de dados no pacote UDP.
Transmita sequencialmente várias mensagens, devendo identificar múltiplos datagramas UDP.
PERGUNTAS baseadas na captura e em seus conhecimentos teóricos:
1. Qual o valor de cada campo do cabeçalho do pacote UDP?
2. Qual o tamanho máximo do número de porta?
3. Qual o tamanho máximo da área de dados (payload) do pacote?
4. Qual o número identificador de protocolo UDP no pacote IP? (igual acima)
5. Em algum momento foi identificado algum procedimento para estabelecimento de conexão?
6. Em algum campo do UDP existe numeração de mensagens?

Parte 2 - Experimento com UDP - MUX e DEMUX

Conceber um adendo ao experimento anterior para demonstrar a multiplexação e demultiplexação de informação.
- Obs.:No experimento anterior o terminal 1 fazia o papel de servidor e o terminal 2 o papel de cliente.
- Obs.:Lembre-se que a demultiplexação permitirá que diferentes fluxos sejam encaminhados para diferentes processos. Nesse sentido, por exemplo, em uma mesma máquina pode-se abrir dois os mais terminais onde, em cada um deles, pode-se gerar ou aguardar fluxos distintos (diferenciados pelas portas).
1. 1 servidor com 2 clientes enviando mensagens distintas.
2. 2 servidores (portas distintas) com 1 cliente para cada servidor, enviando mensagens distintas.
Capture os pacotes com o Wireshark e caracterize quais pacotes pertencem a cada fluxo (porta).

Desvendando o TCP - Básico

Objetivos

Verificar o comportamento básico do Protocolo TCP:
- Fase de Estabelecimento de Conexão
- Troca de Dados
- Finalização da Conexão

Fonte Base

Camada de transporte: TCP básico

Verificando o estabelecimento, troca de dados e finalização da conexão

O roteiro será executado sobre 2 máquinas virtuais, através do uso do Imunes. Abra o Imunes e crie uma rede extremamente simples com somente dois PCs, conforme a figura.

Fig.1 -- Rede exemplo

Execute o Imunes e monte a rede conforme a figura.
Inicie a simulação:
```
 Experiment >> Execute
```
Executar no pc2 um servidor TCP aguardando na porta 5555 na forma:
```
 netcat -l -n -vv -p 5555
```
- Dica: para copiar o comando para o terminal do Imunes: copie da Wiki e cole com < Ctrl > + < Shift > + < V > ou clicando sobre a rodinha do mouse.
- Em uma comunicação TCP um processo é servidor (aguarda pedido de conexão) e um processo é o cliente, que gera um pedido de conexão
Executar o Wireshark na eth0 do pc1 (clique com o botão direito do mouse sobre o ícone do pc1 >> Wireshark >> eth0).
- Aplique um filtro "tcp" para limpar a apresentação.
Executar no pc1 um cliente TCP que solicita uma conexão ao servidor:
```
  netcat -vv -n 10.0.0.21 5555
```
Enviar uma pequena mensagem de 5 caracteres, e no final teclar ENTER e depois CTRL+C.
- O CTRL-C encerra a conexão no netcat.
Observe que no Wireshark todos pacotes TCP, desde o estabelecimento até a desconexão devem estar capturados. Um exemplo dessa captura encontra-se na Figura 2.

Fig.2 -- Protocolo TCP

O processo de conexão do TCP envolve a troca de 3 pacotes e é sempre iniciado pelo cliente. O cliente envia um pacote SYN, o servidor responde com um SYN-ACK e o cliente finalmente responde com ACK. Observe estes pacotes no wireshark.
- Pratique seu inglês e leia um pouco sobre este processo de estabelecimento de conexão em Connection Establishment
Baseado na captura de pacotes realizada responda:
1. Quais foram as portas de origem e destino usadas?
2. Quais os tamanhos das janelas informadas, tanto pelo cliente quanto pelo servidor?
3. Quais os números de sequência informado pelo Wireshark e o número que consta no campo Data em bytes. Qual é relação entre esses números?
4. Em qual mensagem (número) aparece a texto que você digitou?
5. Qual o número identificador de protocolo TCP no pacote IP? (Na janela central, clique sobre o Internet Protocol e observe o campo Protocol).
- Um dos objetivos do processo de conexão é sincronizar o número de sequência. Cada lado fica sabendo do número de sequência do outro. O número de sequência não começa com.
- O Wireshark converte a numeração para mostrar a partir do 0 mas o número inicial de sequência é criado randomicamente por cada lado. (ver [1])
Volte ao Wireshark e analise o processo de termino da conexão (iniciado pelo cliente neste caso, no momento do CTRL+C).
- Note que qualquer uma das partes pode realizar esta finalização.
- Pode ser observado que o cliente envia um pacote TCP com flag FIN.
- O servidor responde com um FIN-ACK.
- Finalmente o cliente faz um ACK.
- Veja se confere com a figura Término de conexão TCP ou com os slides apresentados no início da aula.
Gere com o Wireshark um diagrama da comunicação, ou diagrama de troca de mensagens, somente da conexão TCP estabelecida (não deve conter outras mensagens). Insira-o no relatório:
```
  Statistics >> Flow Graph >> OK
```
Analise esse diagrama, observando qual pacote contém os dados, ou seja, o texto que você digitou.
Analise também o estabelecimento e fechamento de conexão, confere com o apresentado na teoria?

Desvendando o TCP - Número de Sequência, Controle de Erros e Funcionamento Full-Duplex

Objetivos

Verificar alguns mecanismos do protocolo TCP:
- Controle de Erros: Significado de Número de Sequência, ACK
- Controle de Fluxo: Significado do campo Windows Size; Funcionamento do controle de fluxo;
- Comportamento Full-Duplex.

Topologia de rede para experimetação

O roteiro será executado sobre máquinas virtuais, através do uso do Imunes.

Abra um terminal e baixe o aquivo de configuração da rede a ser utilizada e um arquivo auxiliar dos experimentos:

cd ~
wget -4 http://redes.sj.ifsc.edu.br/TCP_Num_Seq_Erro.imn 
wget -4 http://redes.sj.ifsc.edu.br/arq30Bytes.txt

Execute o Imunes.
Carregue o arquivo:
```
 File >> Open >> TCP_Num_Seq_Erro.imn
```
- Será apresentada uma simples rede a ser utilizada no experimento, composta de 2 PCs: Transmissor e Receptor.

PARTE 1 - Transmissão sem erros: Verificação de Número de Sequência e Reconhecimentos

Inicie a simulação da rede no Imunes:
```
Experiment >> Execute
```
- Dica: para abrir um terminal de uma das máquinas da rede a ser simulada basta dar um duplo clique sobre a mesma.
Copie o arquivo arq30Bytes.txt para a máquina Transmissor do Imunes. No terminal da máquina hospedeira (NÃO do Imunes) digite::
```
sudo hcp arq30Bytes.txt Transmissor:
```

Execute o Wireshark no Receptor:

Clique direito do mouse sobre o ícone do Receptor >> Wireshark >> eth0..

Execute o processo servidor no Receptor e prepare o mesmo para limitar a sua capacidade de recepção em cerca de 20 bytes (tamanho do buffer). Isto permitirá ver a quebra do arquivo de 30 bytes em alguns segmentos TCP:
```
sysctl -w net.ipv4.tcp_rmem='20 20 20'
nc -vvnl -p 5555 > ArqRecebido.txt
```
- Dica: para copiar textos para o Imunes, copie normalmente o texto, por exemplo, da Wiki, com o < Ctrl > + < C > e cole com < Ctrl > + < Shift > + < V > ou clicando sobre a rodinha (scroll) do mouse.
Envie o arquivo arq30Bytes.txt da máquina Transmissor:
```
nc -vvn 10.0.0.21 5555 < arq30Bytes.txt
```
Pare os processos rodando nos terminais do Transmissor e Receptor com:
```
Ctrl + c
```
Pare a captura de pacotes no Wireshark.
Na tela do Wireshark você terá algo parecido com o apresentado na Figura 1.

Fig.1 -- Protocolo TCP
Perguntas
1. Qual o número de sequência (normalizado pelo Wireshark) de cada segmento de dados transmitido (de PC1 para PC2) e qual o significado do número de reconhecimento em cada um deles?
  - Relate esta análise por segmento usando os timestamps (coluna Time) como referência.
2. Como foi reconhecido cada segmento enviado?
3. Explique as mensagens do tipo TCP ZeroWindow. Deixe claro sua funcionalidade e necessidade.
4. Explique as mensagens do tipo TCP window Update. Deixe claro sua funcionalidade e necessidade.
Pare o experimento no Imunes:
```
Experiment >> Terminate
```

PARTE 2 - Transmissão com erros: retransmissões

Inicie a simulação da rede no Imunes:
```
Experiment >> Execute
```
- Dica: para abrir um terminal de uma das máquinas da rede a ser simulada basta dar um duplo clique sobre a mesma.
Copie o arquivo arq30Bytes.txt para a máquina Transmissor do Imunes. No terminal da máquina hospedeira (NÃO do Imunes) digite::
```
sudo hcp arq30Bytes.txt Transmissor:
```

Execute o Wireshark no Receptor:

Clique direito do mouse sobre o ícone do Receptor >> Wireshark >> eth0..

Adicione o filtro tcp ao Wireshark, para limpar os dados apresentados.
Vamos provocar perda de bits no enlace editando o BER do mesmo. BER é bit error rate, ou seja, foi inserido uma taxa de erro de bist no canal como sendo 1/15000. Isso significa que, em média, a cada 15 mil bits que passar pelo canal, 1 bit será perdido/adulterado.
```
Duplo clique sobre o enlace (fio vermelho) >> acrescente o valor 15000 no campo BER >> Clique em ''Apply''
```
Execute o processo servidor no Receptor e prepare o mesmo para limitar a sua capacidade de recepção em cerca de 20 bytes (tamanho do buffer). Isto permitirá ver a quebra do arquivo de 30 bytes em alguns segmentos TCP:
```
sysctl -w net.ipv4.tcp_rmem='20 20 20' 
nc -vvnl -p 5555 > ArqRecebido.txt
```
- Dica: para copiar textos para o Imunes, copie normalmente o texto, por exemplo, da Wiki, com o < Ctrl > + < C > e cole com < Ctrl > + < Shift > + < V > ou clicando sobre a rodinha (scroll) do mouse.
Envie o arquivo arq30Bytes.txt da máquina Transmissor:
```
 nc -vvn 10.0.0.21 5555 < arq30Bytes.txt
```
- Obs: Caso receba uma mensagem "No route to host", repita o comando acima. O problema é gerado por perdas sucessivas de mensagens de estabelecimento de conexão do TCP, devido à perda de dados estabelecida em 40%.
Monitore o Wireshark e assim que os 30 Bytes foram transmistidos, pare os processos rodando nos terminais do Transmissor e Receptor com:
```
Ctrl + c
```
Pare a captura de pacotes no Wireshark.
Analise como os dados foram transmitidos e reconhecidos.
Perguntas:
1. Houve perda de pacotes? Como você identificou isso?
2. Os pacotes perdidos foram retransmitidos? Justifique.
Pare o experimento no Imunes:
```
Experiment >> Terminate
```

PARTE 3 - Testando a capacidade do TCP de enviar dados de forma duplex

Agora vamos fazer um pequeno teste de transmissão de arquivos entre dois colegas e observar o comportamento full-duplex.
No experimento, o arquivo de uma máquina será transmitido para outra e vice-versa.

Inicie a simulação da rede no Imunes:
```
Experiment >> Execute
```

Vamos retirar a perda de bits no enlace editando o BER do mesmo.

Duplo clique sobre o enlace (fio vermelho) >> acrescente o valor 0 no campo BER >> Clique em ''Apply''

Num terminal da máquina do hospedeira/Linux (Não do Imunes) baixe os arquivos para o experimento e salve-os a pasta pessoal de seu usuário:
```
cd ~
wget -4 http://redes.sj.ifsc.edu.br/Servidor.tx -O Servidor.tx
wget -4 http://redes.sj.ifsc.edu.br/Cliente.tx -O Cliente.tx
```
Copie os arquivos para as máquinas do Imunes. No terminal da máquina hospedeira/Linux (NÃO do Imunes) digite:
```
sudo hcp Servidor.tx Transmissor: 
sudo hcp Cliente.tx Receptor:
```

Execute o Wireshark no Receptor:

Clique direito do mouse sobre o ícone do Receptor >> Wireshark >> eth0..

Limite o tamanho do buffer do TCP tanto no Transmissor quanto Receptor:

sysctl -w net.ipv4.tcp_rmem='10000 10000 10000' 
tc qdisc replace dev eth0 root netem loss 0%

No Transmissor, que fará o papel de servidor por aguardar a conexão do cliente, execute o comando abaixo. Perceba que o Servidor vai enviar (o sinal < indica isso) um arquivo e vai receber e salvar (o sinal > indica isso) outro do Cliente.
```
nc -vvnl -p 5555 < Servidor.tx > Arq_recebido.rx
```
No Receptor, que fará o papel de cliente, execute o comando abaixo. Perceba que ele também vai enviar e receber arquivo do servidor.
```
nc -vvn 10.0.0.20 5555 < Cliente.tx > Arq_recebido.rx
```
Pare os processos rodando nos terminais do Transmissor e Receptor com:
```
Ctrl + c
```
Confira o conteúdo dos arquivos recebidos no Transmissor e Receptor:
```
cat Arq_recebido.rx
```
Pare a captura de pacotes no Wireshark.
Adicione o filtro tcp ao Wireshark, para limpar os dados apresentados.
Analise como os dados foram transmitidos e reconhecidos.
Perguntas:
1. Onde pode ser observado a comunicação full-duplex? Obs.: Foque a análise nos segmentos que contém [PSH, ACK].
2. Como os ACKs são propagados, em pacotes exclusivos ou de carona (piggyback) com os dados?

TCP: Equidade e controle de congestionamento

Objetivos

Gerar gráficos para facilitar a visualização do controle de congestionamento e a consequente equidade do protocolo TCP.
Utilizar o software Iperf (iperf –h para help) para gerar tráfego entre duas máquinas, cliente e servidor.
Utilização do software Imunes para simulação de redes "complexas".

Topologia de rede para experimetação

Dois clientes "disputando" o enlace com o servidor

O roteiro será executado sobre máquinas virtuais, através do uso do Imunes.
Para realização dos ensaios será montada a rede virtual apresentada na Figura.
Observe que na figura todos os enlaces são iguais e limitados a 1 Mbps com delay de 5 us.
Os dois clientes vão disputar o enlace único entre o roteador e servidor.

Parte 1: Somente fluxos TCP

Baixe o arquivo de configuração da rede, no terminal digite:

wget -4 http://redes.sj.ifsc.edu.br/TCP_Controle_de_congestionamento_e_equidade.imn

Execute o Imunes.
Carregue o arquivo de configuração:
```
File >> Open >> /home/aluno/TCP_Controle_de_congestionamento_e_equidade.imn
```
- Perceba que será apresentada uma rede com um roteador, dois clientes e um servidor de rede. Todos interligados por enlaces de 1 Mbps.
Inicie a simulação no Imunes:
```
Experiment >> Execute
```
Limite o tamanho do buffer do TCP tanto no Servidor quanto no Cliente1:
```
sysctl -w net.ipv4.tcp_rmem='10000 10000 10000'
```
- Para copiar comando para os terminais das máquinas virtuais: copie o texto desejado, selecione o terminal da máquina desejada (duplo clique sobre a mesma) e clique sobre a "rodinha" do mouse que o texto será colado.

No Servidor execute:

iperf -s -p 2000 & iperf -s -p 2001 & iperf -s -p 2002 &

No Roteador execute o Wireshark:

Clique com o botão direito do mouse sobre o ícone do Roteador e no menu selecione: Wireshark >> eth2...

No Cliente1 execute (copie a três linhas e cole no terminal adequado e em seguida tecle <enter>):

iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2000 & \
(sleep 5 && iperf -c 10.0.2.10 -f m -i 1 -t 40 -p 2001) & \
(sleep 10 && iperf -c 10.0.2.10 -f m -i 1 -t 20 -p 2002) &

Fique monitorando o Cliente1 até a tela parar de ser atualizada, aproximadamente 50 s.
Pare os processos no Cliente1 e Servidor utilizando CTRL-C.
Pare a captura de dados no Wireshark e coloque um filtro TCP.
No wireshark acesse Statistics >> IO Graph e, na tela que abrir, ajuste TODOS os parâmetros para obter um gráfico similar ao apresentado na Figura 2:

Captura de 3 fluxos de dados
1. Deve-se adicionar um gráfico por porta, no caso, porta 2000, 2001 e 2002.
2. Clique em Add a new graph (sinal de + no canto inferior esquerdo)
  - X Enabled
  - Duplo clique sobre o campo Graph name: Porta 2000
  - Duplo clique sobre o campo Display Filter: tcp.port==2000
  - Duplo clique sobre o campo Color: clique no botão logo a direita e selecione a cor desejada.
3. Para os demais gráficos copie o anterior clicando no ícone com dois retângulos no canto inferior esquerdo
  - Edite nome, porta e cor.
4. Salve esse gráfico no relatório.
5. Responda:
  1. Explique os filtros aplicados no gráfico do Wireshark.
    - Quais são os 4 gráficos apresentados?
    - Há uma relação de valor entre as curvas?
    - Qual é esta relação?
  2. Por que as duas curvas apresentadas se sobrepõe nos primeiros 5 segundos, a partir do início da transmissão?
  3. Qual é a relação entre entreas três curvas nos próximos 5 segundos, a partir do início da transmissão?
  4. Qual é o mecanismo do TCP que explica a grande oscilação das curvas, principalmente percebida no intervalo entre 10 e 30 segundos, a partir do início da transmissão?
Para o experimentono Imunes:
```
Experiment >> Terminate
```

Parte 2: Fluxos TCP mais UDP

Agora vamos dificultar a vida do TCP incluindo um tráfego UDP. O gráfico gerado deverá apresentar a competição pelo meio de transmissão entre os diversos fluxos de dados.

Inicie a simulação no Imunes:
```
Experiment >> Execute
```
Limite o tamanho do buffer do TCP no Servidor, Cliente1 e Cliente2:
```
sysctl -w net.ipv4.tcp_rmem='10000 10000 10000'
```
- Para copiar comando para os terminais das máquinas virtuais: copie o texto desejado, selecione o terminal da máquina desejada (duplo clique sobre a mesma) e clique sobre a "rodinha" do mouse que o texto será colado.

No Servidor execute:

iperf -s -u -p 2000 & iperf -s -p 2001 & iperf -s -p 2002 &

No Roteador execute o Wireshark:

Clique com o botão direito do mouse sobre o Roteador >> Wireshark >> eth2...

A próxima etapa deve ser executada "simultaneamente" nos Cliente1 e Cliente2.
1. Para isso copie o texto abaixo e cole no terminal do Cliente1, ainda NÃO tecle <enter>:
```
sleep 5 && iperf -u -c 10.0.2.10 -f m -i 1 -t 25 -p 2000 -b 10000000
```
2. Copie o texto abaixo e cole no terminal do Cliente2, ainda NÃO tecle <enter>:
```
iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2001 &  iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2002
```
3. Tecle <enter> no Cliente2 e Cliente1, NESSA ORDEM, "simultaneamente".
Fique monitorando o Cliente2 a tela parar de ser atualizada, aproximadamente 50 s.
Pare os processos no Cliente1, Cliente2 e Servidor utilizando CTRL-C.
Pare a captura de dados no Wireshark.
No wireshark acesse Statistics >> IO Graph e, na tela que abrir, ajuste TODOS os parâmetros para obter um gráfico similar ao apresentado na Figura:

Captura de 2 fluxos de dados TCP mais um fluxo UDP
1. Clique em Add a new graph (sinal de + no canto inferior esquerdo)
  - X Enabled
2. No Graph 2 altere o filtro para tcp.analysis.flags.
3. No Graph 3 altere o filtro para udp.port==2000.
4. No Graph 4 altere o filtro para tcp.port==2001.
5. No Graph 5 altere o filtro para tcp.port==2002.
6. Salve o gráfico no relatório.
7. Responda:
  1. - Quais são os 5 gráficos apresentados?
    - Há uma relação de valor entre as curvas?
    - Qual é esta relação?
  2. O que ocorreu com os fluxos TCP após a entrada do fluxo UDP?
  3. Em que momento houve erros no TCP? Qual é a relação desse momento com o UDP?
  4. O que ocorreu com os fluxos TCP após o término do fluxo UDP?
8. Como desafio, compare o comportamento dos vários fluxos de dados, nos segundo experimentos, acrescentando mais fluxos UDP e TCP.

Interligação de duas redes através de um roteador

Objetivos

Introdução ao mundo IP
Verificação das configurações de interfaces de rede
Verificação de tabelas de roteamento nos hospedeiros e no roteador
Verificação de movimentação de pacotes (rotas) em roteadores

Referências

Base:

Endereçamento MAC x Endereçamento IP

Extra:

Guia de Administração da Camada IP no Linux

Topologia de rede para experimetação

Procedimento

Baixe o arquivo de configuração da rede, no terminal digite:

wget -4 http://redes.sj.ifsc.edu.br/Roteador_com_duas_redes.imn

Execute o Imunes.

Carregue o arquivo de configuração:

File >> Open >> /home/aluno/Roteador_com_duas_redes.imn

Inicie a simulação no Imunes:
```
Experiment >> Execute
```
- Ignore (dismiss) a mensagem de erro apresentada. O erro é proposital.
- Observe que a rede é composta de 4 PCs (pc1 - pc4), 1 roteador (router1) e 2 switchs. O roteador possui duas interfaces de rede, com seus respectivos IPs - camada 3, que interliga as duas sub-redes. Cada switch tem 3 interfaces, mas sem IPs, camada 2.
Anotar os endereços de hardware (ou MAC) e IP de cada dispositivo na rede. No terminal de cada PC e Roteador execute:
```
ifconfig
```
ou
```
ip a
```
Observar, interpretar e anotar a tabela de roteamento em todos os hospedeiros pc1 - pc4 e no roteador router1. Identificar os default gateways em cada PC.
```
route
```
Observar, "provar" e anotar que pacotes indo do pc1 para pc2 são enviados diretamente para pc2, ou seja, entrega direta. Explique a entrega direta.
1. Deixe o ping entre pc1 e pc2, em pc1 execute:
```
ping 10.0.0.21
```
2. No router1 capture pacotes com o Wireshark na interface eth0:
```
Clique com o botão direito do mouse sobre o router1 >> Wireshark >> eth0...
```
3. Observe que não há tráfego de pacotes no router1, portanto, entrega direta.
Observar, "provar" e anotar que pacotes indo de pc1 para pc4 são encaminhados ao roteador e, em seguida, entregues ao destino, ou seja, entrega indireta. Explique a entrega indireta.

Configuração básica de interface de rede

No pc3 teste a conectividade com os demais PCs, por exemplo, fazendo pings para o pc1 e pc4:
```
ping 10.0.0.20 
ping 10.0.1.21
```
- Perceba que não há conectividade, não há resposta aos pings, dado que a interface de rede do pc3 não está devidamente configurada.
Assim sendo, configure a interface de rede no pc3.
- Anote todos os comandos executados.
1. Inicie configurando o IP com o comando ifconfig (man ifconfig) ou ip (man ip). Dica: Observe a configuração de rede do pc4, que está na mesma sub-rede, e tente adaptá-la para o pc3.
  - Assim que a configuração do IP for bem sucedida o ping para o pc4 deverá funcionar.
2. Tente "pingar" para o pc1. Ainda não haverá sucesso, pois não há um roteador devidamente configurado no pc3.
3. Configure o roteador no pc3 com o comando route (man route).
  - Assim que a configuração do roteador for bem sucedida o ping para o pc1, e qualquer outro PC da rede, deverá funcionar.
4. O mesmo deverá ser capaz de "pingar" para qualquer outro PC ou ser "pingado".
5. Execute o comando ping do pc3 para o pc4. Obteve sucesso? Se não corrija as configurações.
6. Execute o comando ping do pc3 para o pc1. Obteve sucesso? Se não corrija as configurações.
7. Execute o comando ping do pc2 para o pc3. Obteve sucesso? Se não corrija as configurações.

Tabelas Estáticas de Roteamento

Objetivos

Analisar o funcionamento de roteadores com tabelas estáticas de roteamento.
Verificar a entrega direta e indireta de pacotes.
Analisar loops em rede.

Topologia de rede para experimetação

Em todos os experimentos será utilizado como base a seguinte arquitetura de rede:

Tabelas estáticas de roteamento

Baixe o arquivo de configuração da rede, no terminal digite:

wget -4 http://redes.sj.ifsc.edu.br/3_roteadores_tab_estaticas.imn

Execute o Imunes.

Carregue o arquivo de configuração:

File >> Open >> /home/aluno/3_roteadores_tab_estaticas.imn

Inicie a simulação no Imunes:
```
Experiment >> Execute
```
- Observe que a rede é composta de 3 PCs (pc0 - pc2) e 3 roteadores roteador (R0 - R2).
Testes de conectividade de enlace e configuração do default gateway.
1. Por exemplo, no pc0 execute o comando:
```
 ping 10.0.0.1
```
  Obteve sucesso? Sim ou não e por quê?
2. Teste a conectividade do pc0 executando o comando:
```
 ping 10.0.10.1
```
  Obteve sucesso? Sim ou não e por quê? Qual foi o erro observado?
3. Por exemplo, no pc0 execute o comando:
```
 ping 10.0.10.2
```
  Obteve sucesso? Sim ou não e por quê? Qual foi o erro observado?
4. Configure o roteador padrão em todos os PCs. Adapte o comando exemplo do pc0 para todos os PCs:
```
 route add -net default gw 10.0.0.1
```
  - Com este comando estamos: i) adicionando (add) uma rota ii) do tipo rede (net) iii) rota padrão (default), que é equivalente a 0.0.0.0 iv) com o roteador (gw - gateway) v) 10.0.0.1 que identifica a interface do roteador, R0, diretamente conectado ao host pc0, no caso.
5. Teste novamente a conectividade, no pc0 execute o comando:
```
 ping 10.0.10.1
```
  e
```
 ping 10.0.10.2
```
  Obteve sucesso? O comportamento foi o mesmo das tentativas anteriores? Sim ou não e por quê? Qual foi o erro observado?
6. Com os ping do item anterior ativos (um a cada tempo) rode o Wireshark no R0 (clique com o botào direito do mouse sobre o R0 e em seguida no menu wireshark eth0).
  1. Qual a origem e destino dos pacotes? Explique?
  2. Qual a diferença no ping entre os dois itens?
7. Iniciando o roteamento.
  1. Deixe o ping do do pc0 para o R1 e o wireshark - eth0 no R0 rodando e estabeleça uma rota no roteador R1 com o comando:
```
 route add -net 10.0.0.0/24 gw 10.0.10.1
```
    O que ocorreu com o ping e o wireshark? Por quê?
    - Com este comando estamos: i) adicionando (add) uma rota ii) do tipo rede (net) iii) para a rede 10.0.0.0/24 iv) com o roteador (gw - gateway) v) 10.0.10.1 que identifica a interface do roteador, R0, diretamente conectado ao roteador R1.
  2. Em todos os roteadores crie rotas para todas as redes. Em cada roteador deve-se criar 3 rotas, para as sub-redes "distantes", não diretamente conectadas. Lembre-se que os enlaces diretos já criam automaticamente rotas para as respectivas sub-redes diretamente conectadas ao equipamento, ou seja, entrega direta. Se tudo estiver correto, todos os PCs e roteadores devem pingar entre si.
    - Crie rotas sempre pelo caminho mais curto, por exemplo, do R0 para a rede do pc1 e pc2 passando por R1 e para R2 respectivamente.
  3. Trace e anote as rotas entre os hosts através do traceroute.
8. Testando a queda de enlace.
  1. Com todas as rotas em perfeito funcionamento, gere um ping do pc0 para o pc2 e execute wireshark eth0 no R0 , em seguida "derrube" o enlace entre o R0 e R2. Por exemplo, no R2 execute o comando:
```
 ifconfig eth1 down
```
    ou
```
 ip link set eth1 down
```
    O que ocorreu com o ping e o wireshark? Por quê? Com este enlace comprometido qual seria a solução para a continuidade de funcionamento de toda a rede?

Testando campo TTL com loop na rede

Baixe o arquivo de configuração da rede, no terminal digite:

wget -4 http://redes.sj.ifsc.edu.br/3_roteadores_tab_estaticas_com_loop.imn

Execute o Imunes.

Carregue o arquivo de configuração:

File >> Open >> /home/aluno/3_roteadores_tab_estaticas_com_loop.imn

Inicie a simulação no Imunes:
```
Experiment >> Execute
```
Execute o Wireshark na interface eth1 dos roteadores R0 e R2 e na interface eth2 do roteador R1.
Gere um tráfego único a partir do pc0 para o pc2:
```
ping -c1 10.0.2.20
```
Pare a captura em todos os Wiresharks.
Qual mensagem de erro foi recebida no terminal do pc0?
Analisando as capturas dos Wireshark responda:
1. Aproximadamente em qual roteador o pacote foi descartado? Procure pelo menor valor de ttl.
2. Qual o significado da linha com o seguinte conteúdo parcial: Time-to-live exceeded (Time to live exceeded in transit)?
3. Explique qual o objetivo do campo ttl no cabeçalho IP?

Tecnologia de Enlace Ethernet

Objetivos

Compreender que Ethernet não é Internet e que não é necessário o mundo IP para haver comunicação.
Compreender o papel do protocolo ARP

Fonte Base

Camada de Enlace

Animação Pearson/Kurose

Animação CSMA/CD

Funcionamento de um Switch

PARTE 1 - Explorando o SWITCH e o endereço de Broadcast Ethernet

Baixe o arquivo de configuração da rede, no terminal digite:
```
wget -4 http://redes.sj.ifsc.edu.br/switch.imn
```
Execute o Imunes.
Carregue o arquivo de configuração:
```
File >> Open >> /home/aluno/switch.imn
```
Inicie a simulação no Imunes:
```
Experiment >> Execute
```
Identificar o endereço de Hardware (MAC) do PC2. Use o ifconfig ou ip. Note que NÃO existe endereço IPv4 configurado.
Baixe o arquivo MacEnvioMsg.py, no terminal da máquina real digite:
```
wget -4 http://redes.sj.ifsc.edu.br/MacEnvioMsg.py
```
Copiar o arquivo para a Máquina Virtual PC1. No terminal da máquina real digite:
```
sudo hcp /home/aluno/MacEnvioMsg.py pc1:
```
Executar o Wireshark no PC2, PC3 e PC4.
No PC1 enviar uma mensagem para o PC2 usando o endereço de hardware (MAC) identificado anteriormente,
Lembre-se se substituir o ENDERECO_MAC pelo MAC do PC2:
```
python3 MacEnvioMsg.py -d ENDERECO_MAC -i Alo-Mundo
```
- Observe nos Wiresharks quem recebeu a mensagem.
- Somente o PC2 deve receber pois o switch entrega o quadro somente para a porta de saída associada ao respectivo MAC destino.
- CASO todos PCs tenham recebido, isto é devido ao fato de o switch ainda não ter aprendido quem está conectado em cada porta. Neste caso, num segundo envio, o switch já terá associado os MAC dos PCs às respectivas portas e o envio deve ser somente ao PC2.
Perguntas:
1. Quais PCs receberam a mensagem?
2. Quantas e quais camadas se observa na mensagem? Obs.: observe a janela intermediária do Wireshark.
3. Quais foram os MACs de origem e destino? A que PCs pertencem os mesmos?
4. Há camada de rede, IP, na mensagem?
5. Em qual camada que se encontra a mensagem?
6. A mensagem é legível?
No PC1 enviar uma mensagem em broadcast (endereço FF:FF:FF:FF:FF:FF)
```
python3 MacEnvioMsg.py -d FF:FF:FF:FF:FF:FF -i GritoNaRede
```
Perguntas:
1. Quais PCs receberam a mensagem?.
2. Quais foram os MACs de origem e destino? A que PCs pertencem os mesmos?
Pare (feche) todos o capturadores de pacotes (Wireshark).

PARTE 2 - Explorando o ARP

O protocolo ARP serve como apoio para descoberta do endereço MAC dado que se sabe o endereço IP de uma máquina. Quando um PC deseja enviar um pacote IP para uma máquina na rede local, ele necessita descobrir o endereço MAC desta máquina. O protocolo ARP usa o broadcast ETHERNET para perguntar para todas as máquinas na rede QUEM tem o endereço IP em questão. A máquina que possui o endereço responderá informando o seu MAC.

Configure o IP de todos os PCs. Todos devem pertencer a rede 10.0.0.0/24. Por exemplo, no pc1:
```
ifconfig eth0 10.0.0.1/24
```
Rode o Wireshark no PC2.
Faça um ping do PC1 no PC2 e observe a sequência de pacotes trocados. Faça um diagrama no tempo mostrando a troca de pacotes até a realização do ECHO REQUEST do ping. Os resultados do Wireshark devem ser similares a:
Confira e anote o cache do arp no PC1 fazendo:
```
  arp -a
```
Confira e anote o cache do arp no PC2 fazendo:
```
  arp -a
```
Confira e anote o cache do arp no PC3 fazendo:
```
  arp -a
```
1. Faça um ping do PC1 no PC3.
2. Confira e anote novamente o cache do arp no PC3 fazendo:
```
  arp -a
```
  - A tabela foi atualizada após o ping?
Confira e anote o cache do arp da sua máquina real fazendo:
```
  ip neigh show
```

Neighbor Discovery e roteamento estático no IPv6

Este roteiro foi baseado no material disponível no Livro - Laboratório de IPv6.

Slides de endereçamento IPv6.

Objetivos do laboratório

Um primeiro contato com o protocolo IPv6
Compreender o funcionando do Neighbor Discovery, o equivalente ao ARP (Address Resolution Protocol) do IPv4, que em resumo é uma tabela contendo a relação ente IPs e MACs.
Aprender configurações básicas de interfaces IPv6 no Linux
Aprender configurações básicas de rotas IPv6

Introdução teórica

Obs.: texto copiado literalmente de: Laboratório de IPv6.

A descoberta de vizinhança por meio do protocolo Neighbor Discovery no IPv6 é um procedimento realizado pelos nós de uma rede para descobrir endereços físicos dos dispositivos vizinhos presentes no mesmo enlace. A função deste protocolo se assemelha à função do ARP e do RARP no IPv4.

O procedimento é iniciado quando um dispositivo tenta enviar um pacote cujo endereço físico de destino é desconhecido. O nó solicitante envia uma mensagem Neighbor Solicitation (NS) para todos os nós do enlace pertencentes ao grupo multicast solicited-node (ff02::1:ffXX:XXXX), de modo que XX:XXXX são os últimos 24 bits do endereço IPv6 em que está interessado.
É possível notar que, por uma coincidência dos últimos 24 bits, é bastante provável que apenas o nó de destino faça realmente parte deste grupo. Isto é um truque interessante do IPv6 para diminuir o tráfego deste tipo de pacote na rede.
Na mensagem NS, o endereço IPv6 a ser resolvido é informado no campo Target. O campo Source link-layer address informa ao nó de destino o endereço MAC do nó de origem, poupando-o de ter que fazer o mesmo procedimento no sentido inverso.
O nó de destino, dono do IPv6 requisitado, ao receber este pacote, envia uma mensagem Neighbor Advertisement (NA) como resposta diretamente ao nó requisitante. O seu endereço físico será informado no campo Target link-layer address.
A informação de mapeamento entre endereços IP e endereços físicos é armazenada em uma tabela chamada neighbor cache. Nela também fica registrado o status de cada destino, informando se o mesmo é alcançável ou não.

Topologia de rede para experimetação

A figura abaixo apresenta o diagrama esquemático da rede a ser montada/analisada. Observe que todos os IPv6 Global Unicast já estão definidos na mesma, são esses IPs que utilizaremos em nosso experimento.

Roteiro de atividades

Baixe o arquivo de configuração da rede, no terminal digite:
```
wget -4 http://redes.sj.ifsc.edu.br/IPv6.imn
```
Execute o Imunes.
Carregue o arquivo de configuração:
```
File >> Open >> /home/aluno/IPv6.imn
```
Inicie a simulação no Imunes:
```
Experiment >> Execute
```
- Ignore a mensagem de erro, o mesmo é proposital.
- Observe que a rede é composta de 4 PCs (pc0 - pc3) e 2 roteadores (R0 - R1) e 1 switch.

Execute o wireshark em R1:

clique com o botão direito do mouse sobre seu ícone >>  Wireshark >> eth0...

Vamos testar o Neighbor Discovery, anote a saída do comando. A partir do pc2 execute:
```
ndisc6 -m fc00:2::1 eth0
```
- Esse comando descobre e retorna o MAC address da interface de rede que possui o endereço IPv6 informado. É equivalente ao protocolo ARP do IPv4.
Observe que todas as interfaces de rede já estão pré-configuradas, exceto do pc3.
Vamos adicionar o endereço IPv6 à interface de rede no pc3:
```
ip addr add fc00:2::21/64 dev eth0
```
Faça um ping6 entre o pc3 ao pc2:
```
ping6 fc00:2::20
```
- Se tudo estiver devidamente configurado, deve-se obter sucesso no ping entre o pc3 e pc2. Entrega direta ou indireta?
Faça um ping6 entre o pc3 ao pc0.
- Obteve sucesso? Sim ou não e por quê?
No pc3 use o seguinte comando para verificar como ficou a configuração dos endereços da interface de rede. O resultado é similar ao apresentado pelo comando ifconfig:
```
ip addr show dev eth0
```
No pc3, liste a tabela de roteamento com o comando:
```
ip -6 route show
```
No pc3, acrescente o default gateway com o seguinte comando:
```
ip -6 route add default via fc00:2::1 dev eth0
```
- Confira novamente a tabela de roteamento do pc3.
Faça novamente um ping6 entre o pc3 ao pc0.
- Obteve sucesso? Sim ou não e por quê?
Pode-se conferir se as rotas, nos roteadores ou qualquer host, com o comando:
```
ip -6 route show
```
A partir do computador pc0 use o comando traceroute6 IPv6_DE_DESTINO e anote a rota para todos os demais PCs. Ex:
```
traceroute6 fc00:1::20
```
Pare a captura no Wireshark.
Baseado na captura de pacotes do Wireshark explique o processo de descoberta de vizinhança (Neighbor Solicitation - NS e Neighbor Advertisement - NA), citando os endereços de multicast e link local utilizados. Obs.: ao final do roteiro há alguns exemplos de mensagens.
Numa mensagem do tipo Neighbor Solicitation qual é o endereço IPv6 de origem e destino? Explique/defina ambos.
Em todos os hosts rode o comando
```
 ip -6 neighbor show
```
1. Qual é a funcionalidade desse comando?
2. Qual é o significado do conteúdo dessa tabela?
3. A tabela mostrada em cada um dos casos é compatível com o diagrama da rede montado?
4. Por que, por exemplo, na tabela do pc2 não há uma referência explícita ao pc0?
Explique sucintamente as diferenças na comunicação baseada em IPv4 e IPv6.

Alguns exemplos de campos visualizáveis para uma mensagem do tipo Neighbor Advertisement, presentes nas camadas destacadas:

Source (camada Ethernet)
- A origem é o endereço MAC da interface do dispositivo que enviou a resposta.
Protocol (camada Ethernet)
- Indica que a mensagem utiliza IPv6.
Next header (camada IPv6)
- Indica qual é o próximo cabeçalho. Neste caso, o valor 58 (0x3a) refere-se a uma mensagem ICMPv6.
Source (camada IPv6)
- A origem é o endereço IP da interface diretamente ligada ao enlace em que a requisição foi recebida.
Destination (camada IPv6)
Type (camada ICMPv6)
- Indica que a mensagem é do tipo 136 (Neighbor Advertisement).
Flags (camada ICMPv6)
- Uma mensagem NA possui três flags:
1. Indica se quem está enviando é um roteador. Neste caso, o valor marcado é 0, pois não é um roteador.
2. Indica se a mensagem é uma resposta a um NS. Neste caso, o valor marcado é 1, pois é uma resposta.
3. Indica se a informação carregada na mensagem é uma atualização de endereço de algum nó da rede. Neste caso, o valor marcado é 1, pois está informando o endereço pela primeira vez.
Target Address (camada ICMPv6)
- Indica o endereço IP associado às informações das flags. Neste caso, é o próprio endereço da interface do dispositivo em questão.

Path MTU Discovery: mensagem ICMPv6 do tipo packet too big

Este roteiro foi baseado no material disponível no Livro - Laboratório de IPv6.

Objetivos do laboratório

O objetivo desta experiência é mostrar o funcionamento do mecanismo de descoberta de MTU no IPv6.

Introdução teórica

Obs.: texto copiado literalmente de: Laboratório de IPv6.

O MTU é o tamanho máximo de pacote suportado em um determinado enlace de rede. Caso seja necessário enviar um pacote maior do que o MTU do enlace é necessário fragmentá-lo. No IPv6, a fragmentação dos pacotes é realizada apenas na origem. Este procedimento não é realizado (e nem permitido) em roteadores intermediários, como ocorre no protocolo antigo, o IPv4. Isto tem o intuito de reduzir o custo de processamento nos roteadores, seguindo o princípio de manter a inteligência da Internet nas extremidades da rede. Numa rede IPv6, quem está enviando os pacotes tem então que conhecer o MTU do caminho até o destino. Se o caminho for composto por vários seguimentos com MTUs diferentes, valerá, na prática, o menor deles. Essa informação é obtida por meio do Path MTU Discovery (PMTUD), definido na RFC 1981 (McCann et al., 1996). O processo de PMTUD assume que o MTU de todo o caminho é igual ao do primeiro salto. Caso o tamanho dos pacotes enviados seja maior do que o suportado por algum enlace ao longo do caminho, o roteador irá descartá-lo e enviará uma mensagem ICMPv6 packet too big, contendo tanto a mensagem de erro quanto o valor do MTU do enlace seguinte. Após o recebimento dessa mensagem, o nó de origem passa a limitar o tamanho dos pacotes de acordo com o MTU indicado. Isso é repetido até que o tamanho do pacote seja igual ou inferior ao menor MTU do caminho. Os dispositivos armazenam o MTU para cada destino em uma tabela chamada destination cache, não sendo necessário repetir a descoberta a cada pacote enviado. Caso o pacote seja enviado a um grupo multicast, o tamanho utilizado será o menor MTU de todo o conjunto de destinos. Implementações minimalistas de IPv6 podem não realizar a descoberta de MTU e utilizar 1280 bytes como tamanho máximo para os pacotes.

Roteiro de atividades

Baixe o arquivo de configuração da rede, no terminal digite:
```
wget -4 http://redes.sj.ifsc.edu.br/PathMTU.imn
```
Execute o Imunes.

Carregue o arquivo de configuração:

File >> Open >> /home/aluno/PathMTU.imn

Inicie a simulação no Imunes:
```
Experiment >> Execute
```
- Observe que a rede é composta de 2 PCs e 1 roteador.
Altere o valor de MTU no dispositivo router1:
```
ip link set eth1 mtu 1400
```
Verifique o valor de MTU no dispositivo router1:
```
ip addr show
```
- Na interface eth1 deverá constar mtu 1400
Altere o valor de MTU no dispositivo pc2:
```
ip link set eth0 mtu 1400
```
Verifique o valor de MTU no dispositivo pc2:
```
ip addr show
```
- Na interface eth0 deverá constar mtu 1400

Execute o wireshark no pc1:

clique com o botão direito do mouse sobre seu ícone >>  Wireshark >> eth0...

Abra um terminal no pc1 e verifique a conectividade IPv6 com o pc2:
```
ping6 -s 1500 -M want -c 4 fc00:1::20
```
- Veja que o comando ping6, com os parâmetros apresentados, configura os pacotes enviados para conterem 1500 bytes de tamanho, por meio da opção -s 1500, e a interface para permitir a fragmentação de pacotes, utilizando a opção -M want.
Pare a captura de pacotes e aplique, no Wireshark, o filtro icmpv6.
Procure pelo pacote Packet Too Big.
1. Veja se os dados contidos nos pacotes conferem com a teoria.
2. Qual é o tipo (type) e código (code) do pacote? Está de acordo com a teoria? ([2])
3. Procure o campo MTU: 1400, qual o significado desta informação?
Procure pelos pacotes Echo (ping) request.
1. Analise os mesmos na camada 3 (IPv6):
  1. quantos fragmentos os mesmos possuem?
  2. Qual o tamanho de cada fragmento?
2. Onde (máquina) foi realizada a fragmentação?
  1. Como você chegou a esta conclusão?
3. Procure pelos pacotes Echo (ping) reply.
  1. Eles também estão fragmentados? Prove.
  2. Qual o sentido dessa fragmentação?
Repita todo o experimento, alterando o MTU do enlace a direita para 500.
1. Analise a nova fragmentação no wireshark e dê print do resultado.
2. Analise a nova fragmentação, é compatível com o MTU de 500?
3. Quantos fragmentos são gerados em cada ping?

O resultado mostra que, para a topologia apresentada, o menor valor de MTU ao longo do caminho foi descoberto corretamente a partir do primeiro pacote. Este foi descartado ao chegar em uma rede cujo o limite do MTU era de 1400 bytes. Na sequência, os pacotes foram enviados fragmentados de acordo com o valor de MTU descoberto e passaram a transitar corretamente pela rede.

@@ Linha 1: / Linha 1: @@
+__INDEX__
 * <span style="font-size:130%"> Esta página é dedicada a descrição de roteiros de experimentos que tem por objetivo o fortalecimento de conceitos relacionados à disciplina de Redes de Computadores do curso técnico em Telecomunicações do IFSC.</span>
-* <span style="font-size:130%"> Cada roteiro é elaborado de tal modo que o estudante consiga realizar as atividades de maneira autônoma e propõe questões que forçam a reflexão sobre os conceitos abordados.</span>
+*<span style="font-size:130%"> Cada roteiro é elaborado de tal modo que o estudante consiga realizar as atividades de maneira autônoma e propõe questões que forçam a reflexão sobre os conceitos abordados.
-* <span style="font-size:130%"> Para realizar os roteiros em casa deve-se utilizar o [https://www.virtualbox.org/ VirtualBox] e uma máquina virtual pré-configurada com todo o ferramental necessário que pode se baixada [http://docente.ifsc.edu.br/odilson/Redes/Redes.ova aqui]:
+<span style="font-size:180%"> Para realizar os roteiros em casa, deve-se seguir o procedimento abaixo em uma máquina com sistema operacional Windows:</span>
-*# Baixe e instale o [https://www.virtualbox.org/ VirtualBox];
+#Baixe e instale o [https://www.virtualbox.org/ VirtualBox];
-*# Baixe a máquina virtual, http://docente.ifsc.edu.br/odilson/Redes/Redes.ova, e salve em um diretório/pasta qualquer de sua máquina;
+#Baixe o [https://ubuntu.com/download Ubuntu];
-*# Acesse o diretório onde salvou o arquivo Redes.ova e dê duplo clique sobre o mesmo;
+#Execute o Virtualbox e adicione uma nova máquina virtual (Máquina > Novo);
-*# Irá abrir um janela do VirtualBox com a opção de Importar Appliance Virtual, deixe todas as opções padrão e clique em '''Importar''';
+#Irá abrir um janela do VirtualBox para Criar Máquina Virtual, preencha corretamente os campos e clique em Próximo > Próximo > Próximo > Finalizar;
-*# Irá abrir outra janela do VirtualBox: Importando Appliance...;
+#Preencha adequadamente os campos para instalação do SO Ubuntu. Em geral deixe as opções padrão.
-*# Ao terminar sua máquina virtual estará pronta para uso. Usuário: aluno, senha: aluno.</span>
+#Aguarde o término da instalação da máquina virtual.
+#Ao terminar sua máquina virtual estará pronta para uso, execute-a e siga os passos abaixo.
-* <span style="font-size:180%">Caso possua o Ubuntu já instalado em sua máquina, instale somente o Imunes com o seguinte procedimento (testado para Ubuntu 18.04, 20.04 ou 22.04) </span>
-** Abra um terminal de digite, um a um, os seguintes comandos:<syntaxhighlight lang=bash>
-sudo apt install openvswitch-switch docker.io xterm wireshark \
-    make imagemagick tk tcllib util-linux
-git clone https://github.com/imunes/imunes.git
-cd imunes
-sudo make install
-sudo imunes -p
-sudo imunes & </syntaxhighlight>
-** Habilitando o navegador Firefox nas máquinas Imunes:<syntaxhighlight lang=bash>
-sudo apt install socat
-sudo apt-get_imunes install firefox-esr socat </syntaxhighlight>
+<span style="font-size:180%">Instale o Imunes no seu Ubuntu 18.04, 20.04 ou 22.04</span>
+*Abra um terminal e digite, um a um, os seguintes comandos:
+*#sudo apt install openvswitch-switch docker.io xterm wireshark make imagemagick tk tcllib util-linux
+*#git clone https://github.com/imunes/imunes.git
+*#cd imunes
+*#sudo make install
+*#sudo imunes -p
+*#sudo apt install socat
+*#sudo apt-get_imunes install firefox-esr socat
+*#Baixe o arquivo de configuração, no terminal digite: <syntaxhighlight lang=bash>
+wget http://redes.sj.ifsc.edu.br/Xresources </syntaxhighlight>
+*#Mova e renomeie o arquivo baixado com o comando: <syntaxhighlight lang=bash>
+mv Xresources ~/.Xresources </syntaxhighlight>
+*#Reinicie a máquina.
+*Para um teste de funcionamento, abra um terminal e execute:<syntaxhighlight lang=bash>
+sudo imunes </syntaxhighlight>
 [[Curso_Técnico_Integrado_de_Telecomunicações_-_Redes_de_Computadores_(RCO) | <span style="font-size:200%"> Página principal da disciplina]]</span>
@@ Linha 43: / Linha 49: @@
 ** o funcionamento básico de um protocolo (ICMP - ''echo request/echo reply''), ganhando ''insight'' em relação as entidades de protocolos comunicantes.
-==Material e Pré-condições==
+===Material e Pré-condições===
 * Virtualbox com Máquina Virtual com a Appliance '''Redes''' instalado ou Ubuntu instalado em dual-boot.
@@ Linha 63: / Linha 69: @@
 * redefinir a interrupção utilizada pelo dispositivo, entre outros.
-Através do  comando ''ifconfig''' pode-se observar os resultados, o comando '''ip a''' apresenta resultados semelhantes:
+Através do  comando ''ifconfig''' pode-se observar os resultados, o comando '''ip a''' apresenta resultados semelhantes:<syntaxhighlight lang=bash>
-<pre style="color: red">
+ifconfig
-$ ifconfig
 eth0      Link encap:Ethernet  Endereço de HW 64:51:06:1a:f3:da
            inet end.: 172.18.18.14  Bcast:172.18.63.255  Masc:255.255.192.0
@@ Linha 86: / Linha 91: @@
            colisões:0 txqueuelen:0
            RX bytes:1057934 (1.0 MB) TX bytes:1057934 (1.0 MB)
-</pre>
+OU
+ip a
+: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
+    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
+    inet 127.0.0.1/8 scope host lo
+       valid_lft forever preferred_lft forever
+    inet6 ::1/128 scope host
+       valid_lft forever preferred_lft forever
+: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
+    link/ether 20:47:47:fd:7c:24 brd ff:ff:ff:ff:ff:ff
+    altname enp2s0
+    inet 191.36.9.62/24 brd 191.36.9.255 scope global dynamic noprefixroute eth0
+       valid_lft 84215sec preferred_lft 84215sec
+    inet6 2804:1454:1004:200:5f9e:5bb9:47c8:db8e/64 scope global temporary dynamic
+       valid_lft 602615sec preferred_lft 83649sec
+    inet6 2804:1454:1004:200:2247:47ff:fefd:7c24/64 scope global dynamic mngtmpaddr noprefixroute
+       valid_lft 2591956sec preferred_lft 604756sec
+    inet6 fe80::2247:47ff:fefd:7c24/64 scope link noprefixroute
+       valid_lft forever preferred_lft forever </syntaxhighlight>
 * O sistema em questão possui duas interfaces de rede: '''eth0''' e '''lo'''
 * '''Link encap:Ethernet''': Configuração da interface '''Eth'''ernet 0 (primeira)
@@ Linha 114: / Linha 138: @@
 Consultar as páginas ''man'' do ping para verificar as possibilidades de uso deste aplicativo.
-Exemplo 1: <pre style="color: red">
+Exemplo 1: <syntaxhighlight lang=bash>
-ping 191.36.0.94
+ping4 191.36.0.94
 PING 191.36.0.94 (191.36.0.94) 56(84) bytes of data.
 bytes from 191.36.0.94: icmp_seq=1 ttl=60 time=2.46 ms
@@ Linha 124: / Linha 148: @@
 --- 191.36.0.94 ping statistics ---
 packets transmitted, 4 received, 0% packet loss, time 3001ms
-rtt min/avg/max/mdev = 0.513/1.026/2.463/0.830 ms
+rtt min/avg/max/mdev = 0.513/1.026/2.463/0.830 ms </syntaxhighlight>
-</pre>
 # No exemplo foram enviados quatro pacotes ICMP, cada um com um número de seqüência (''icmp_seq''), os quais foram recebidos com sucesso com o tempo de viagem assinalado (''time'')
 # Cada pacote tem ainda um tempo de vida (''ttl'' – ''time to live''), o qual é decrementado em cada roteador, sendo o pacote descartado quando chegar a zero; isto evita pacotes perdidos na rede
@@ Linha 131: / Linha 154: @@
 # O tempo de viagem (''rtt'' – ''round trip time'') mínimo (''min''), médio (''avg'') e máximo (''max'') é calculado, assim como o desvio padrão (''mdev'')
-<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">TAREFA: Como exercício envie '''ping''' para diferentes ''hosts'' e compare os tempos de resposta (documente recortando e colando as telas). Faça ping:</span>
+<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">TAREFA: Como exercício envie '''ping4''' para diferentes ''hosts'' e compare os tempos de resposta (documente recortando e colando as telas). Faça ping4:</span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">no endereço local de loopback;</span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">servidores externos: <syntaxhighlight lang=bash>
@@ Linha 142: / Linha 165: @@
 ## -s packetsize
 ## -t ttl (para um site distante inicie com 1 e vá incrementando, observe as mensagens)</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;"><span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Observe que também é possível realizar ping em endereços no formato IPv6, desde que seu computador tenha IPv6 configurado, por exemplo:</span> <syntaxhighlight lang=bash> ping6 tele.sj.ifsc.edu.br </syntaxhighlight></span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;"><span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Observe que também é possível realizar ping em endereços no formato IPv6, desde que seu computador tenha IPv6 configurado, por exemplo:</span> <syntaxhighlight lang=bash> ping6 google.com </syntaxhighlight></span>
 # <span style="color: green" data-mce-style="color: green;"><span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tente o ping6 para outros sites.</span> </span>
@@ Linha 158: / Linha 181: @@
 O exemplo mostra a rota dos pacotes entre um computador do Lab. Redes (192.168.1.1) e o servidor ''hendrix'' (200.135.37.65). Observe que para cada roteador são realizados três amostras de tempo de ida e volta. Veja pelo mapa da rede do Campus São José que entre estes dois computadores, sistemas finais, existem dois roteadores intermediários, máquina do professor e Switch camada 3 (VLANs).
 # <span style="color: green" data-mce-style="color: green;"> Tarefa: Traçar a rota dos pacotes entre seu computador e diferentes hosts:
-## traceroute tele.sj.ifsc.edu.br
+## traceroute redes.sj.ifsc.edu.br
 ## traceroute nasa.com
 ## ... outros servidores de sua preferência.</span>
@@ Linha 173: / Linha 196: @@
 Experiment >> Execute </syntaxhighlight>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um ifconfig ou ip a em cada PC e nos roteadores. Discuta os resultados no caso dos roteadores.</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um ping do PC1 em direção ao PC2; </span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um ping do PC1 em direção ao PC2; Qual o atraso? </span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Modifique o retardo de um dos links para 50 ms; </span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Modifique o retardo (''delay'') de um dos links para 50 ms; </span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um traceroute entre PC1 e PC2 e explique o resultado obtido quando comparado com a figura.</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um ping do PC1 em direção ao PC2; Qual o atraso? </span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Execute um traceroute entre PC1 e PC2 e explique o resultado obtido quando comparado com a figura, em relação aos números de IP apresentados.</span>
 =Wireshark e encapsulamento=
@@ Linha 191: / Linha 215: @@
 O analisador de pacotes exibe os conteúdos de todos os campos dentro de uma mensagem de protocolo. Para que isso seja feito, o analisador de pacotes deve “entender” a estrutura de todas as mensagens trocadas pelos protocolos.
-Suponha que estamos interessados em mostrar os vários campos nas mensagens trocadas pelo protocolo HTTP na Figura 5. O analisador de pacotes entende o formato dos quadros Ethernet, e desta forma pode identificar o datagrama IP dentro de um quadro. Ele também entende o formato do datagrama IP, para que ele possa extrair o segmento TCP dentro do datagrama IP. Ele entende a estrutura do segmento TCP, para que possa extrair a mensagem HTTP contida no segmento. Finalmente, ele entende o protocolo HTTP e então, por exemplo, sabe que os primeiros bytes de uma mensagem HTTP contém a cadeia “GET”, “POST” ou “HEAD”.
+Suponha que estamos interessados em mostrar os vários campos nas mensagens trocadas pelo protocolo HTTP. O analisador de pacotes entende o formato dos quadros Ethernet, e desta forma pode identificar o datagrama IP dentro de um quadro. Ele também entende o formato do datagrama IP, para que ele possa extrair o segmento TCP dentro do datagrama IP. Ele entende a estrutura do segmento TCP, para que possa extrair a mensagem HTTP contida no segmento. Finalmente, ele entende o protocolo HTTP e então, por exemplo, sabe que os primeiros bytes de uma mensagem HTTP contém a cadeia “GET”, “POST” ou “HEAD”.
 Nós utilizaremos o ''sniffer'' Wireshark (http://www.wireshark.org) para estes laboratórios, o que nos permite exibir os conteúdos das mensagens sendo enviadas/recebidas de/por protocolos em diferentes camadas da pilha de protocolos. Tecnicamente falando, Wireshark é um analisador de pacotes que pode ser executado em computadores com Windows, Linux/UNIX e MAC.
@@ Linha 200: / Linha 224: @@
    sudo wireshark
-==ETAPA 1: Identificando os campos da interface do Wireshark==
+==Identificando os campos da interface do Wireshark==
 Quando você executar o programa Wireshark, a interface com o usuário exibida na Figura abaixo aparecerá. Inicialmente, nenhum dado será apresentado nas janelas. A interface do Wireshark tem seis componentes principais:
 # Os menus de comandos são localizados no topo da janela. Por enquanto, interessam apenas os menus ''File'' e ''Capture''. O menu ''File'' permite salvar dados de capturas de pacotes ou abrir um arquivo contendo dados de capturas de pacotes previamente realizadas, e sair da aplicação. O menu ''Capture'' permite iniciar uma captura de pacotes;
@@ Linha 211: / Linha 235: @@
 [[Arquivo:Wireshark_interface_usuario.png  | 700px| Figura 3 - Interface com o usuário do Wireshark]]
-===ETAPA 2 - Verificando pacotes do ping (ICMP REQUEST/REPLY)===
+==Verificando pacotes do ping (ICMP REQUEST/REPLY)==
-=====Etapa 1 - Treinamento=====
-# Inicie o Wireshark. Inicialmente as janelas estarão vazias, pois não há captura de pacotes em progresso;<syntaxhighlight lang=bash>
+===Treinamento===
-   sudo wireshark</syntaxhighlight>
+# Inicie o Wireshark. Inicialmente as janelas estarão vazias, pois não há captura de pacotes em progresso. O programa pode ser iniciado pelo menu ou no terminal, conforme abaixo:<syntaxhighlight lang=bash>
+   sudo wireshark &</syntaxhighlight>
 # Para iniciar uma captura de pacotes, selecione o menu Capture e depois Options. Provavelmente sua interface de rede será a ''eth0'', duplo clique sobre a mesma.
 # Isso faz com que a janela de interfaces de rede disponíveis seja apresentada (Figura 4); [[Arquivo:Wireshark_interfaces_rede.png |thumb | 400px| Figura 4 - Interfaces de rede no Wireshark]]
@@ Linha 234: / Linha 259: @@
 [[Arquivo:TelaWiresharkPing.png | 700px| Figura 5 - Tela Wireshark - Ping]]
-=====Etapa 2 -- <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tarefa</span>=====
+===<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tarefa</span>===
 # <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Abra o Wireshark em modo captura. </span>
-# <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Abra um terminal e faça um "ping -c 3" para um site conhecido (você pode usar o nome: www.ifsc.edu.br por exemplo).</span>
+# <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Abra um terminal e faça um "ping4 -c 3" para um site conhecido (você pode usar o nome: www.ifsc.edu.br por exemplo).</span>
 # <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Pare a captura de pacotes no Wireshark.</span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Aplique um filtro icmp no display. Recorte a tela observada e indique os pacotes ICMP ECHO REQUEST. Anote quem são os endereços IP e MAC que aparecem no pacote IP e Frame Ethernet.</span>
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Discuta o endereço MAC de destino de um dos pacotes enviados por sua máquina. O MAC de destino é ou não do servidor para o qual você pingou?</span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Aplique um comando Flow Graph e mostre a troca de mensagens do ping através de um recorte da tela;</span>
 #* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Statistics >> Flow Graph >> Abrirá uma nova janela com várias informações >> Aplique o filtro (Flow type:) '''ICMP Flows''' na base da janela. Salve esta tela no relatório.</span>
@@ Linha 257: / Linha 283: @@
 ==A Interação Básica GET/Resposta do HTTP==
+#O exemplo da figura 1 mostra na janela de listagem de pacotes duas mensagens HTTP capturadas:
+##A mensagem GET (do seu navegador para o servidor web www.sj.ifsc.edu.br) e a mensagem de resposta do servidor para o seu navegador.
+##A janela de conteúdos de pacotes mostra detalhes da mensagem selecionada (neste caso a mensagem HTTP GET, que está em destaque na janela de listagem de pacotes).
+##A mensagem HTTP transportada em um segmento TCP, que é carregado em um datagrama IP, que é levado em um quadro Ethernet com 5728 bits no fio. Isso é observado de baixo para cima na janela de detalhes do cabeçalho do pacote selecionado. O Wireshark exibe informações sobre o quadro, IP, TCP e HTTP. Você deve expandir as informações, por exemplo, do HTTP clicando na seta ao lado esquerdo de “Hypertext Transfer Protocol”. Observando as informações das mensagens HTTP GET e de resposta. [[Arquivo:HTTP_Wireshark.png |thumb | 300px| Fig.1 Requisição e Resposta HTTP]]
+#Vamos iniciar a nossa exploração do HTTP baixando um arquivo em HTML simples - bastante pequeno, que não contém objetos incluídos. Faça o seguinte:
+##inicie o navegador Chrome e limpe o cache do mesmo (teclas de atalho:'''Ctrl + Shift + Del''');
+##inicie o Wireshark, no terminal digite:<syntaxhighlight lang=bash>
+sudo wireshark
+</syntaxhighlight>
+##inicie a captura de pacotes no Wireshark;
+##abra em uma nova aba do navegador a seguinte URL: http://redes.sj.ifsc.edu.br/;
+##pare a captura de pacotes;
+##digite “http” (somente as letras, sem as aspas) na caixa de texto de especificação do filtro de exibição, de tal forma que apenas as mensagens HTTP capturadas serão exibidas na janela de listagem de pacotes. (Só estamos interessados em HTTP desta vez, e não desejamos ver todos os pacotes capturados).
-# Vamos iniciar a nossa exploração do HTTP baixando um arquivo em HTML simples - bastante pequeno, que não contém objetos incluídos. Faça o seguinte:
+#<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Responda às seguintes perguntas e imprima as mensagens GET e a resposta e indique em que parte da mensagem você encontrou a informação que responde às questões.
-## inicie o navegador;
+##O seu navegador executa HTTP 1.0 ou 1.1?
-## limpe o cache do mesmo (teclas de atalho para o Firefox: '''Ctrl + Shift + Del''');
+##Qual a versão de HTTP do servidor?
-## inicie o Wireshark, como descrito no '''Ferramentas básicas''';
+##Quais idiomas (se algum) o seu navegador indica ao servidor que pode aceitar?
-## inicie a captura de pacotes;
+##Qual o endereço IP do seu computador?
-## digite o seguinte URL no navegador http://tele.sj.ifsc.edu.br/~odilson/RED29004//RED29004.html;
+##E do servidor redes.sj.ifsc.edu.br?
-## pare a captura de pacotes;
+##Qual o número da porta utilizada no seu computador?
-## digite “http” (somente as letras, sem as aspas) na caixa de texto de especificação do filtro de exibição, de tal forma que apenas as mensagens HTTP capturadas serão exibidas na janela de listagem de pacotes. (Só estamos interessados em HTTP desta vez, e não desejamos ver todos os pacotes capturados).[[Arquivo:HTTP_Wireshark.png |thumb | 300px| Fig.1 Requisição e Resposta HTTP]]
+##E do servidor redes.sj.ifsc.edu.br?
-# O exemplo da figura 1 mostra na janela de listagem de pacotes duas mensagens HTTP capturadas:
+##Qual o código de status retornado do servidor para o seu navegador?
-## A mensagem GET (do seu navegador para o servidor web www.sj.ifsc.edu.br) e a mensagem de resposta do servidor para o seu navegador.
+##Quando o arquivo em HTML que você baixou foi modificado no servidor pela última vez?
-## A janela de conteúdos de pacotes mostra detalhes da mensagem selecionada (neste caso a mensagem HTTP GET /~odilson/RED29004//RED29004.html, que está em destaque na janela de listagem de pacotes).
+##Quantos bytes de conteúdo são baixados pelo seu navegador?
-## A mensagem HTTP transportada em um segmento TCP, que é carregado em um datagrama IP, que é levado em um quadro Ethernet com 5728 bits no fio. Isso é observado de baixo para cima na janela de detalhes do cabeçalho do pacote selecionado. O Wireshark exibe informações sobre o quadro, IP, TCP e HTTP. Você deve expandir as informações, por exemplo, do HTTP clicando na seta ao lado esquerdo de “Hypertext Transfer Protocol”. Observando as informações das mensagens HTTP GET e de resposta. Você consegue inclusive enxergar a mensagem mostrada no navegador: '''RED29004! Página de teste.'''
+##Encontre a mensagem '''Redes de Computadores IFSC - SJ - Telecomunicacoes! - Pagina de teste'''. Onde (em qual campo) encontra-se?
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Responda às seguintes perguntas e imprima as mensagens GET e a resposta e indique em que parte da mensagem você encontrou a informação que responde às questões.</span>
+##Qual a diferença entre os endereços IP e porta de origem e destino entre a mensagem GET e a de resposta do HTTP?
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O seu navegador executa HTTP 1.0 ou 1.1? Com uma mensagem GET selecionada, na janela central, clique na seta ao lado de ''Hypertext Transfer Protocol''</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual a versão de HTTP do servidor? Com uma mensagem 200 OK selecionada, na janela central, clique na seta ao lado de ''Hypertext Transfer Protocol''</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quais idiomas (se algum) o seu navegador indica ao servidor que pode aceitar?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o endereço IP do seu computador?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">E do servidor tele.sj.ifsc.edu.br?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o número da porta utilizada no seu computador?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">E do servidor tele.sj.ifsc.edu.br?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o código de status retornado do servidor para o seu navegador? É um número seguido por uma mensagem contendo um texto em inglês. São mensagem padronizadas do protocolo HTTP.</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quando o arquivo em HTML que você baixou foi modificado no servidor pela última vez?</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Encontre a mensagem '''RED29004! Página de teste'''. Vá clicando nas setas da janela central do wireshark. Onde (em qual campo) encontra-se?</span>
 ==Interação Básica GET/Resposta do HTTP usando TELNET e REQUISIÇÃO MANUAL==
@@ Linha 288: / Linha 317: @@
 ## Abra um terminal de texto no Linux.
 ## Execute este comando: <syntaxhighlight lang=bash>
-telnet -4 tele.sj.ifsc.edu.br 80
+telnet -4 redes.sj.ifsc.edu.br 80
 </syntaxhighlight>
-## Após aparecer esta linha: <syntaxhighlight lang=bash>
+## Após aparecer esta linha: <syntaxhighlight lang=text>
 Trying 200.135.37.75...
-Connected to tele.sj.ifsc.edu.br.
+Connected to redes.sj.ifsc.edu.br.
-Escape character is '^]'.</syntaxhighlight>digite o seguinte:<syntaxhighlight lang=bash>
+Escape character is '^]'.</syntaxhighlight>digite o seguinte:<syntaxhighlight lang=text>
-GET /~odilson/RED29004//RED29004.html HTTP/1.0</syntaxhighlight> em seguida <syntaxhighlight lang=bash>
+GET / HTTP/1.0
-<Enter> <Enter></syntaxhighlight>
+<Enter> <Enter>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Anote a página html que foi enviada como resposta.</span>
+</syntaxhighlight>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quanto tempo levou para fechar a conexão (após o duplo Enter)? Foi imediato?</span>
+## Pare a captura de pacotes.
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Refaça um pedido em que o recurso é inexistente no servidor (ex: GET /~odilson/RED29004//abacaxi). Observe a resposta. Qual é o código da mensagem recebida?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Identifique a página html que foi enviada como resposta. Respeita o protocolo HTTP (observe o cabeçalho)?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">No Wireshark compare o resultado das execuções desses comandos com o que se viu nas capturas Wireshark com acesso pelo navegador, em resumo, compare a troca de mensagens via navegador e terminal (cabeçalhos). Qual a diferença em cada caso?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quanto tempo levou para fechar a conexão (após o duplo Enter)?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Refaça um pedido em que o recurso é inexistente no servidor (ex: página html com nome/URL inexistente). Observe a resposta. Qual é o código da mensagem recebida?</span>
 # Refaça a conexão com o servidor:<syntaxhighlight lang=bash>
-telnet -4 tele.sj.ifsc.edu.br 80</syntaxhighlight>
+telnet -4 redes.sj.ifsc.edu.br 80</syntaxhighlight>
 ## Refaça o pedido, mas agora utilizando o HTTP/1.1, e tente inferir a diferença da versão 1.0. Note que o GET nesta versão deve ser realizado com o campo Host:<syntaxhighlight lang=bash>
-GET /~odilson/RED29004//RED29004.html HTTP/1.1
+GET / HTTP/1.1
-Host: tele.sj.ifsc.edu.br
+HOST: redes.sj.ifsc.edu.br
-<enter>/<enter></syntaxhighlight>
+<Enter>/<Enter></syntaxhighlight>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quanto tempo levou para fechar a conexão (após o duplo Enter)?</span>
 # Refaça a conexão com o servidor:<syntaxhighlight lang=bash>
-telnet -4 tele.sj.ifsc.edu.br 80 </syntaxhighlight>
+telnet -4 redes.sj.ifsc.edu.br 80
+</syntaxhighlight>
 ## Refaça o pedido, mas agora utilizando o HTTP/1.1:<syntaxhighlight lang=bash>
-GET /~odilson/RED29004//RED29004.html HTTP/1.1
+GET / HTTP/1.1
-Host: tele.sj.ifsc.edu.br
+HOST: redes.sj.ifsc.edu.br
-<enter>/<enter></syntaxhighlight>
+<Enter>/<Enter>
-## Antes do fechamento da conexão, faça um novo pedido na conexão já aberta:<syntaxhighlight lang=bash>
+</syntaxhighlight>
-GET /~odilson/RED29004//RED29004_arq3.html HTTP/1.1
+## <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">Seja rápido</span>. Antes do fechamento da conexão, faça um novo pedido na conexão já aberta:<syntaxhighlight lang=bash>
-Host: tele.sj.ifsc.edu.br
+GET /Redes_arq1.html HTTP/1.1
-<enter>/<enter></syntaxhighlight>
+Host: redes.sj.ifsc.edu.br
+<Enter>/<Enter>
+</syntaxhighlight>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O que explica a diferença de tempo para fechamento de conexão entre as versões HTTP 1.0 e 1.1? </span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Descreva qual seria o procedimento para o download de dois objetos, via telnet, nos protocolos HTTP 1.0 e 1.1?</span>
 =Desvendando o HTTP com Wireshark - AVANÇADO=
 ==Objetivos==
 * Explorar GET Condicional/Resposta no protocolo HTTP.
 * Analisar documentos HTML com Objetos Incluídos
 * Comparar as mensagens nos protocolos HTTP X HTTPS.
-==Fonte base==
+===Fonte base===
+* [http://docente.ifsc.edu.br/odilson/RDC60807/Desvendando%20o%20HTTP%20avancado.pdf SLIDES DE APOIO: Desvendando o HTTP - Avançado - Baseado na Pearson/Kurose]
-* [http://docente.ifsc.edu.br/odilson/RCO60803/Desvendando%20o%20HTTP%20avancado.pdf SLIDES DE APOIO: Desvendando o HTTP - Avançado - Baseado na Pearson/Kurose]
 * [http://www.ebah.com.br/content/ABAAABZ6QAD/wireshark-http Wireshark - HTTP]
 * [https://pt.wikipedia.org/wiki/Hypertext_Transfer_Protocol HTTP na Wikipedia]
 ==PARTE 1 - A Interação HTTP GET Condicional/Resposta==
-A maioria dos navegadores web tem um cache (seção 2.2.6 do livro) e, desta forma, realizam GET condicional quando pretendem baixar um objeto HTTP já presente em seu cache.
+#A maioria dos navegadores web tem um cache (seção 2.2.6 do livro) e, desta forma, realizam GET condicional quando baixam um objeto HTTP. Execute os seguintes passos:
+##Inicie o navegador web;
-Execute os seguintes passos:
+##Limpe o cache do seu navegador ('''Ctrl + Shift + Del''');
-# Inicie o Firefox;
+##Inicie o Wireshark;
-# Limpe o cache do seu navegador('''Ctrl + Shift + Del''');
+##Digite o URL no navegador  http://redes.sj.ifsc.edu.br. Seu navegador deve exibir um arquivo em HTML muito simples com duas linhas;
-# Inicie o Wireshark;
+##Pressione o botão “refresh” no navegador (ou digite o URL novamente);
-# Digite o URL no navegador http://tele.sj.ifsc.edu.br/~odilson/RED29004//RED29004.html.
+##No Wireshark pare a captura de pacotes e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP sejam apresentadas na janela de listagem de pacotes.
-# Seu navegador deve exibir um arquivo em HTML muito simples com duas linhas;
+#<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Responda às seguintes questões:
-# Pressione o botão ''refresh'' ('''F5''') no navegador (ou digite o URL novamente);
+##Inspecione o conteúdo da primeira mensagem - HTTP GET - do seu navegador para o servidor redes.sj.ifsc.edu.br. Você vê uma linha “If-Modified-Since”?
-# Pare a captura de pacotes, e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP sejam apresentadas na janela de listagem de pacotes.
+##Inspecione o conteúdo da resposta do servidor, segunda mensagem. O servidor retornou explicitamente o conteúdo do arquivo? Como você pode dizer isso?
-#* Se você realizou o procedimento corretamente, você visualizará um total de 6 mensagens no Wireshark: três GETs e três respostas.
+##Agora inspecione o conteúdo da terceira mensagem - HTTP GET - do seu navegador para o servidor. Você vê uma linha “If-Modified-Since”? Caso a resposta seja afirmativa, qual informação segue o cabeçalho “If-Modified-Since”?
-#* <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">Obs: Para fins de análise, despreze a solicitação e resposta relativa ao ''favicon.ico'', que é relativa ao ''download'' do ícone do IFSC.</span>
+##Qual é o código de status e a frase retornada do servidor na resposta à terceira mensagem HTTP GET? É diferente do código de retorno da primeira mensagem? Qual é o código?
+##Na terceira resposta, o servidor retornou explicitamente o conteúdo do arquivo? Explique.
-<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tarefa:</span>
+##Qual o tamanho da primeira e terceira mensagem de retorno (respostas) do servidor?
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Inspecione o conteúdo da primeira mensagem HTTP GET do seu navegador para o servidor tele.sj.ifsc.edu.br. Você vê uma linha “If-Modified-Since”?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Inspecione o conteúdo da primeira resposta do servidor. O servidor retornou explicitamente o conteúdo do arquivo? Como você pode dizer isso?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Agora inspecione o conteúdo da segunda mensagem HTTP GET do seu navegador para o servidor. Você vê uma linha “If-Modified-Since”? Caso a resposta seja afirmativa, qual informação segue o cabeçalho “If-Modified-Since”?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é o código de status e a frase retornada do servidor na resposta à segunda mensagem HTTP GET? É diferente do código de retorno da primeira mensagem?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O servidor retornou explicitamente o ojeto HTTP na segunda requisição? Explique.</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o tamanho da primeira e segunda mensagem de retorno do servidor? O que explica a diferença de tamanho?</span>
 ==PARTE 2 - Documentos HTML com Objetos Incluídos==
-Agora que vimos como o Wireshark mostra o tráfego capturado para arquivos em HTML simples, também podemos observar o que acontece quando o seu browser baixa um arquivo com objetos incluídos, no nosso exemplo, imagens que estão armazenadas em outros servidores.
+#Agora que vimos como o Wireshark mostra o tráfego capturado para arquivos em HTML grandes, nós podemos observar o que acontece quando o seu navegador baixa um arquivo principal com objetos incluídos, no nosso exemplo, imagens que estão armazenadas em outros servidores. Faça o seguinte:
+##Inicie o navegador web;
-Faça o seguinte:
+##Limpe o cache do seu navegador ('''Ctrl + Shift + Del''');
-# Inicie o Firefox;
+##Inicie o Wireshark;
-# Limpe o cache do seu navegador;
+##Digite o URL no navegador  http://redes.sj.ifsc.edu.br/Redes_arq3.html. Seu navegador deve exibir um arquivo pequeno em HTML com duas imagens incluídas. Estas duas imagens estão referenciadas no arquivo em HTML. Isto é, as imagens não são conteúdos do arquivo em HTML e nem estão depositadas no mesmo servidor, ao invés disso, há um URL para cada imagem no arquivo em HTML. Como discutido no livro, seu navegador terá que baixar estas imagens dos locais correspondentes. As imagens estão em docente.ifsc.edu.br;
-# Inicie o Wireshark;
+#Digite o URL no navegador  http://redes.sj.ifsc.edu.br/Redes_arq4.html. Seu navegador deve exibir um arquivo pequeno em HTML com cinco imagens incluídas. Estas cinco imagens,diferentemente do caso anterior, estão depositadas no próprio sítio navegado;
-# Digite o URL no navegador  http://tele.sj.ifsc.edu.br/~odilson/RED29004/RED29004_arq3.html;
+#Pare a captura de pacotes, e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP seja exibidas.
-# Seu navegador deve exibir um arquivo pequeno em HTML com duas imagens incluídas.
+#<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Responda às seguintes questões, separando as respostas para o acesso ao Redes_arq3.html e Redes_arq4.html (6 respostas):
-#* Estas duas imagens estão referenciadas no objeto HTML. Isto é, as imagens não estão contidas no objeto HTML e sim referenciadas no mesmo, um URL para cada imagem.
+##Quantas mensagens HTTP GET foram enviadas pelo seu navegador em cada acesso? (<span style="color:red;">desconsidere a requisição e resposta (erro) da mensagem favicon</span>)
-#* Como discutido no livro, seu navegador terá que baixar estas imagens dos locais correspondentes.
+##Para quais endereços na Internet (URI = Host + URL) estas mensagens foram enviadas em cada acesso?
-# Verifique o código fonte da página, clicando com o botão direito do mouse sobre ela no navegador e em '''inspecionar'''.
+##Você consegue dizer se o seu navegador baixou imagens com ou sem paralelismo? Explique e diferencie o comportamento em cada um dos casos.
-#* Observe os links dentro do código html.
-# Digite o URL no navegador  http://tele.sj.ifsc.edu.br/~odilson/RED29004/RED29004_arq4.html.
-# Seu navegador deve exibir um arquivo pequeno em HTML com cinco imagens incluídas.
-#* Estas cinco imagens,diferentemente do caso anterior, estão depositadas no próprio sítio do professor;
-# Verifique o código fonte da página, clicando com o botão direito do mouse sobre ela no navegador e em '''inspecionar'''.
-#* Observe os links dentro do código html.
-# Pare a captura de pacotes, e digite “http” na caixa de texto de especificação de filtro, para que apenas as mensagens HTTP seja exibidas.
-<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tarefa:</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quantas mensagens HTTP GET foram enviadas pelo seu navegador em cada acesso?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Para quais endereços na Internet (URI = Hosta + URL) estas mensagens foram enviadas em cada acesso?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Você consegue dizer se o seu navegador baixou imagens com ou sem paralelismo? Explique e diferencie o comportamento em cada um dos casos, em sítios diferentes e no mesmo sítio.</span>
 ==PARTE 3 - Segurança com HTTPS==
-Para finalizar, vamos capturar sequências de mensagens HTTPS, somente a título de comparação.
+*O Hyper Text Transfer Protocol Secure (HTTPS) é uma implementação do protocolo HTTP sobre uma camada adicional de segurança que utiliza o protocolo SSL/TLS e permite a transmissão de dados numa conexão criptografada através de certificados digitais.
+*Caso tenha interesse em analisar troca de mensagens HTTPS e verificar seus conteúdos siga o roteiro [https://www.comparitech.com/net-admin/decrypt-ssl-with-wireshark/#:~:text=Configure%20Wireshark%20to%20decrypt%20SSL&text=Open%20Wireshark%20and%20click%20Edit,)%2DMaster%2DSecret%20log%20filename. ''How to Decrypt SSL and TLS Traffic Using Wireshark'']
-Execute os seguintes procedimentos:
-# Inicie o Firefox;
-# Limpe o cache do seu navegador;
-# Inicie o Wireshark;
-# Digite o seguinte URL no navegador https://www.ssllabs.com/ssltest/;
-# Pare a captura de pacotes e digite "ssl" na caixa de texto de especificação de filtro, para que apenas as mensagens criptografadas sejam exibidas.
-<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Tarefa:</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Compare a sequência de troca de mensagens (GET e resposta) entre o HTTP (das seções anteriores) com o ssl, existe alguma similaridade?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Que tipos de informações (info) são mais presentes nesse tipo de mensagens?</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Você consegue identificar o conteúdo de alguma nas mensagens ssl, como no caso das mensagens HTTP?</span>
-=Camada de Aplicação: Colocando no "ar" aplicações servidoras=
-==Objetivos==
-*Testar serviços de rede na camada de aplicação.
-*Construir uma pequena internet, colocando dois serviços no "ar": um '''servidor ssh''', um servidor DNS e um '''web server''', .
-*Uma visão do posicionamento dos "pacotes de aplicação" capturados para cada um destes serviços.
-Os serviços são, portanto:
-<blockquote style="background: #DCF4CC; border: 1px solid black; padding: 1em;">
-*serviço SSH: ''Secure Shell'', terminal remoto. Permite acessar um computador remoto através de um terminal.
-*serviço DNS: Vai permitir a navegação através de nomes de máquinas.
-*serviço WEB: permite hospedar e acessar remotamente páginas da Internet.
-</blockquote>
-Rede a ser implementada
-[[Arquivo:RedeLab4.png|800px|Rede Lab4]]
-==Servidor SSH==
-# Vamos usar o simulador imunes para nos apropriarmos do sentimento do comportamento em camadas em uma rede simples. Construir no Imunes a rede a seguir ou, se preferir, importe o arquivo (clique com o direito do mouse e mande baixar) https://docente.ifsc.edu.br/odilson/Redes/Camada_aplicacao.imn.
-# Inicie o Imunes e carregue o arquivo salvo (Camada_aplicacao.imn).
-# Iniciando a REDE: <syntaxhighlight lang=bash>
-Experiment >> Execute </syntaxhighlight>
-# Executando serviço SSH. O serviço SSH será iniciado no '''servidor SSH''' (SSH SERVER).
-## Primeiramente vamos atribuir uma senha ao usuário root no servidor. Atribua senha '''''root''''' (SSH SERVER) com o seguinte comando no terminal: <syntaxhighlight lang=bash>
-passwd </syntaxhighlight>
-##* Enquanto digita-se a senha o terminal nada apresenta, é normal.
-##* Ao terminar de digitar a senha tecle <enter>. Será solicitado a confirmação da senha com o mesmo procedimento.</enter>
-## Em seguida vamos fazer uma pequena configuração no '''servidor SSH''' (SSH SERVER), através do comando: <syntaxhighlight lang=bash>
-echo PermitRootLogin yes >>/etc/ssh/sshd_config </syntaxhighlight>
-## Iniciamos o serviço, através do comando: <syntaxhighlight lang=bash>
-/etc/init.d/ssh start
-/etc/init.d/ssh reload </syntaxhighlight>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira se o serviço está rodando: </span><syntaxhighlight lang=bash>
-ps aux </syntaxhighlight>
-##* Observe se há um processo do tipo, última coluna a direita: /usr/sbin/sshd
-## Agora vamos testar a conectividade do serviço fazendo uma acesso remoto, por exemplo, no terminal do '''pc2''' execute: <syntaxhighlight lang=bash>
-ssh 10.0.9.10 </syntaxhighlight>
-##* Na primeira pergunta responda com yes
-##* Na segunda pergunta preencha com a senha: root
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observe e salve que o prompt do seu terminal mudou para '''root@ssh:~#''',</span> isso significa que, apesar de você estar no terminal do pc2, vocês está conectado no SSH SERVER. Tudo que você digitar estará sendo executado no SSH SERVER.
-## No terminal do '''pc2''', que na verdade está conectado ao servidor '''SSH SERVER''', vamos deixar um ping testando a conectividade com o próprio '''pc2''': <syntaxhighlight lang=bash>
-ping 10.0.8.20 </syntaxhighlight>
-# Agora vamos capturar pacotes do ssh. Basta usar o Wireshark em qualquer interface onde passam os pacotes. Por exemplo, no '''router2'''.<syntaxhighlight lang=bash>
-Clique com o direito do mouse sobre o router2 >> Wireshark >> eth0 </syntaxhighlight>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Recorte a tela do Wireshark, filtrando os pacotes do '''ssh'''. Mostre o encapsulamento de pacotes de aplicação e seu posicionamento na estrutura de pacotes.</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Recorte a tela do Wireshark, filtrando os pacotes do '''icmp'''. Comprovando que os pacotes do ping estão passando pelo '''router2'''.</span>
-# Para encerrar a conexão ao '''SSH SERVER''', no terminal do '''pc2''' digite: <syntaxhighlight lang=bash>
-exit </syntaxhighlight>
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observe e salve que o prompt do seu terminal mudou para '''root@pc2:~#'''</span>, isso significa que a conexão foi encerrada.
-==Servidor DNS==
-*Com este serviço vamos instalar o banco de dados de um servidor DNS, [https://www.isc.org/bind/ BIND]. Ele dará suporte a navegação por nomes de máquinas.
-===Criando um domínio de Internet===
-# Vá até o diretório de configuração do BIND, por exemplo vamos fazer isso no '''host2''' da LAN inferior: <syntaxhighlight lang=bash>
-cd /etc/bind </syntaxhighlight>
-# Defina uma zona, um ''Second Level Domain'', de nome '''redes.edu.br'''. Isto é feito editando o arquivo '''named.conf.default-zones'''. Abra o terminal do '''host2''' e digite:<syntaxhighlight lang=bash>
-nano named.conf.default-zones </syntaxhighlight>
-# Acrescente ao final do mesmo o seguinte conteúdo: <syntaxhighlight lang=bash>
-zone "redes.edu.br" {
-        type master;
-        file "/etc/bind/db.redes";
-}; </syntaxhighlight>
-#* Ao terminar de editar digite '''<CRTL> + X''', em seguida, '''Y''' e '''<Enter>'''.
-#* Este arquivo definirá uma nova zona (domínio) DNS.
-===Criando a base de dados relativa ao domínio===
-# Na zona criada atribua endereços IPv4 (A) as máquinas em '''db.redes: <syntaxhighlight lang=bash>
-nano db.redes </syntaxhighlight>
-# Cole o seguinte conteúdo no arquivo e salve:''': <syntaxhighlight lang=bash>$TTL    86400
-@       IN      SOA     ns.redes.edu.br. root (
-                2022051200      ; Serial
-          ; Refresh
-           ; Retry
-                2419200         ; Expire
-)         ; Negative Cache TTL
-;
-@               IN      NS      ns.redes.edu.br.
-@               IN      MX      10      mail.redes.edu.br.
-$ORIGIN redes.edu.br.
-ns              IN  A   10.0.6.10
-www             IN  A   10.0.9.11
-ssh             IN  A   10.0.9.10
-mail            IN  A   10.0.6.10
-apelido         IN  CNAME       mail.redes.edu.br. </syntaxhighlight>
-# Reinicie o serviço DNS: <syntaxhighlight lang=bash> /etc/init.d/bind9 restart </syntaxhighlight>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Faça um teste com consulta ao seu servidor com o comando, por exemplo: </span><syntaxhighlight lang=bash> dig @localhost www.redes.edu.br </syntaxhighlight>
-#*O resultado obtido deve conter algo do tipo:<syntaxhighlight lang=bash>
-;; ANSWER SECTION:
-www.redes.edu.br.       86400   IN      A       10.0.9.11 </syntaxhighlight>
-===Configurando as máquinas para acessarem o DNS===
-# Em qualquer máquina que desejar navegar por nomes, declare o servidor '''host2''' como '''servidor DNS''' com o seguinte comendo digitado no respectivo terminal: <syntaxhighlight lang=bash>
-echo nameserver 10.0.6.10 >> /etc/resolv.conf </syntaxhighlight>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Faça alguns testes simples via ping, por exemplo: </span><syntaxhighlight lang=bash>
-ping www.redes.edu.br
-ping apelido.redes.edu.br </syntaxhighlight>
-# Acrescente um novo endereço ao banco de dados: '''casa.redes.edu.br''' apontando para o IP '''10.0.8.21'''.
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Prove que o mesmo está funcional, por exemplo, dando um ping casa.redes.edu.br a partir do host ssh.</span>
-# No terminal do '''host2''' execute:  <syntaxhighlight lang=bash>
-dig apelido.redes.edu.br </syntaxhighlight>
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual foi o resultado obtido?</span>
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o significado?</span>
-==Servidor WEB==
-# Preparando uma página HTML para colocar no servidor WEB.
-#* Páginas da internet são construídas usando o formato HTML.
-#* Ver aqui o que é uma página [https://wiki.sj.ifsc.edu.br/images/e/ee/03_-_HTML.pdf HTML] e como construir uma página simples.
-## No terminal da máquina '''WEB SERVER''' entre no diretório diretório''' /var/www/html''': <syntaxhighlight lang=bash>
-cd /var/www/html </syntaxhighlight>
-## Use o editor nano para editar uma página chamada '''index.html''': <syntaxhighlight lang=bash>
-nano index.html </syntaxhighlight>
-##* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Salve um print com o editor aberto.</span>
-## Crie a página com o seguinte conteúdo: <syntaxhighlight lang=c>
-<html>
-<body>
-<h1>Redes de Computadores</h1>
-<p>Pagina teste do aluno Pedro Alvares Cabral da Silva</p>
-</body>
-</html>
-</syntaxhighlight>
-##* Ao terminar de editar digite '''<Ctrl> + <X>''' e, em seguida, '''Y''' e '''<Enter>'''.
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Verifique se o conteúdo está correto:</span> <syntaxhighlight lang=bash>
-cat index.html </syntaxhighlight>
-## Inicie o SERVIÇO WEB para testar o protocolo HTTP. O servidor WEB irá disponibilizar a página criada para acesso remoto via protocolo HTTP: <syntaxhighlight lang=bash>
-/etc/init.d/lighttpd start </syntaxhighlight>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira se o programa está executando no servidor através do comando:</span> <syntaxhighlight lang=bash>
-ps aux </syntaxhighlight>
-# No '''router2''' deixe o Wireshark capturando pacotes.
-# Faça um acesso a sua página, a partir do Firefox (cliente HTTP) em um PC cliente de sua escolha: <syntaxhighlight lang=bash>Clique com o botão direito do mouse sobre, por exemplo, o pc1
-Clique sobre Web Browser
-Digite no navegador: www.redes.edu.br ou 10.0.9.11 </syntaxhighlight>
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">RECORTE a tela com a página em destaque no navegador e cole no relatório.</span>
-# Se desejar modificar a página repita os itens 2 e 3.
-# Crie uma nova página  <syntaxhighlight lang=bash>
-nano abacaxi.html </syntaxhighlight>
-# Coloque um conteúdo a seu critério: <syntaxhighlight lang=c>
-<html>
-<body>
-<h1>Redes de Computadores</h1>
-<p>Minha primeira pagina..........</p>
-</body>
-</html>
-</syntaxhighlight>
-#* Ao terminar de editar digite '''<Ctrl> + <X>''' e, em seguida, '''Y''' e '''<Enter>'''.
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Verifique se o conteúdo está correto:</span> <syntaxhighlight lang=bash>
-cat abacaxi.html </syntaxhighlight>
-# Acesse a nova página através do navegador Firefox com o endereço (URL):  <syntaxhighlight lang=bash>http://www.redes.edu.br/abacaxi.html </syntaxhighlight>
-#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">RECORTE a tela com a página em destaque no navegador e cole no relatório.</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Salve um print da tela do Wireshark destacando a troca de mensagens HTTP e o conteúdo HTML de uma das páginas acessadas.</span>
 =Serviço de Nomes (DNS)=
@@ Linha 562: / Linha 410: @@
 * Uma resposta é recebida deste servidor.
-==Fonte Base==
+===Fonte Base===
-* [https://docente.ifsc.edu.br/odilson/RCO60807/Servico%20de%20Nomes%20DNS.pdf Serviço de Nomes - DNS]
+* [https://docente.ifsc.edu.br/odilson/RDC60807/Servico%20de%20Nomes%20DNS.pdf Serviço de Nomes - DNS]
 ==PARTE 1: Consulta simples ao DNS gerada a partir de um comando ping==
@@ Linha 577: / Linha 425: @@
 # Inicie o wireshark para capturar os pacotes.
 # Execute o ping para um endereço de host conhecido <syntaxhighlight lang=bash>
-ping -4 www.sorbonne.fr</syntaxhighlight>
+ping4 -c2 www.ufsc.br</syntaxhighlight>
 # Pare a captura de pacotes no Wireshark e coloque um filtro de display para mostrar apenas mensagens DNS e de ICMP<syntaxhighlight lang=bash>
 dns || icmp </syntaxhighlight>
@@ Linha 597: / Linha 445: @@
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O ping gerou pergunta para cada um deles, ou somente para um?</span>
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o tipo da RR associada a pergunta (''Queries''). O que significa?</span>
-#**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual endereço IP retornado para o www.sorbonne.fr?</span>
+#**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual endereço IP retornado para o www.ufsc.br?</span>
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual endereço IP usado no ping (ver pacote REQUEST ICMP)?</span>
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual protocolo de transporte, camada 4, que foi usado para transportar as mensagens de aplicação DNS?</span>
-#**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quais os servidores autorizados (''Authoritative nameservers'') foram repassados em resposta a sua consulta?</span>
 #** Logo após o primeiro ping existe mais uma consulta DNS. Esta pergunta é realizada através de uma mensagem do tipo PTR. O ping está tentando verificar qual é o nome da máquina que realmente está respondendo. É o DNS reverso, nesse tipo de consulta se fornece um IP e o servidor devolve o nome da máquina.
 #** <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Perguntas a serem respondidas:</span>
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o IP que se pretende resolver?</span>
 #**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o nome retornado?</span>
-#**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O nome retornado é www.sorbonne.fr? Sim ou não? Explique.</span>
+#**# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">O nome retornado é www.ufsc.br? Sim ou não? Explique.</span>
 ==PARTE 2 - Consultas DNS por meio de ferramentas especializadas==
@@ Linha 613: / Linha 460: @@
 #* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">www.google.com</span>
 #* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">www.gmail.com</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Agora descubra e anote no relatório quais são os servidores DNS responsáveis por cada um dos domínios dos nomes acima</span>.
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Agora descubra e anote no relatório quais são os servidores DNS responsáveis por cada um dos '''domínios''' (p.e.: ifsc.edu.br) dos nomes acima</span>.
 #* Para isso consulte o valor do registro NS associado a esses domínios.
 #* Por exemplo, com o programa ''host'' ou ''dig'' isso pode ser feito assim: <syntaxhighlight lang=bash>
@@ Linha 648: / Linha 495: @@
 # Consultando um servidor explícito(@)<syntaxhighlight lang=bash>
 dig @j.root-servers.net. +trace www.sj.ifsc.edu.br. </syntaxhighlight>
+==Algumas consultas AAAA==
+Vamos expandir um pouco nossos horizontes e fazer algumas consultas envolvendo IPv6.
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">No terminal de sua máquina faça uma consulta e responda: qual o endereço IPv6 dos hosts? Por exemplo: </span><syntaxhighlight lang=bash>
+dig AAAA google.com
+host -t AAAA google.com </syntaxhighlight>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">ipv6.br</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">www.microsoft.com</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Agora vamos fazer a consulta reversa. Qual é o nome de host dos seguintes endereços? Por exemplo: </span><syntaxhighlight lang=bash>
+dig -x 2800:3f0:4001:82c::200e
+dig -x 2800:3f0:4001:82c::200e +short
+host 2800:3f0:4001:82c::200e </syntaxhighlight>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2001:12ff:0:4::9</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2001:12d0:0:126::183:244</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2600:1419:3e00:190::356e</span>
 # AVANÇADO. <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">Execute somente se tiver curiosidade</span>. Como explicado durante a aula e visto no exercício anterior, DNS é um banco de dados distribuído. Isso quer dizer que suas informações estão espalhadas em milhares (ou milhões?) de servidores DNS mundo afora. Cada servidor DNS mantém os dados dos domínios por que é responsável. Será que é possível rastrear todos os servidores DNS que devem ser consultados até chegar ao servidor do domínio procurado? Posto de outro modo, vamos fazer todo o processo de requisição interativa, do exercício anterior, manualmente, ou seja, descobrir quem é o ''Root Level Domain'', o ''Top Level Domain'' e o ''Second Level Domain''. Anote no relatório.
 ## Descubra quem são os servidores raiz (topo de hierarquia DNS): <syntaxhighlight lang=bash>
@@ Linha 659: / Linha 521: @@
 host -v -t a www.sj.ifsc.edu.br. b.dns.br </syntaxhighlight>
 ## Quantos servidores DNS foram necessários consultar no total?
-==Algumas consultas AAAA==
-Vamos expandir um pouco nossos horizontes e fazer algumas consultas envolvendo IPv6.
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">No terminal de sua máquina faça uma consulta e responda: qual o endereço IPv6 dos hosts? Por exemplo: </span><syntaxhighlight lang=bash>
-dig AAAA google.com
-host -t AAAA google.com </syntaxhighlight>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">ipv6.br</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">www.microsoft.com</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Agora vamos fazer a consulta reversa. Qual é o nome de host dos seguintes endereços? Por exemplo: </span><syntaxhighlight lang=bash>
-dig -x 2001:12ff::10
-dig -x 2001:12ff::10 +short
-host 2001:12ff::10 </syntaxhighlight>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2801:84:0:2::10</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2001:12d0:0:126::183:244</span>
-## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">2001:12ff::10</span>
 ==Exemplos de arquivos de um ''Second Level Domain'' fictício==
@@ Linha 714: / Linha 561: @@
        IN      PTR     ftp.redes.edu.br.
        IN      PTR     mail.redes.edu.br. </syntaxhighlight>
+=Camada de Aplicação: Colocando no "ar" aplicações servidoras=
+==Objetivos==
+*Testar serviços de rede na camada de aplicação.
+*Construir uma pequena internet, colocando dois serviços no "ar": um '''servidor ssh''', um '''servidor DNS''' e um '''web server''', .
+*Uma visão do posicionamento dos "pacotes de aplicação" capturados para cada um destes serviços.
+Os serviços são, portanto:
+<blockquote style="background: #DCF4CC; border: 1px solid black; padding: 1em;">
+*serviço SSH: ''Secure Shell'', terminal remoto. Permite acessar um computador remoto através de um terminal seguro.
+*serviço DNS: Vai permitir a navegação através de nomes de máquinas. Com este serviço vamos configurar o banco de dados de um servidor DNS, [https://www.isc.org/bind/ BIND]. Ele dará suporte a navegação por nomes de máquinas.
+*serviço WEB: permite hospedar e acessar remotamente páginas da Internet.
+</blockquote>
+==Topologia de rede para experimetação==
+[[Arquivo:Internet_Servidores.png|800px|"Internet"]]
+==Servidor SSH==
+# Vamos usar o simulador '''Imunes''' para nos apropriarmos do sentimento do comportamento em camadas em uma rede simples. Construir no Imunes a rede a seguir ou, se preferir, importe o arquivo digitando no terminal: <syntaxhighlight lang=bash>
+wget http://redes.sj.ifsc.edu.br/Camada_aplicacao.imn </syntaxhighlight>
+# Inicie o '''Imunes''' e carregue o arquivo salvo (Camada_aplicacao.imn).
+# Iniciando a REDE: <syntaxhighlight lang=bash>
+Experiment >> Execute </syntaxhighlight>
+# Executando serviço SSH. O serviço SSH será iniciado no '''servidor SSH''' (SSH SERVER).
+## Primeiramente vamos atribuir uma senha ao usuário root no servidor SSH, por exemplo, atribua senha '''''root''''' (SSH SERVER) com o seguinte comando no terminal do SSH SERVER (duplo clique sobre a máquina SSH SERVER abre o terminal de comandos da mesma): <syntaxhighlight lang=bash>
+passwd </syntaxhighlight>
+##* <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">Durante a digitação da senha, nada é apresentado no terminal, é normal</span>.
+##* Ao terminar de digitar a senha tecle <enter>. Será solicitado a confirmação da senha com o mesmo procedimento.</enter>
+## Em seguida vamos fazer uma pequena configuração no '''servidor SSH''' (SSH SERVER), através do comando: <syntaxhighlight lang=bash>
+echo PermitRootLogin yes >>/etc/ssh/sshd_config </syntaxhighlight>
+## Iniciamos o serviço, através do comando: <syntaxhighlight lang=bash>
+/etc/init.d/ssh start
+/etc/init.d/ssh reload </syntaxhighlight>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira se o serviço está rodando, através do comando: </span><syntaxhighlight lang=bash>
+ps aux </syntaxhighlight>
+##* Observe se há um processo do tipo, última coluna a direita: /usr/sbin/sshd
+## Agora vamos testar a conectividade do serviço fazendo uma acesso remoto, por exemplo, no terminal do '''pc2''' execute: <syntaxhighlight lang=bash>
+ssh 10.0.9.10 </syntaxhighlight>
+##* Na primeira pergunta responda com yes
+##* Na segunda pergunta preencha com a senha: root
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observe e salve que o prompt do seu terminal mudou para '''root@ssh:~#''',</span> isso significa que, apesar de você estar no terminal do pc2, vocês está conectado no SSH SERVER. Tudo que você digitar estará sendo executado no SSH SERVER.
+## No terminal do '''pc2''', que na verdade está conectado ao servidor '''SSH SERVER''', vamos deixar um ping testando a conectividade com o próprio '''pc2''': <syntaxhighlight lang=bash>
+ping 10.0.8.20 </syntaxhighlight>
+# Agora vamos capturar pacotes do ssh. Basta usar o Wireshark em qualquer interface onde passam os pacotes. Por exemplo, no '''router2'''.<syntaxhighlight lang=bash>
+Clique com o direito do mouse sobre o router2 >> Wireshark >> eth0 </syntaxhighlight>
+# Pare o ping.
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Recorte a tela do Wireshark, filtrando os pacotes do '''ssh'''. Mostre o encapsulamento de pacotes de aplicação e seu posicionamento na estrutura de pacotes.</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Recorte a tela do Wireshark, filtrando os pacotes do '''icmp'''. Comprovando que os pacotes do ping estão passando pelo '''router2'''.</span>
+# Para encerrar a conexão ao '''SSH SERVER''', no terminal do '''pc2''' digite: <syntaxhighlight lang=bash>
+exit </syntaxhighlight>
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observe e salve que o prompt do seu terminal mudou para '''root@pc2:~#'''</span>, isso significa que a conexão foi encerrada.
+==Servidor DNS==
+===Criando um domínio de Internet===
+# Abra o terminal do '''DNS_Server''', vá até o diretório de configuração do BIND com o comando: <syntaxhighlight lang=bash>
+cd /etc/bind </syntaxhighlight>
+# Defina uma zona, um ''Second Level Domain'', de nome '''redes.edu.br'''. Isto é feito editando o arquivo '''named.conf.default-zones'''. No terminal do '''DNS_Server''' e digite:<syntaxhighlight lang=bash>
+nano named.conf.default-zones </syntaxhighlight>
+# Acrescente '''ao final''' do mesmo o seguinte conteúdo: <syntaxhighlight lang=bash>
+zone "redes.edu.br" {
+        type master;
+        file "/etc/bind/db.redes";
+}; </syntaxhighlight>
+#* Ao terminar de editar digite '''<CRTL> + X''', em seguida, '''Y''' e '''<Enter>'''.
+#* Este arquivo definirá uma nova zona (domínio) DNS.
+===Criando a base de dados relativa ao domínio===
+# Na zona criada atribua endereços IPv4 (A) as máquinas em '''db.redes: <syntaxhighlight lang=bash>
+nano db.redes </syntaxhighlight>
+# Cole o seguinte conteúdo no arquivo e salve:''': <syntaxhighlight lang=bash>$TTL    86400
+@       IN      SOA     ns.redes.edu.br. root (
+                2022051200      ; Serial
+          ; Refresh
+           ; Retry
+                2419200         ; Expire
+)         ; Negative Cache TTL
+;
+@               IN      NS      ns.redes.edu.br.
+@               IN      MX      10      mail.redes.edu.br.
+$ORIGIN redes.edu.br.
+ns              IN  A   10.0.6.10
+www             IN  A   10.0.9.11
+ssh             IN  A   10.0.9.10
+mail            IN  A   10.0.6.10
+apelido         IN  CNAME       mail.redes.edu.br. </syntaxhighlight>
+#*Ao terminar de editar digite '''<CRTL> + X''', em seguida, '''Y''' e '''<Enter>'''.
+#*Este arquivo definirá o banco de dados do DNS.
+# Reinicie o serviço DNS, através do comando: <syntaxhighlight lang=bash> /etc/init.d/bind9 restart </syntaxhighlight>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Faça um teste com consulta ao seu servidor com o comando, por exemplo: </span><syntaxhighlight lang=bash> dig @localhost www.redes.edu.br </syntaxhighlight>
+#*O resultado obtido deve conter algo do tipo:<syntaxhighlight lang=bash>
+;; ANSWER SECTION:
+www.redes.edu.br.       86400   IN      A       10.0.9.11 </syntaxhighlight>
+===Configurando as máquinas para acessarem o DNS===
+# Em qualquer máquina que desejar navegar por nomes, declare o servidor '''DNS_Server''' como '''servidor DNS''' com o seguinte comendo digitado no respectivo terminal: <syntaxhighlight lang=bash>
+echo nameserver 10.0.6.10 >> /etc/resolv.conf </syntaxhighlight>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Faça alguns testes simples via ping, por exemplo: </span><syntaxhighlight lang=bash>
+ping www.redes.edu.br
+ping apelido.redes.edu.br </syntaxhighlight>
+# Acrescente um novo endereço ao banco de dados: '''casa.redes.edu.br''' apontando para o IP '''10.0.8.21'''.
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Prove que o mesmo está funcional, por exemplo, dando um ping casa.redes.edu.br a partir do host ssh.</span>
+# No terminal do '''DNS_Server''' execute:  <syntaxhighlight lang=bash>
+dig apelido.redes.edu.br </syntaxhighlight>
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual foi o resultado obtido?</span>
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o significado?</span>
+==Servidor WEB==
+# Preparando uma página HTML para colocar no servidor WEB.
+#* Páginas da internet são construídas usando o formato HTML.
+#* Ver aqui o que é uma página [https://wiki.sj.ifsc.edu.br/images/e/ee/03_-_HTML.pdf HTML] e como construir uma página simples.
+## No terminal da máquina '''WEB SERVER''' entre no diretório diretório''' /var/www/html''': <syntaxhighlight lang=bash>
+cd /var/www/html </syntaxhighlight>
+## Use o editor nano para editar uma página chamada '''index.html''': <syntaxhighlight lang=bash>
+nano index.html </syntaxhighlight>
+##* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Salve um print com o editor aberto.</span>
+## Crie a página com o seguinte conteúdo: <syntaxhighlight lang=c>
+<html>
+<body>
+<h1>Redes de Computadores</h1>
+<p>Pagina teste do aluno Pedro Alvares Cabral da Silva</p>
+</body>
+</html>
+</syntaxhighlight>
+##* Ao terminar de editar digite '''<Ctrl> + <X>''' e, em seguida, '''Y''' e '''<Enter>'''.
+## Inicie o SERVIÇO WEB para testar o protocolo HTTP. O servidor WEB irá disponibilizar a página criada para acesso remoto via protocolo HTTP: <syntaxhighlight lang=bash>
+/etc/init.d/lighttpd start </syntaxhighlight>
+# No '''router2''' deixe o Wireshark capturando pacotes.
+# Faça um acesso a sua página, a partir do Firefox (cliente HTTP) em um PC cliente de sua escolha: <syntaxhighlight lang=bash>Clique com o botão direito do mouse sobre, por exemplo, o pc1
+Clique sobre Web Browser
+Digite no navegador: www.redes.edu.br</syntaxhighlight>
+#* Se der erro, verifique se a máquina da qual você está navegando está resolvendo nomes, por exemplo, no terminal fazendo um ping www.redes.edu.br.
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">RECORTE a tela com a página em destaque no navegador e cole no relatório.</span>
+# Se desejar modificar a página repita os itens 2 e 3.
+# Crie uma nova página dentro do diretório /var/www/html:<syntaxhighlight lang=bash>
+nano abacaxi.html </syntaxhighlight>
+# Coloque um conteúdo a seu critério: <syntaxhighlight lang=c>
+<html>
+<body>
+<h1>Redes de Computadores</h1>
+<p>Minha primeira pagina..........</p>
+</body>
+</html>
+</syntaxhighlight>
+#* Ao terminar de editar digite '''<Ctrl> + <X>''' e, em seguida, '''Y''' e '''<Enter>'''.
+# Acesse a nova página através do navegador Firefox com o endereço (URL):  <syntaxhighlight lang=bash>http://www.redes.edu.br/abacaxi.html </syntaxhighlight>
+#* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">RECORTE a tela com a página em destaque no navegador e cole no relatório.</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Salve um print da tela do Wireshark destacando a troca de mensagens HTTP e o conteúdo HTML de uma das páginas acessadas.</span>
+# Extra (não obrigatório). Para quem quiser enfeitar sua página html com, por exemplo, imagem, siga o roteiro:
+## Baixe a imagem desejada na máquina real, por exemplo, imagem.jpg.
+## Abra um terminal da máquina real e, no diretório onde se encontra imagem.jpg, digite:<syntaxhighlight lang=bash>
+sudo hcp imagem.jpg web:/var/www/html</syntaxhighlight>
+## Confira no terminal do WEB SERVER (Imunes) se a imagem está lá:<syntaxhighlight lang=bash>
+cd /var/www/html
+ls -l</syntaxhighlight>
+## Use a imagem em sua página, seguindo o exemplo em [https://developer.mozilla.org/pt-BR/docs/Learn/HTML/Multimedia_and_embedding/Images_in_HTML Imagens no HTML].
 =Desvendando o UDP - Básico=
@@ Linha 723: / Linha 733: @@
 *Entender o conceito de portas
 *Entender o conceito de multiplexação
-==Fonte Base==
+===Fonte Base===
-*[http://docente.ifsc.edu.br/odilson/RCO60803/UDP%20Basico.pdf Introdução a camada de transporte e UDP básico]
+*[https://docente.ifsc.edu.br/odilson/RDC60807/UDP%20Basico.pdf Introdução a camada de transporte e UDP básico]
 ==Parte 1 - Fluxo único UDP==
@@ Linha 733: / Linha 743: @@
 # Abrir o '''Wireshark''', interfaces '''any''', para escuta das portas no protocolo UDP usando um filtro:<syntaxhighlight lang=bash>
 udp.port==5000</syntaxhighlight>
-# Com o Gedit escreva (copie) o programa UDPServer.py <syntaxhighlight lang=bash>
+# Com o editor de texto Gedit ou Pluma escreva (copie) o programa UDPServer.py <syntaxhighlight lang=bash>
 #Os comentarios estao propositalmente sem acentuacao, caso contrario, tem-se erro de sintaxe.
 #Esta linha define que pode-se utilizar sockets dentro do programa
@@ Linha 745: / Linha 755: @@
 #Vincula o numero da porta, nesse caso 22222, ao socket do servidor e "abre a porta".
 serverSocket.bind(('', serverPort))
-print "O servidor esta pronto para recepcao"
+print ('O servidor esta pronto para recepcao')
 #Aguarda indefinidamente por contatos (mensagens) de clientes
 while 1:
-        message, clientAddress = serverSocket.recvfrom(2048)
+    message, clientAddress = serverSocket.recvfrom(2048)
-        print message
+    print (message)
-        #Ao receber a mensagem do cliente converte todos os caracteres para maiusculas.
+    #Ao receber a mensagem do cliente converte todos os caracteres para maiusculas.
-	modifiedMessage = message.upper()
+    modifiedMessage = message.upper()
-	serverSocket.sendto(modifiedMessage, clientAddress) </syntaxhighlight>
+    serverSocket.sendto(modifiedMessage, clientAddress) </syntaxhighlight>
-# Salve o programa como UDPServer.py.
+# Salve o programa, na pasta '''/home/aluno''', como '''UDPServer.py'''
 # Abra um terminal (primeiro) e digite<syntaxhighlight lang=bash>
-python  UDPServer.py</syntaxhighlight> Esse será o nosso servidor
+python3 UDPServer.py</syntaxhighlight> No terminal aparacerá a mensagem: 'O servidor esta pronto para recepcao'. Esse será o nosso servidor...
-# No segundo terminal, que irá transmitir para a porta 5000 aberta no primeiro terminal, execute: <syntaxhighlight lang=bash>
+# No segundo terminal, que irá transmitir para a porta 5000 aberta no primeiro terminal, execute:  <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;"> (Ajuste o IP_DEST para o número IP de sua própria máquina)</span> <syntaxhighlight lang=bash>
-netcat -u IP_DEST 5000 </syntaxhighlight> <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">onde IP_DEST é o número IP de sua própria máquina</span>.
+netcat -u IP_DEST 5000 </syntaxhighlight>
-#* Em seguida escreve no terminal uma mensagem de até 20 caracteres, ao teclar <enter> a mensagem será enviada.</enter>
+#* Em seguida escreve no terminal uma mensagem de até 20 caracteres, ao teclar <enter> a mensagem será enviada.
 #* O wireshark deve ter capturado os pacotes UDP.
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Identifique e anote os seguintes dados na captura do wireshark:.</span>
@@ Linha 792: / Linha 802: @@
 **Troca de Dados
 **Finalização da Conexão
-==Fonte Base==
+===Fonte Base===
-*[http://docente.ifsc.edu.br/odilson/RCO60803/TCP%20Basico.pdf Camada de transporte: TCP básico]
+*[https://docente.ifsc.edu.br/odilson/RDC60807/TCP%20Basico.pdf Camada de transporte: TCP básico]
 ==Verificando o estabelecimento, troca de dados e finalização da conexão==
-# O roteiro será executado sobre 2 máquinas virtuais, através do uso do Imunes. Abra o Imunes e crie uma rede extremamente simples com somente dois PCs, conforme a figura. [[Arquivo:2PCs.png |thumb | 300px]]
+O roteiro será executado sobre 2 máquinas virtuais, através do uso do Imunes. Abra o Imunes e crie uma rede extremamente simples com somente dois PCs, conforme a figura. [[Arquivo:2PCs.png |thumb | 300px| Fig.1 -- Rede exemplo]]
 # Execute o Imunes e monte a rede conforme a figura.
 # Inicie a simulação: <syntaxhighlight lang=bash> Experiment >> Execute </syntaxhighlight>
@@ Linha 825: / Linha 835: @@
 #* <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">O servidor responde com um FIN-ACK.</span>
 #* <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Finalmente o cliente faz um ACK.  </span>
-#* <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Veja se confere com a figura </span>[http://www.tcpipguide.com/free/t_TCPConnectionTermination-2.htm Término de conexão TCP]<span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;"> ou com os </span>[http://docente.ifsc.edu.br/odilson/RCO60803/TCP%20Basico.pdf slides]<span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;"> apresentados no início da aula.</span>
+#* <span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;">Veja se confere com a figura </span>[http://www.tcpipguide.com/free/t_TCPConnectionTermination-2.htm Término de conexão TCP]<span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;"> ou com os </span>[http://docente.ifsc.edu.br/odilson/RDC60807/TCP%20Basico.pdf slides]<span style="color: rgb(0, 0, 0);" data-mce-style="color: #000000;"> apresentados no início da aula.</span>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Gere com o Wireshark um diagrama da comunicação, ou diagrama de troca de mensagens. Insira-o no relatório: </span><syntaxhighlight lang=bash>  Statistics >> Flow Graph >> OK </syntaxhighlight>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Gere com o Wireshark um diagrama da comunicação, ou diagrama de troca de mensagens, somente da conexão TCP estabelecida (não deve conter outras mensagens). Insira-o no relatório: </span><syntaxhighlight lang=bash>  Statistics >> Flow Graph >> OK </syntaxhighlight>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Analise esse diagrama, observando qual pacote  contém os dados, ou seja, o texto que você digitou.</span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Analise também o estabelecimento e fechamento de conexão, confere com o apresentado na teoria?</span>
@@ Linha 839: / Linha 849: @@
 **Comportamento Full-Duplex.
-==Configuração do Laboratório==
+==Topologia de rede para experimetação==
 #O roteiro será executado sobre máquinas virtuais, através do uso do [http://imunes.net/ Imunes].
 #Abra um terminal e baixe o aquivo de configuração da rede a ser utilizada e um arquivo auxiliar dos experimentos: <syntaxhighlight lang=bash>
 cd ~
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/TCP_Num_Seq_Erro.imn
+wget -4 http://redes.sj.ifsc.edu.br/TCP_Num_Seq_Erro.imn
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/arq30Bytes.txt</syntaxhighlight>
+wget -4 http://redes.sj.ifsc.edu.br/arq30Bytes.txt</syntaxhighlight>
-# Execute o Imunes, num terminal execute: <syntaxhighlight lang=bash>
+# Execute o Imunes.
- sudo imunes</syntaxhighlight>
 # Carregue o arquivo: <syntaxhighlight lang=bash>
   File >> Open >> TCP_Num_Seq_Erro.imn</syntaxhighlight>
@@ Linha 870: / Linha 879: @@
 # Pare a captura de pacotes no Wireshark.
 # Na tela do Wireshark você terá algo parecido com o apresentado na Figura 1. [[Arquivo:WiresharkTCPPerdaDePacotes.png |thumb | 600px| Fig.1 -- Protocolo TCP]]
-#* O comportamento padrão do Wireshark é redefinir o número de sequência para sempre iniciar em 0. Este comportamento pode ser alterado conforme nossas necessidades: <syntaxhighlight lang=bash>
-Edit >> Preferences >> Protocols >> TCP >> (Habilite/Desabilite) Relative sequence numbers >> OK </syntaxhighlight>
-# Analise como os dados foram transmitidos e reconhecidos.
 # <span style="color: #9966CC;" data-mce-style="color: #9966cc;"><span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Perguntas</span>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o número de sequência (normalizado pelo Wireshark) de cada segmento de dados transmitido (de PC1 para PC2) e qual o significado do número de reconhecimento em cada um deles?</span>
+##* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Relate esta análise por segmento usando os ''timestamps'' (coluna ''Time'') como referência.</span>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Como foi reconhecido cada segmento enviado?</span>
-##* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Relate esta análise por segmento usando os ''timestamps'' (coluna ''Time'') como referência.</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Explique as mensagens do tipo '''TCP ZeroWindow'''. Deixe claro sua funcionalidade e necessidade.</span>
-## Pare o experimento no Imunes: <syntaxhighlight lang=bash>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Explique as mensagens do tipo '''TCP window Update'''. Deixe claro sua funcionalidade e necessidade.</span>
+#Pare o experimento no Imunes: <syntaxhighlight lang=bash>
 Experiment >> Terminate </syntaxhighlight></span>
@@ Linha 889: / Linha 897: @@
 # Execute o Wireshark no '''Receptor''':<syntaxhighlight lang=bash>
 Clique direito do mouse sobre o ícone do Receptor >> Wireshark >> eth0.. </syntaxhighlight>
-# Execute o processo servidor no '''Receptor''' e prepare o mesmo para limitar a sua capacidade de recepção em cerca de 20 bytes (tamanho do ''buffer'') e perda de dados em torno de 40%. Isto permitirá ver a quebra do arquivo de 30 bytes em alguns segmentos TCP: <syntaxhighlight lang=bash>
+# Adicione o filtro '''tcp''' ao Wireshark, para limpar os dados apresentados.
-sysctl -w net.ipv4.tcp_rmem='20 20 20'
+# Vamos provocar perda de bits no enlace editando o BER do mesmo. BER é ''bit error rate'', ou seja, foi inserido uma taxa de erro de bist no canal como sendo 1/15000. Isso significa que, em média, a cada 15 mil bits que passar pelo canal, 1 bit será perdido/adulterado.<syntaxhighlight lang=bash>
-tc qdisc replace dev eth0 root netem loss 40%
+Duplo clique sobre o enlace (fio vermelho) >> acrescente o valor 15000 no campo BER >> Clique em ''Apply'' </syntaxhighlight>
+# Execute o processo servidor no '''Receptor''' e prepare o mesmo para limitar a sua capacidade de recepção em cerca de 20 bytes (tamanho do ''buffer''). Isto permitirá ver a quebra do arquivo de 30 bytes em alguns segmentos TCP: <syntaxhighlight lang=bash>
+sysctl -w net.ipv4.tcp_rmem='20 20 20'
 nc -vvnl -p 5555 > ArqRecebido.txt </syntaxhighlight>
 #* <span style="color: blue;">Dica: para copiar textos para o Imunes, copie normalmente o texto, por exemplo, da Wiki, com o < Ctrl > + < C > e cole com < Ctrl > + < Shift > + < V > ou clicando sobre a rodinha (''scroll'') do mouse.</span>
@@ Linha 897: / Linha 907: @@
   nc -vvn 10.0.0.21 5555 < arq30Bytes.txt </syntaxhighlight>
 #* Obs: Caso receba uma mensagem "No route to host", repita o comando acima. O problema é gerado por perdas sucessivas de mensagens de estabelecimento de conexão do TCP, devido à perda de dados estabelecida em 40%.
-# Pare os processos rodando nos terminais do '''Transmissor''' e '''Receptor''' com:<syntaxhighlight lang=bash>
+# Monitore o Wireshark e assim que os 30 Bytes foram transmistidos, pare os processos rodando nos terminais do '''Transmissor''' e '''Receptor''' com:<syntaxhighlight lang=bash>
 Ctrl + c </syntaxhighlight>
 # Pare a captura de pacotes no Wireshark.
-# Adicione o filtro '''tcp''' ao Wireshark, para limpar os dados apresentados.
 # Analise como os dados foram transmitidos e reconhecidos.
 # <span style="color: #9966CC;" data-mce-style="color: #9966cc;"><span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Perguntas:</span>
@@ Linha 915: / Linha 924: @@
 # Inicie a simulação da rede no Imunes:<syntaxhighlight lang=bash>
 Experiment >> Execute </syntaxhighlight>
+# Vamos retirar a perda de bits no enlace editando o BER do mesmo.<syntaxhighlight lang=bash>
+Duplo clique sobre o enlace (fio vermelho) >> acrescente o valor 0 no campo BER >> Clique em ''Apply'' </syntaxhighlight>
 # Num terminal da máquina do hospedeira/Linux ('''Não do Imunes''') baixe os arquivos para o experimento e salve-os a pasta pessoal de seu usuário: <syntaxhighlight lang=bash>
 cd ~
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/Servidor.tx -O Servidor.tx
+wget -4 http://redes.sj.ifsc.edu.br/Servidor.tx -O Servidor.tx
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/Cliente.tx -O Cliente.tx </syntaxhighlight>
+wget -4 http://redes.sj.ifsc.edu.br/Cliente.tx -O Cliente.tx </syntaxhighlight>
 # Copie os arquivos para as máquinas do Imunes. No terminal da máquina hospedeira/Linux ('''NÃO do Imunes''') digite:<syntaxhighlight lang=bash>
 sudo hcp Servidor.tx Transmissor:
@@ Linha 948: / Linha 959: @@
 *Utilizar o software [https://iperf.fr/ Iperf] (iperf –h para help) para gerar tráfego entre duas máquinas, '''cliente''' e '''servidor'''.
 *Utilização do software [http://imunes.net/ Imunes] para simulação de redes "complexas".
-== Cenário para todos os experimentos==
+==Topologia de rede para experimetação==
 [[Arquivo:TCP_Controle_de_Cong_e_Equidade.png |thumb | 500px| Dois clientes "disputando" o enlace com o servidor]]
 *O roteiro será executado sobre máquinas virtuais, através do uso do [http://imunes.net/ Imunes].
@@ Linha 958: / Linha 969: @@
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/TCP_Controle_de_congestionamento_e_equidade.imn
+wget -4 http://redes.sj.ifsc.edu.br/TCP_Controle_de_congestionamento_e_equidade.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/TCP_Controle_de_congestionamento_e_equidade.imn</syntaxhighlight>
-#* Perceba que será apresentada uma rede com um roteador, dois clientes e um servidor de rede. Todos interligados por enlaces de 10 kbps.
+#* Perceba que será apresentada uma rede com um roteador, dois clientes e um servidor de rede. Todos interligados por enlaces de 1 Mbps.
 # Inicie a simulação no Imunes: <syntaxhighlight lang=bash>
 Experiment >> Execute </syntaxhighlight>
@@ Linha 976: / Linha 986: @@
 # No '''Cliente1''' execute (copie a três linhas e cole no terminal adequado e em seguida tecle <enter>): <syntaxhighlight lang=bash>
 iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2000 & \
-(sleep 5; iperf -c 10.0.2.10 -f m -i 1 -t 40 -p 2001) & \
+(sleep 5 && iperf -c 10.0.2.10 -f m -i 1 -t 40 -p 2001) & \
-(sleep 10; iperf -c 10.0.2.10 -f m -i 1 -t 20 -p 2002) & </syntaxhighlight></enter>
+(sleep 10 && iperf -c 10.0.2.10 -f m -i 1 -t 20 -p 2002) & </syntaxhighlight>
 # Fique monitorando o '''Cliente1''' até a tela parar de ser atualizada, aproximadamente 50 s.
 # Pare os processos no '''Cliente1''' e '''Servidor''' utilizando CTRL-C.
-# Pare a captura de dados no Wireshark.
+# Pare a captura de dados no Wireshark e coloque um filtro TCP.
 # No wireshark acesse '''Statistics''' >> '''IO Graph''' e, na tela que abrir, ajuste TODOS os parâmetros para obter um gráfico similar ao apresentado na Figura 2:  [[Arquivo:TCP_Controle_de_Cong_e_Equidade_Graficos.png |thumb | 400px| Captura de 3 fluxos de dados]]
+##Deve-se adicionar um gráfico por porta, no caso, porta 2000, 2001 e 2002.
 ## Clique em '''Add a new graph''' (sinal de + no canto inferior esquerdo)
 ##* X Enabled
@@ Linha 995: / Linha 1 006: @@
 ###* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Há uma relação de valor entre as curvas?</span>
 ###* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é esta relação?</span>
-### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Por que a curva vermelha se sobrepõe a curva preta nos primeiros 5 segundos, a partir do início da transmissão?</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Por que as duas curvas apresentadas se sobrepõe nos primeiros 5 segundos, a partir do início da transmissão?</span>
-### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é a relação entre a curva preta e as curvas vermelha e verde no intervalo entre 6 e 10 segundos, a partir do início da transmissão?</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é a relação entre entreas três curvas nos próximos 5 segundos, a partir do início da transmissão?</span>
 ### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é o mecanismo do TCP que explica a grande oscilação das curvas, principalmente percebida no intervalo entre 10 e 30 segundos, a partir do início da transmissão?</span></span>
+#Para o experimentono Imunes: <syntaxhighlight lang=bash>
+Experiment >> Terminate </syntaxhighlight>
 ==Parte 2: Fluxos TCP mais UDP==
 Agora vamos dificultar a vida do TCP incluindo um tráfego UDP. O gráfico gerado deverá apresentar a competição pelo meio de transmissão entre os diversos fluxos de dados.
-# Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/TCP_Controle_de_congestionamento_e_equidade.imn
-</syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
-sudo imunes</syntaxhighlight>
-# Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
-File >> Open >> /home/aluno/TCP_Controle_de_congestionamento_e_equidade.imn</syntaxhighlight>
 # Inicie a simulação no Imunes: <syntaxhighlight lang=bash>
 Experiment >> Execute </syntaxhighlight>
@@ Linha 1 019: / Linha 1 025: @@
 # A próxima etapa deve ser executada "simultaneamente" nos '''Cliente1''' e '''Cliente2'''.
 ## Para isso copie o texto abaixo e cole no terminal do '''Cliente1''', ainda NÃO tecle <enter>: <syntaxhighlight lang=bash>
-sleep 5;iperf -u -c 10.0.2.10 -f m -i 1 -t 25 -p 2000 -b 10000000 </syntaxhighlight></enter>
+sleep 5 && iperf -u -c 10.0.2.10 -f m -i 1 -t 25 -p 2000 -b 10000000 </syntaxhighlight>
 ## Copie o texto abaixo e cole no terminal do '''Cliente2''', ainda NÃO tecle <enter>: <syntaxhighlight lang=bash>
-iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2001 &  iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2002</syntaxhighlight></enter>
+iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2001 &  iperf -c 10.0.2.10 -f m -i 1 -t 50 -p 2002</syntaxhighlight>
-## Tecle <enter> no '''Cliente2''' e '''Cliente1''', NESSA ORDEM, "simultaneamente".</enter>
+## Tecle <enter> no '''Cliente2''' e '''Cliente1''', NESSA ORDEM, "simultaneamente".
 # Fique monitorando o '''Cliente2''' a tela parar de ser atualizada, aproximadamente 50 s.
 # Pare os processos no '''Cliente1''', '''Cliente2''' e '''Servidor''' utilizando CTRL-C.
@@ Linha 1 051: / Linha 1 057: @@
 #Verificação de movimentação de pacotes (rotas) em roteadores
-Usaremos como base a seguinte arquitetura de rede:
+===Referências===
-[[Arquivo:2_sub-redes_com_1_roteador.png| 500 px]]
-==Referências==
 Base:
-*[http://tele.sj.ifsc.edu.br/~eraldo/AULAS/2018-2/RCO-INTEGRADO/MACxIP.pdf Endereçamento MAC x Endereçamento IP]
+*[http://https://docente.ifsc.edu.br/odilson/RDC60807/Enderecamentos.pdf Endereçamento MAC x Endereçamento IP]
 Extra:
 * [http://linux-ip.net/html Guia de Administração da Camada IP no Linux]
+==Topologia de rede para experimetação==
+[[Arquivo:2_sub-redes_com_1_roteador.png| 500 px]]
 ==Procedimento==
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/Roteador_com_duas_redes.imn
+wget -4 http://redes.sj.ifsc.edu.br/Roteador_com_duas_redes.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/Roteador_com_duas_redes.imn</syntaxhighlight>
 # Inicie a simulação no Imunes: <syntaxhighlight lang=bash>
 Experiment >> Execute </syntaxhighlight>
-#* Ignore (''dismiss'') a mensagem de erro apresentada. O erro é proposital.
+#* '''Ignore (''dismiss'')''' a mensagem de erro apresentada. O erro é proposital.
 #* Observe que a rede é composta de 4 PCs ('''pc1''' - '''pc4'''), 1 roteador ('''router1''') e 2 switchs. O roteador possui duas interfaces de rede, com seus respectivos IPs - camada 3, que interliga as duas sub-redes. Cada ''switch'' tem 3 interfaces, mas sem IPs, camada 2.
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Anotar os endereços de hardware (ou MAC) e IP de cada dispositivo na rede. No terminal de cada PC execute: <syntaxhighlight lang=bash>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Anotar os endereços de hardware (ou MAC) e IP de cada dispositivo na rede. No terminal de cada PC e Roteador execute: <syntaxhighlight lang=bash>
-ifconfig </syntaxhighlight></span> ou
+ifconfig </syntaxhighlight></span> ou <syntaxhighlight lang=bash>
-<syntaxhighlight lang=bash>
 ip a </syntaxhighlight></span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observar, interpretar e anotar a tabela de roteamento em todos os hospedeiros '''pc1''' - '''pc4''' e no roteador '''router1'''. Identificar os ''default gateways'' em cada PC.<syntaxhighlight lang=bash>
-route -n </syntaxhighlight></span>
+route  </syntaxhighlight></span>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Observar, "provar" e anotar que pacotes indo do '''pc1''' para '''pc2''' são enviados diretamente para '''pc2''', ou seja, entrega direta. Explique a entrega direta.
 ## Deixe o ping entre '''pc1''' e '''pc2''', em '''pc1''' execute:<syntaxhighlight lang=bash>
@@ Linha 1 113: / Linha 1 117: @@
 * Analisar ''loops'' em rede.
-==Arquitetura de rede==
+==Topologia de rede para experimetação==
 Em todos os experimentos será utilizado como base a seguinte arquitetura de rede:
-[[Arquivo:3_roteadores_tab_estaticas.png]]
+[[Arquivo:3_roteadores_tab_estaticas.png| 500 px]]
 ==Tabelas estáticas de roteamento==
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/3_roteadores_tab_estaticas.imn
+wget -4 http://redes.sj.ifsc.edu.br/3_roteadores_tab_estaticas.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/3_roteadores_tab_estaticas.imn</syntaxhighlight>
@@ Linha 1 152: / Linha 1 155: @@
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/3_roteadores_tab_estaticas_com_loop.imn
+wget -4 http://redes.sj.ifsc.edu.br/3_roteadores_tab_estaticas_com_loop.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/3_roteadores_tab_estaticas_com_loop.imn</syntaxhighlight>
 # Inicie a simulação no Imunes: <syntaxhighlight lang=bash>
 Experiment >> Execute </syntaxhighlight>
-# Execute o Wireshark na interface eth1 de todos os roteadores e na interface eth0 do '''pc0'''.
+# Execute o Wireshark na interface '''eth1''' dos roteadores '''R0''' e '''R2''' e na interface '''eth2''' do roteador '''R1'''.
 # Gere um tráfego único a partir do '''pc0''' para o '''pc2''': <syntaxhighlight lang=bash>
 ping -c1 10.0.2.20 </syntaxhighlight>
@@ Linha 1 177: / Linha 1 179: @@
 *Compreender o papel do protocolo ARP
-==Fonte Base==
+===Fonte Base===
-*[http://docente.ifsc.edu.br/odilson/RCO60803/Camada%20de%20enlace.pdf Camada de Enlace]
+*[http://docente.ifsc.edu.br/odilson/RDC60807/Camada%20de%20enlace.pdf Camada de Enlace]
-==Animação Pearson/Kurose==
+===Animação Pearson/Kurose===
 *[https://media.pearsoncmg.com/aw/ecs_kurose_compnetwork_7/cw/content/interactiveanimations/csma-cd/index.html Animação CSMA/CD]
@@ Linha 1 189: / Linha 1 191: @@
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/Redes/switch.imn
+wget -4 http://redes.sj.ifsc.edu.br/switch.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/switch.imn</syntaxhighlight>
@@ Linha 1 199: / Linha 1 200: @@
 # Identificar o endereço de Hardware (MAC) do PC2. Use o ifconfig ou ip. Note que NÃO existe endereço IPv4 configurado.
 # Baixe o arquivo '''MacEnvioMsg.py''', no terminal da máquina real digite: <syntaxhighlight lang=bash>
-wget -4 https://docente.ifsc.edu.br/odilson/Redes/MacEnvioMsg.py
+wget -4 http://redes.sj.ifsc.edu.br/MacEnvioMsg.py
 </syntaxhighlight>
-# Copiar o arquivo para a Máquina Virtual PC1. No terminal da máquina real digite:<syntaxhighlight lang=bash>
+# Copiar o arquivo para a Máquina Virtual PC1. <span style="color: rgb(255, 0, 0);" data-mce-style="color: #ff0000;">No terminal da máquina real digite</span>:<syntaxhighlight lang=bash>
 sudo hcp /home/aluno/MacEnvioMsg.py pc1: </syntaxhighlight>
 # Executar o Wireshark no PC2, PC3 e PC4.
-# No PC1 enviar uma mensagem para o PC2 usando o endereço de hardware (MAC) identificado anteriormente, <span style="color: red;">Lembre-se se substituir o ENDERECO_MAC pelo MAC adequado:<syntaxhighlight lang=bash>
+# No PC1 enviar uma mensagem para o PC2 usando o endereço de hardware (MAC) identificado anteriormente, <span style="color: red;">Lembre-se se substituir o ENDERECO_MAC pelo MAC do PC2:<syntaxhighlight lang=bash>
-python MacEnvioMsg.py -d ENDERECO_MAC -i Alo-Mundo </syntaxhighlight> </span>
+python3 MacEnvioMsg.py -d ENDERECO_MAC -i Alo-Mundo </syntaxhighlight> </span>
 #* Observe nos Wiresharks quem recebeu a mensagem.
 #* Somente o PC2 deve receber pois o ''switch'' entrega o quadro somente para a porta de saída associada ao respectivo MAC destino.
@@ Linha 1 214: / Linha 1 215: @@
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quais foram os MACs de origem e destino? A que PCs pertencem os mesmos?</span>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Há camada de rede, IP, na mensagem?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Em qual camada que se encontra a mensagem?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">A mensagem é legível?</span>
 # No PC1 enviar uma mensagem em ''broadcast'' (endereço FF:FF:FF:FF:FF:FF)<syntaxhighlight lang=bash>
-python MacEnvioMsg.py -d FF:FF:FF:FF:FF:FF -i GritoNaRede  </syntaxhighlight>
+python3 MacEnvioMsg.py -d FF:FF:FF:FF:FF:FF -i GritoNaRede  </syntaxhighlight>
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Perguntas:</span>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quais PCs receberam a mensagem?.</span>
 ## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Quais foram os MACs de origem e destino? A que PCs pertencem os mesmos?</span>
+#Pare (feche) todos o capturadores de pacotes (Wireshark).
 ==PARTE 2 - Explorando o ARP==
 O protocolo ARP serve como apoio para descoberta do endereço MAC dado que se sabe o endereço IP de uma máquina. Quando um PC deseja enviar um pacote IP para uma máquina na rede local, ele necessita descobrir o endereço MAC desta máquina. O protocolo ARP usa o ''broadcast'' ETHERNET para perguntar para todas as máquinas na rede QUEM tem o endereço IP em questão. A máquina que possui o endereço responderá informando o seu MAC.
-# Configure endereços IP em todas as máquinas do laboratório anterior. Use endereços da rede 10.10.10.0/24
+# Configure o IP de todos os PCs. Todos devem pertencer a rede 10.0.0.0/24. Por exemplo, no pc1: <syntaxhighlight lang=bash>
-#* Use seus conhecimentos adquiridos no Laboratório: '''Interligação de duas redes através de um roteador'''.
+ifconfig eth0 10.0.0.1/24
+</syntaxhighlight>
 # Rode o Wireshark no PC2.
-# Faça um ping do PC1 no PC2 e observe a sequência de pacotes trocados. Faça um diagrama no tempo mostrando a troca de pacotes até a realização do ECHO REQUEST do ping. Os resultados do Wireshark devem ser similares a: [[Arquivo:RCO-TelaARP.jpg | 700px| Troca de pacotes ARP e PING]]
+# Faça um ping do PC1 no PC2 e observe a sequência de pacotes trocados. Faça um diagrama no tempo mostrando a troca de pacotes até a realização do ECHO REQUEST do ping. Os resultados do Wireshark devem ser similares a: [[Arquivo:RCO-TelaARP.jpg | 1000px| Troca de pacotes ARP e PING]]
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira e anote o cache do arp no PC1 fazendo:</span><syntaxhighlight lang=bash>
    arp -a</syntaxhighlight>
@@ Linha 1 237: / Linha 1 242: @@
    arp -a</syntaxhighlight>
 ##* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">A tabela foi atualizada após o ping?</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira e anote o cache do arp da sua máquina real fazendo:</span><syntaxhighlight lang=bash>
+  ip neigh show </syntaxhighlight>
 =''Neighbor Discovery'' e roteamento estático no IPv6=
@@ Linha 1 243: / Linha 1 250: @@
 Slides de [http://docente.ifsc.edu.br/odilson/RED29004/IPv6.pdf endereçamento IPv6].
-==Objetivos do laboratório:==
+==Objetivos do laboratório==
 *Um primeiro contato com o protocolo [https://pt.wikipedia.org/wiki/IPv6 IPv6]
 *Compreender o funcionando do ''Neighbor Discovery'', o equivalente ao ARP (''Address Resolution Protocol'') do IPv4, que em resumo é uma tabela contendo a relação ente IPs e MACs.
@@ Linha 1 249: / Linha 1 256: @@
 *Aprender configurações básicas de rotas IPv6
-==Introdução teórica==
+===Introdução teórica===
 Obs.: texto copiado literalmente de: [http://ipv6.br/pagina/livro-ipv6/ Laboratório de IPv6].
@@ Linha 1 260: / Linha 1 267: @@
 *A informação de mapeamento entre endereços IP e endereços físicos é armazenada em uma tabela chamada ''neighbor cache''. Nela também fica registrado o ''status'' de cada destino, informando se o mesmo é alcançável ou não.
-==Roteiro de atividades:==
+==Topologia de rede para experimetação==
 A figura abaixo apresenta o diagrama esquemático da rede a ser montada/analisada. Observe que todos os IPv6 ''Global Unicast'' já estão definidos na mesma, são esses IPs que utilizaremos em nosso experimento.
-[[Arquivo:IPv6.png]]
+[[Arquivo:IPv6.png| 500 px]]
+==Roteiro de atividades==
 # Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
-wget -4 http://docente.ifsc.edu.br/odilson/RED29004/IPv6.imn
+wget -4 http://redes.sj.ifsc.edu.br/IPv6.imn
 </syntaxhighlight>
-# Execute o Imunes.<syntaxhighlight lang=bash>
+# Execute o Imunes.
-sudo imunes</syntaxhighlight>
 # Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
 File >> Open >> /home/aluno/IPv6.imn</syntaxhighlight>
@@ Linha 1 296: / Linha 1 303: @@
 ip -6 route add default via fc00:2::1 dev eth0 </syntaxhighlight>
 #* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Confira novamente a tabela de roteamento do '''pc3'''.</span>
-# Faça novamente um '''ping6''' entre o '''pc3''' ao '''pc1'''.
+# Faça novamente um '''ping6''' entre o '''pc3''' ao '''pc0'''.
 #* <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Obteve sucesso? Sim ou não e por quê?</span>
 # Pode-se conferir se as rotas, nos roteadores ou qualquer host, com o comando: <syntaxhighlight lang=bash>
 ip -6 route show </syntaxhighlight>
-# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">A partir do computador '''pc0''' use o comando '''traceroute6''' e anote a rota para todos os demais PCs.</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">A partir do computador '''pc0''' use o comando '''traceroute6 IPv6_DE_DESTINO''' e anote a rota para todos os demais PCs. Ex:</span><syntaxhighlight lang=bash>
+traceroute6 fc00:1::20 </syntaxhighlight>
 # Pare a captura no Wireshark.
 # <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Baseado na captura de pacotes do Wireshark explique o processo de descoberta de vizinhança (''Neighbor Solicitation'' - '''NS''' e ''Neighbor Advertisement'' - '''NA'''), citando os endereços de '''multicast''' e '''link local''' utilizados. Obs.: ao final do roteiro há alguns exemplos de mensagens.</span>
@@ Linha 1 330: / Linha 1 338: @@
 # '''Target Address''' (camada ICMPv6)
 #* Indica o endereço IP associado às informações das flags. Neste caso, é o próprio endereço da interface do dispositivo em questão.
+=Path MTU Discovery: mensagem ICMPv6 do tipo ''packet too big''=
+Este roteiro foi baseado no material disponível no Livro - [http://ipv6.br/pagina/livro-ipv6/ Laboratório de IPv6].
+==Objetivos do laboratório==
+*O objetivo desta experiência é mostrar o funcionamento do mecanismo de descoberta de MTU no IPv6.
+==Introdução teórica==
+Obs.: texto copiado literalmente de: [http://ipv6.br/pagina/livro-ipv6/ Laboratório de IPv6].
+O MTU é o tamanho máximo de pacote suportado em um determinado enlace de rede. Caso seja necessário enviar um pacote maior do que o MTU do enlace é necessário fragmentá-lo.
+No IPv6, a fragmentação dos pacotes é realizada apenas na origem. Este procedimento não é realizado (e nem permitido) em roteadores intermediários, como ocorre no protocolo antigo, o IPv4. Isto tem o intuito de reduzir o custo de processamento nos roteadores, seguindo o princípio de manter a inteligência da Internet nas extremidades da rede.
+Numa rede IPv6, quem está enviando os pacotes tem então que conhecer o MTU do caminho até o destino. Se o caminho for composto por vários seguimentos com MTUs diferentes, valerá, na prática, o menor deles. Essa informação é obtida por meio do Path MTU Discovery (PMTUD), definido na RFC 1981 (McCann et al., 1996).
+O processo de PMTUD assume que o MTU de todo o caminho é igual ao do primeiro salto. Caso o tamanho dos pacotes enviados seja maior do que o suportado por algum enlace ao longo do caminho, o roteador irá descartá-lo e enviará uma mensagem ICMPv6 packet too big, contendo tanto a mensagem de erro quanto o valor do MTU do enlace seguinte.
+Após o recebimento dessa mensagem, o nó de origem passa a limitar o tamanho dos pacotes de acordo com o MTU indicado. Isso é repetido até que o tamanho do pacote seja igual ou inferior ao menor MTU do caminho.
+Os dispositivos armazenam o MTU para cada destino em uma tabela chamada destination cache, não sendo necessário repetir a descoberta a cada pacote enviado.
+Caso o pacote seja enviado a um grupo multicast, o tamanho utilizado será o menor MTU de todo o conjunto de destinos. Implementações minimalistas de IPv6 podem não realizar a descoberta de MTU e utilizar 1280 bytes como tamanho máximo para os pacotes.
+==Roteiro de atividades==
+# Baixe o arquivo de configuração da rede, no terminal digite: <syntaxhighlight lang=bash>
+wget -4 http://redes.sj.ifsc.edu.br/PathMTU.imn
+</syntaxhighlight>
+# Execute o Imunes.
+# Carregue o arquivo de configuração: <syntaxhighlight lang=bash>
+File >> Open >> /home/aluno/PathMTU.imn</syntaxhighlight>
+# Inicie a simulação no Imunes: <syntaxhighlight lang=bash>
+Experiment >> Execute </syntaxhighlight>
+#* Observe que a rede é composta de 2 PCs e 1 roteador.
+# Altere o valor de MTU no dispositivo '''router1''':<syntaxhighlight lang=bash>
+ip link set eth1 mtu 1400 </syntaxhighlight>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Verifique o valor de MTU no dispositivo '''router1''':</span><syntaxhighlight lang=bash>
+ip addr show </syntaxhighlight>
+#* Na interface eth1 deverá constar mtu 1400
+# Altere o valor de MTU no dispositivo '''pc2''':<syntaxhighlight lang=bash>
+ip link set eth0 mtu 1400 </syntaxhighlight>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Verifique o valor de MTU no dispositivo '''pc2''':</span><syntaxhighlight lang=bash>
+ip addr show </syntaxhighlight>
+#* Na interface eth0 deverá constar mtu 1400
+# Execute o wireshark no '''pc1''':<syntaxhighlight lang=bash>
+clique com o botão direito do mouse sobre seu ícone >>  Wireshark >> eth0... </syntaxhighlight>
+# Abra um terminal no '''pc1''' e verifique a conectividade IPv6 com o '''pc2''':<syntaxhighlight lang=bash>
+ping6 -s 1500 -M want -c 4 fc00:1::20 </syntaxhighlight>
+#* Veja que o comando ping6, com os parâmetros apresentados, configura os pacotes enviados para conterem 1500 bytes de tamanho, por meio da opção -s 1500, e a interface para permitir a fragmentação de pacotes, utilizando a opção -M want.
+# Pare a captura de pacotes e aplique, no Wireshark, o filtro icmpv6.
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Procure pelo pacote '''Packet Too Big'''.</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Veja se os dados contidos nos pacotes conferem com a teoria.</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual é o tipo (type) e código (code) do pacote? Está de acordo com a teoria? (</span>[https://www.iana.org/assignments/icmpv6-parameters/icmpv6-parameters.xhtml]<span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">)</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Procure o campo '''MTU: 1400''', qual o significado desta informação?</span>
+# <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Procure pelos pacotes '''Echo (ping) request'''.</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Analise os mesmos na camada 3 (IPv6):</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">quantos fragmentos os mesmos possuem?</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o tamanho de cada fragmento?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Onde (máquina) foi realizada a fragmentação?</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Como você chegou a esta conclusão?</span>
+## <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Procure pelos pacotes '''Echo (ping) reply'''.</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Eles também estão fragmentados? Prove.</span>
+### <span style="color: rgb(0, 128, 0);" data-mce-style="color: #008000;">Qual o sentido dessa fragmentação?</span>
+#Repita todo o experimento, alterando o MTU do enlace a direita para 500.
+##Analise a nova fragmentação no wireshark e dê print do resultado.
+##Analise a nova fragmentação, é compatível com o MTU de 500?
+##Quantos fragmentos são gerados em cada ping?
+O resultado mostra que, para a topologia apresentada, o menor valor de MTU ao longo do caminho foi descoberto corretamente a partir do primeiro pacote. Este foi descartado ao chegar em uma rede cujo o limite do MTU era de 1400 bytes. Na sequência, os pacotes foram enviados fragmentados de acordo com o valor de MTU descoberto e passaram a transitar corretamente pela rede.

Mudanças entre as edições de "RDC60807"

Edição atual tal como às 15h49min de 23 de abril de 2024

Conceitos Básicos de Redes e Ferramentas Básicas de Trabalho

Objetivos

Material e Pré-condições

Roteiro de atividades

Parte 1: Observando interfaces do sistema com ifconfig ou ip

Parte 2: Testando a conectividade com o ping

Parte 3: Verificando rotas com o traceroute

Parte 4: Usando as ferramentas ping, ifconfig, ip e traceroute em um cenário com o imunes

Wireshark e encapsulamento

Objetivos

Sobre o analisador Wireshark

Identificando os campos da interface do Wireshark

Verificando pacotes do ping (ICMP REQUEST/REPLY)

Treinamento

Tarefa

Desvendando o HTTP com Wireshark - Básico

Objetivos

A Interação Básica GET/Resposta do HTTP

Interação Básica GET/Resposta do HTTP usando TELNET e REQUISIÇÃO MANUAL

Desvendando o HTTP com Wireshark - AVANÇADO

Objetivos

Fonte base

PARTE 1 - A Interação HTTP GET Condicional/Resposta

PARTE 2 - Documentos HTML com Objetos Incluídos

PARTE 3 - Segurança com HTTPS

Serviço de Nomes (DNS)

Objetivos

Fonte Base

PARTE 1: Consulta simples ao DNS gerada a partir de um comando ping

PARTE 2 - Consultas DNS por meio de ferramentas especializadas

Algumas consultas AAAA

Exemplos de arquivos de um Second Level Domain fictício

Camada de Aplicação: Colocando no "ar" aplicações servidoras

Objetivos

Topologia de rede para experimetação

Servidor SSH

Servidor DNS

Criando um domínio de Internet

Criando a base de dados relativa ao domínio

Configurando as máquinas para acessarem o DNS

Servidor WEB

Desvendando o UDP - Básico

Objetivos

Fonte Base

Parte 1 - Fluxo único UDP

Parte 2 - Experimento com UDP - MUX e DEMUX

Desvendando o TCP - Básico

Objetivos

Fonte Base

Verificando o estabelecimento, troca de dados e finalização da conexão

Desvendando o TCP - Número de Sequência, Controle de Erros e Funcionamento Full-Duplex

Objetivos

Topologia de rede para experimetação

PARTE 1 - Transmissão sem erros: Verificação de Número de Sequência e Reconhecimentos

PARTE 2 - Transmissão com erros: retransmissões

PARTE 3 - Testando a capacidade do TCP de enviar dados de forma duplex

TCP: Equidade e controle de congestionamento

Objetivos

Topologia de rede para experimetação

Parte 1: Somente fluxos TCP

Parte 2: Fluxos TCP mais UDP

Interligação de duas redes através de um roteador

Objetivos

Referências

Topologia de rede para experimetação

Procedimento

Configuração básica de interface de rede

Tabelas Estáticas de Roteamento

Objetivos

Topologia de rede para experimetação

Tabelas estáticas de roteamento

Testando campo TTL com loop na rede

Tecnologia de Enlace Ethernet

Objetivos

Fonte Base

Animação Pearson/Kurose

PARTE 1 - Explorando o SWITCH e o endereço de Broadcast Ethernet

PARTE 2 - Explorando o ARP