LabEx
EntrarJunte-se

Controlar a Velocidade de Scan com Threads no Gobuster

Beginner
Pratique Agora

Introdução

Neste laboratório, você explorará como gerenciar a velocidade de escaneamento do Gobuster, uma popular ferramenta de brute-forcing de diretórios e arquivos, manipulando sua contagem de threads. Compreender como ajustar o número de threads é crucial para um escaneamento eficiente e para minimizar o impacto nos servidores de destino. Você aprenderá a executar escaneamentos com contagens de threads padrão, aumentadas e diminuídas, observando as implicações práticas de cada configuração. Essa experiência prática fornecerá insights sobre a otimização de seus esforços de reconhecimento, ao mesmo tempo em que se mantém atento à etiqueta de rede e à estabilidade do alvo.

Executar um Scan com a Contagem de Threads Padrão (10)

Nesta etapa, você iniciará um scan do Gobuster usando sua contagem de threads padrão, que é tipicamente 10. Isso lhe dará uma compreensão básica de seu desempenho e do formato de saída. O Gobuster tentará descobrir diretórios e arquivos em um servidor web local que foi configurado para este laboratório.

Abra seu terminal e execute o seguinte comando:

gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt
  • gobuster dir: Especifica que você deseja realizar um scan de brute-forcing de diretório/arquivo.
  • -u http://127.0.0.1:8080: Define a URL de destino para o scan. Neste laboratório, estamos visando um servidor HTTP local rodando na porta 8080.
  • -w /tmp/wordlist.txt: Especifica a wordlist a ser usada no processo de brute-forcing. Este arquivo contém nomes comuns de diretórios e arquivos.

Observe a saída. Você verá o Gobuster iniciando o scan, indicando o número de threads em uso (por padrão, 10), e então listando quaisquer diretórios ou arquivos descobertos. Preste atenção à rapidez com que os resultados aparecem.

