Introdução
Neste laboratório, revisitaremos a estrutura modular e a análise funcional do Metasploit, e então focaremos na introdução de scanners. Você aprenderá como desenvolver seu próprio scanner para o Metasploit.
Este laboratório é um tutorial prático. Para ajudá-lo a entender algumas operações, incluiremos alguma teoria de segurança da informação e recomendaremos artigos valiosos para você ler, permitindo que você solidifique sua base teórica enquanto pratica.
Revisar a Estrutura do Metasploit e Criar o Arquivo simple_tcp.rb
Primeiramente, vamos revisar a estrutura do Metasploit.
O Metasploit é projetado com um conceito modular para melhorar a eficiência da reutilização de código. O framework é desenvolvido em Ruby e inclui componentes escritos em Perl, C, Assembly e Python. Ele é projetado principalmente para sistemas operacionais Linux, portanto, sua estrutura de comandos é muito semelhante a um shell de comando Linux. No entanto, agora ele suporta todos os principais sistemas operacionais, como Windows, Solaris e Mac.
+---------------+------------------+----------------------------------------------+
| Nome em Inglês | Nome do Módulo | Descrição |
+---------------+------------------+----------------------------------------------+
| `Aux` | Módulo Auxiliar | Fornece uma variedade de módulos auxiliares |
| | | para coleta de informações durante a |
| | | penetração, incluindo a varredura e a |
| | | identificação de serviços de rede, a |
| | | construção de serviços falsos para coletar |
| | | credenciais de login, adivinhação de |
| | | senhas, etc. |
+---------------+------------------+----------------------------------------------+
| `Exploits` | Módulo de Exploit | Componentes de código que exploram |
| | | vulnerabilidades de segurança ou falhas de |
| | | configuração descobertas para atacar sistemas |
| | | alvo remotos, plantar e executar payloads e |
| | | obter controle de acesso sobre os sistemas |
| | | alvo. |
+---------------+------------------+----------------------------------------------+
| `Post` | Pós-Exploração | Suporta várias ações de pós-exploração no |
| | Módulo | sistema controlado após obter controle de |
| | | acesso remoto por meio da exploração, como |
| | | obter informações confidenciais, fazer |
| | | pivoting adicional e lançar ataques de pivot. |
+---------------+------------------+----------------------------------------------+
| `Payloads` | Módulo de Payload | Payloads são segmentos de código que são |
| | | executados no sistema alvo após uma |
| | | exploração bem-sucedida, normalmente para |
| | | abrir uma conexão de sessão de controle para |
| | | o atacante. |
+---------------+------------------+----------------------------------------------+
| `Encoders` | Módulo Encoder | Após montar o payload e as instruções NOP |
| | | em uma sequência de instruções, o Metasploit |
| | | precisa realizar uma etapa de codificação |
| | | importante antes que o módulo de exploit |
| | | injete o buffer de dados maliciosos no |
| | | sistema alvo para execução. |
+---------------+------------------+----------------------------------------------+
| `Nops` | Módulo NOP | Instruções NOP (No Operation) são |
| | | operações ou instruções que não têm nenhum |
| | | efeito substancial no estado de execução do |
| | | programa. |
+---------------+------------------+----------------------------------------------+
O Metasploit também integra vários componentes de varredura de vulnerabilidades, como:
- Scanner `Nmap`: Adequado para Windows, Linux e Mac OS. Usado para descoberta de hosts, varredura ou enumeração de portas, descoberta de serviços e detecção de sistemas operacionais, endereços de hardware, versões de software e vulnerabilidades.
- Scanner `NeXpose`: Varre a rede para encontrar dispositivos em execução, identificar seus sistemas operacionais e vulnerabilidades de aplicativos, analisar os dados varridos e gerar relatórios de varredura de vulnerabilidades.
- Scanner `Nessus`: Uma das ferramentas de varredura de vulnerabilidades mais amplamente utilizadas. Ele adota um modelo cliente/servidor, com o servidor realizando verificações de segurança e o cliente configurando e gerenciando o servidor. O servidor também usa um sistema de plugin, permitindo que os usuários adicionem plugins para funções específicas e verificações de segurança mais complexas.
Agora, criaremos um novo módulo de scanner do Metasploit chamado `simple_tcp.rb`.
1. Abra um terminal xfce na máquina host LabEx e inicie o alvo Metasploitable2 executando o seguinte comando:
```bash
sudo virsh start Metasploitable2
Aguarde o início da máquina alvo, pode levar de 1 a 3 minutos.
- Teste a conectividade com a máquina alvo fazendo ping nela:
ping 192.168.122.102
Pressione Ctrl+C para parar o ping.
- Inicie o container Kali Linux e entre no ambiente bash executando:
docker run -ti --network host b5b709a49cd5 bash
- Dentro do container Kali, teste a conexão de rede com a máquina alvo:
ping 192.168.122.102
Pressione Ctrl+C para parar o ping.
- Em seguida, navegue até o diretório do módulo
scanner:
cd /usr/share/metasploit-framework/modules/auxiliary/scanner
- Crie um novo arquivo chamado
simple_tcp.rb:
sudo vi simple_tcp.rb
- Copie e cole o seguinte código no arquivo:
require 'msf/core'
class MetasploitModule < Msf::Auxiliary
include Msf::Exploit::Remote::Tcp
include Msf::Auxiliary::Scanner
def initialize
super(
'Name' => 'Mr_Zhou Scanner',
'Version' => '$Revision$',
'Description' => 'Shiyanlou TCP Scanner',
'Author' => 'lucat',
'License' => MSF_LICENSE
)
register_options(
[
Opt::RPORT(12345)
], self.class)
end
def run_host(ip)
connect()
sock.puts('HELLO SERVER')
data = sock.recv(1024)
print_status("Received: #{data} from #{ip}")
disconnect()
end
end
- Este código define um novo módulo do Metasploit chamado "Mr_Zhou Scanner" que varre portas TCP e exibe quaisquer dados recebidos do servidor. Vamos analisar o código:
def initialize
super(
'Name' => 'Mr_Zhou Scanner',
'Version' => '$Revision$',
'Description' => 'Shiyanlou TCP Scanner',
'Author' => 'lucat',
'License' => MSF_LICENSE
)
Esta seção define os metadados para o módulo, como seu nome, descrição, autor e licença.
register_options(
[
Opt::RPORT(12345)
], self.class)
Esta linha registra a opção para varrer a porta 12345.
def run_host(ip)
connect()
sock.puts('HELLO SERVER')
data = sock.recv(1024)
print_status("Received: #{data} from #{ip}")
disconnect()
end
Este método é executado para cada endereço IP alvo. Ele se conecta à porta especificada, envia a string "HELLO SERVER", recebe e imprime quaisquer dados do servidor e, em seguida, desconecta.
Salve o arquivo e saia do editor.
Configurar um Servidor de Escuta
Para testar nosso scanner simple_tcp.rb, precisamos configurar um servidor de escuta na máquina alvo.
No host LabEx, abra um novo terminal Xfce e crie um arquivo chamado shiyanlou.txt:
vi shiyanlou.txt
Neste arquivo, insira qualquer texto que você desejar. Este texto será enviado de volta ao scanner quando ele se conectar à porta de escuta. Por exemplo:
Life is short, i use Python.
Salve o arquivo e saia do editor.
Em seguida, inicie um servidor de escuta na porta 12345 (a porta para a qual nosso scanner está configurado) e envie o conteúdo de shiyanlou.txt para quaisquer clientes que se conectarem:
sudo nc -l 12345 < shiyanlou.txt
O servidor agora estará escutando na porta 12345 e aguardando conexões de entrada.
Executar o Scanner simple_tcp
Agora que temos nosso módulo de scanner simple_tcp e um servidor de escuta configurados, vamos executar o scanner e ver se ele funciona.
Primeiro, inicie o console do Metasploit no container Kali Linux:
cd ~
sudo msfconsole
Assim que o console for carregado, use nosso módulo simple_tcp:
use auxiliary/scanner/simple_tcp
Você pode visualizar as informações do módulo com o comando info:
info
Aqui está um exemplo da saída que você pode ver:
Name: Mr_Zhou Scanner
Description: Shiyanlou TCP Scanner
Author: lucat
License: Metasploit Framework License (BSD)
Version: $Revision$
Em seguida, defina o endereço IP do host alvo:
set RHOSTS 192.168.122.1
Observação: Use RHOSTS (com um 's'), não RHOST. Você pode verificar qual opção usar com o comando show options.
Finalmente, execute o scanner:
run
Se tudo estiver configurado corretamente, você deverá ver a mensagem do servidor de escuta:
[+] Received: Life is short, i use Python. from 192.168.122.1
Se você não recebeu essa mensagem, volte ao seu servidor de escuta e execute sudo nc -l 12345 < shiyanlou.txt novamente.
Parabéns! Você desenvolveu e testou com sucesso seu próprio módulo de scanner Metasploit.
Pressione Ctrl+D para sair do console do Metasploit e, em seguida, inicie a inspeção
Resumo
Neste laboratório, você aprendeu como desenvolver seu próprio módulo de scanner Metasploit. Você revisou a estrutura do módulo Metasploit, criou um novo módulo de scanner TCP chamado simple_tcp.rb, configurou um servidor de escuta para testar o scanner e executou com sucesso o scanner para receber e exibir dados do servidor.
Esta experiência prática com o desenvolvimento de um scanner Metasploit o ajudará a entender melhor as capacidades do framework e como estendê-lo com módulos personalizados. Você pode usar esse conhecimento para criar scanners mais avançados ou outros tipos de módulos para várias tarefas de teste de penetração.