===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url:            http://127.0.0.1:8080
[+] Threads:        10
[+] Wordlist:       /tmp/wordlist.txt
[+] Status codes:   200,204,301,302,307,401,403
[+] User Agent:     gobuster/X.X.X
[+] Timeout:        10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin                (Status: 200)
/login                (Status: 200)
/secret               (Status: 200)
/index                (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================

A saída mostra a configuração usada para o scan, incluindo a URL, a wordlist e, o mais importante, o número de threads. Os caminhos descobertos como /admin, /login, /secret e /index são listados com seus respectivos códigos de status HTTP.

Aumentar a Contagem de Threads para 50 com a Flag -t

Nesta etapa, você aumentará o número de threads usados pelo Gobuster para 50. Isso é feito usando a flag -t, que permite especificar o número desejado de threads concorrentes. Uma contagem de threads maior geralmente leva a um scan mais rápido, pois mais requisições são enviadas simultaneamente.

Execute o seguinte comando em seu terminal:

gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt -t 50
  • -t 50: Esta nova flag define o número de threads para 50.

Observe a saída novamente. Você deve notar que o scan é concluído muito mais rapidamente do que com os 10 threads padrão. A saída inicial confirmará que 50 threads estão sendo usados.

===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url:            http://127.0.0.1:8080
[+] Threads:        50
[+] Wordlist:       /tmp/wordlist.txt
[+] Status codes:   200,204,301,302,307,401,403
[+] User Agent:     gobuster/X.X.X
[+] Timeout:        10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin                (Status: 200)
/login                (Status: 200)
/secret               (Status: 200)
/index                (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================

Note a linha [+] Threads: 50 na saída, confirmando que sua contagem de threads especificada está sendo usada. O scan deve ser concluído quase instantaneamente devido à pequena wordlist e ao alvo local.

Observe o Aumento na Velocidade do Scan

Nesta etapa, compararemos explicitamente os tempos de scan para confirmar visualmente o impacto do aumento da contagem de threads. Enquanto as etapas anteriores forneceram uma observação qualitativa, esta etapa visa reforçar o conceito.

Embora os scans anteriores tenham sido muito rápidos devido à pequena wordlist e ao servidor local, você deve ter notado uma diferença significativa no tempo que levou para a saída aparecer. Quando você aumentou os threads de 10 para 50, o scan foi concluído quase instantaneamente.

Para ilustrar melhor a diferença de velocidade, imagine se a wordlist contivesse milhares ou milhões de entradas, e o servidor de destino fosse remoto com maior latência. Nesses cenários, a diferença entre 10 e 50 threads seria dramaticamente mais aparente, potencialmente reduzindo o tempo de scan de horas para minutos.

A principal conclusão aqui é que mais threads permitem que o Gobuster envie mais requisições concorrentemente, o que pode reduzir drasticamente o tempo total de scan, especialmente para wordlists grandes e alvos responsivos.

Nenhum comando específico é necessário para esta etapa, pois é uma observação baseada nas duas etapas anteriores.

Diminuir a Contagem de Threads para 5 para um Scan Mais Lento

Agora, vamos reverter o processo e diminuir a contagem de threads para 5. Isso demonstrará como menos threads levam a um scan mais lento. Embora um scan mais lento possa parecer contraproducente, ele pode ser necessário em certas situações, como ao lidar com alvos com limite de taxa (rate-limited) ou para ser menos intrusivo.

Execute o seguinte comando em seu terminal:

gobuster dir -u http://127.0.0.1:8080 -w /tmp/wordlist.txt -t 5
  • -t 5: Isso define o número de threads para 5, que é metade do padrão.

Observe a saída. Você deve notar que o scan leva um pouco mais de tempo para ser concluído em comparação com os 10 threads padrão, e notavelmente mais tempo do que o scan com 50 threads.

===============================================================
Gobuster vX.X.X-XXXXXX
===============================================================
[+] Url:            http://127.0.0.1:8080
[+] Threads:        5
[+] Wordlist:       /tmp/wordlist.txt
[+] Status codes:   200,204,301,302,307,401,403
[+] User Agent:     gobuster/X.X.X
[+] Timeout:        10s
===============================================================
XXXX/XX/XX XX:XX:XX Starting gobuster in directory enumeration mode
===============================================================
/admin                (Status: 200)
/login                (Status: 200)
/secret               (Status: 200)
/index                (Status: 200)
===============================================================
XXXX/XX/XX XX:XX:XX Finished
===============================================================

A linha [+] Threads: 5 confirma a contagem reduzida de threads. Mesmo com nossa pequena wordlist, você deve perceber um leve atraso em comparação com as execuções anteriores. Isso ilustra a relação direta entre a contagem de threads e a duração do scan.

Compreender o Impacto dos Threads no Servidor de Destino

Nesta etapa final, discutiremos as implicações mais amplas do ajuste das contagens de threads, particularmente em relação ao servidor de destino. Embora o aumento de threads possa acelerar seu scan, ele também aumenta a carga no servidor de destino.

Alta Contagem de Threads (por exemplo, 50 ou mais):

  • Prós: Conclusão mais rápida do scan.
  • Contras:
    • Aumento da Carga do Servidor: Enviar muitas requisições simultaneamente pode sobrecarregar o servidor de destino, potencialmente levando a negação de serviço (DoS) ou degradação de desempenho.
    • Rate Limiting/Bloqueio: Muitos servidores web e WAFs (Web Application Firewalls) implementam limites de taxa para prevenir ataques de força bruta. Uma alta contagem de threads pode acionar rapidamente essas defesas, levando ao bloqueio temporário ou permanente do seu IP.
    • Congestionamento de Rede: Pode consumir largura de banda de rede significativa, especialmente se o destino for remoto.
    • Suspeita: Altas taxas de requisição são frequentemente indicativas de atividade maliciosa e podem alertar as equipes de segurança.

Baixa Contagem de Threads (por exemplo, 1-5):

  • Prós:
    • Redução da Carga do Servidor: Menos intrusivo e menos propenso a causar problemas de desempenho no destino.
    • Evasão de Rate Limiting: Taxas de requisição mais lentas são menos propensas a acionar mecanismos de limite de taxa, permitindo que o scan prossiga sem ser detectado por mais tempo.
    • Discrição (Stealth): Parece mais com tráfego de usuário legítimo, reduzindo a chance de detecção.
  • Contras:
    • Scan Mais Lento: Leva significativamente mais tempo para ser concluído, especialmente com wordlists grandes.

Escolhendo a Contagem de Threads Correta:
A contagem de threads ideal depende de vários fatores:

  • Capacidade do Servidor de Destino: Quanta carga o servidor pode suportar?
  • Latência da Rede: Latência mais alta pode exigir mais threads para manter uma velocidade decente.
  • Políticas de Rate Limiting: Existem limites de taxa conhecidos ou WAFs em vigor?
  • Seu Objetivo: Você prioriza velocidade ou discrição?

Para hacking ético e testes de penetração, é crucial estar ciente da estabilidade do alvo e evitar causar qualquer interrupção. Sempre comece com uma contagem de threads mais baixa e aumente-a gradualmente se o alvo puder suportar e seus objetivos exigirem resultados mais rápidos.

Nenhum comando específico é necessário para esta etapa, pois é um entendimento conceitual.

Resumo

Neste laboratório, você aprendeu com sucesso como controlar a velocidade de scan do Gobuster ajustando o número de threads usando o flag -t. Você começou executando um scan com os 10 threads padrão, depois aumentou para 50 para observar uma melhoria significativa de velocidade e, finalmente, diminuiu para 5 para ver o scan desacelerar.

Mais importante, você obteve uma compreensão do impacto crítico que a contagem de threads tem não apenas na duração do scan, mas também no desempenho e nos mecanismos de segurança do servidor de destino. Agora você sabe que, embora mais threads signifiquem scans mais rápidos, eles também aumentam a carga do servidor e o risco de detecção ou bloqueio. Inversamente, menos threads oferecem discrição e reduzem o impacto no servidor ao custo da velocidade. Esse conhecimento é vital para conduzir reconhecimento responsável e eficaz.