hacktricks/network-services-pentesting/pentesting-web

80,443 - Metodologia de Pentesting Web

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Você trabalha em uma empresa de segurança cibernética? Você quer ver sua empresa anunciada no HackTricks? ou você quer ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Verifique os PLANOS DE ASSINATURA!
• Descubra A Família PEASS, nossa coleção exclusiva de NFTs
• Adquira o swag oficial do PEASS & HackTricks
• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-me no Twitter 🐦@carlospolopm.
• Compartilhe suas técnicas de hacking enviando PRs para o repositório hacktricks e repositório hacktricks-cloud.

Dica de bug bounty: inscreva-se no Intigriti, uma plataforma premium de bug bounty criada por hackers, para hackers! Junte-se a nós em https://go.intigriti.com/hacktricks hoje mesmo e comece a ganhar recompensas de até $100.000!

{% embed url="https://go.intigriti.com/hacktricks" %}

Informações Básicas

O serviço web é o serviço mais comum e extenso e existem muitos tipos diferentes de vulnerabilidades.

Porta padrão: 80 (HTTP), 443 (HTTPS)

PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  ssl/https

nc -v domain.com 80 # GET / HTTP/1.0
openssl s_client -connect domain.com:443 # GET / HTTP/1.0

Orientação para Web API

{% content-ref url="web-api-pentesting.md" %} web-api-pentesting.md {% endcontent-ref %}

Resumo da metodologia

Nesta metodologia, vamos supor que você está atacando um domínio (ou subdomínio) e apenas isso. Portanto, você deve aplicar esta metodologia a cada domínio, subdomínio ou IP descoberto com um servidor web indeterminado dentro do escopo.

• Comece identificando as tecnologias usadas pelo servidor web. Procure por dicas para ter em mente durante o restante do teste, se você conseguir identificar com sucesso a tecnologia.
• Alguma vulnerabilidade conhecida na versão da tecnologia?
• Usando alguma tecnologia bem conhecida? Alguma dica útil para extrair mais informações?
• Algum scanner especializado para executar (como wpscan)?
• Execute scanners de propósito geral. Você nunca sabe se eles vão encontrar algo ou se vão encontrar alguma informação interessante.
• Comece com as verificações iniciais: robots, sitemap, erro 404 e verificação SSL/TLS (se HTTPS).
• Comece a navegar na página da web: É hora de encontrar todos os possíveis arquivos, pastas e parâmetros sendo usados. Também verifique se há descobertas especiais.
• Observe que sempre que um novo diretório for descoberto durante a força bruta ou navegação, ele deve ser navegado.
• Força Bruta de Diretórios: Tente forçar a entrada em todos os diretórios descobertos em busca de novos arquivos e diretórios.
• Observe que sempre que um novo diretório for descoberto durante a força bruta ou navegação, ele deve ser forçado.
• Verificação de Backups: Teste se você pode encontrar backups dos arquivos descobertos adicionando extensões de backup comuns.
• Força Bruta de Parâmetros: Tente encontrar parâmetros ocultos.
• Depois de ter identificado todos os possíveis pontos de extremidade que aceitam entrada do usuário, verifique todas as vulnerabilidades relacionadas a eles.
• Siga esta lista de verificação

Versão do Servidor (Vulnerável?)

Identificar

Verifique se existem vulnerabilidades conhecidas para a versão do servidor que está em execução.
Os cabeçalhos HTTP e cookies da resposta podem ser muito úteis para identificar as tecnologias e/ou versão sendo usadas. A varredura do Nmap pode identificar a versão do servidor, mas também podem ser úteis as ferramentas whatweb, webtech ou https://builtwith.com/:

whatweb -a 1 <URL> #Stealthy
whatweb -a 3 <URL> #Aggresive
webtech -u <URL>
webanalyze -host https://google.com -crawl 2

Busque por vulnerabilidades da versão da aplicação web.

Verifique se há algum WAF

• https://github.com/EnableSecurity/wafw00f
• https://github.com/Ekultek/WhatWaf.git
• https://nmap.org/nsedoc/scripts/http-waf-detect.html

Truques de tecnologia web

Alguns truques para encontrar vulnerabilidades em diferentes tecnologias bem conhecidas:

• AEM - Adobe Experience Cloud
• Apache
• Artifactory
• Buckets
• CGI
• Drupal
• Flask
• Git
• Golang
• GraphQL
• H2 - Banco de dados SQL Java
• Truques do IIS
• JBOSS
• Jenkins
• Jira
• Joomla
• JSP
• Laravel
• Moodle
• Nginx
• PHP (o PHP tem muitos truques interessantes que podem ser explorados)
• Python
• Spring Actuators
• Symphony
• Tomcat
• VMWare
• Teste de penetração da API da Web
• WebDav
• Werkzeug
• Wordpress
• Electron Desktop (XSS para RCE)

Leve em consideração que o mesmo domínio pode estar usando diferentes tecnologias em portas, pastas e subdomínios diferentes. Se a aplicação web estiver usando alguma tecnologia/plataforma conhecida listada anteriormente ou qualquer outra, não se esqueça de pesquisar na Internet por novos truques (e me avise!).

Revisão de código fonte

Se o código fonte da aplicação estiver disponível no GitHub, além de realizar um teste White Box da aplicação por conta própria, há algumas informações que podem ser úteis para o teste Black-Box atual:

• Existe um arquivo de registro de alterações, leia-me ou versão ou qualquer coisa com informações de versão acessíveis via web?
• Como e onde as credenciais são salvas? Existe algum arquivo (acessível?) com credenciais (nomes de usuário ou senhas)?
• As senhas estão em texto simples, criptografadas ou qual algoritmo de hashing é usado?
• Está usando alguma chave mestra para criptografar algo? Qual algoritmo é usado?
• É possível acessar algum desses arquivos explorando alguma vulnerabilidade?
• Há alguma informação interessante no GitHub (problemas resolvidos e não resolvidos)? Ou no histórico de commits (talvez alguma senha introduzida em um commit antigo)?

{% content-ref url="code-review-tools.md" %} code-review-tools.md {% endcontent-ref %}

Scanners automáticos

Scanners automáticos de propósito geral

nikto -h <URL>
whatweb -a 4 <URL>
wapiti -u <URL>
W3af
zaproxy #You can use an API
nuclei -ut && nuclei -target <URL>

Scanners de CMS

Se um CMS for usado, não se esqueça de executar um scanner, talvez algo interessante seja encontrado:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, sites vBulletin em busca de problemas de segurança. (GUI)
VulnX: Joomla, Wordpress, Drupal, PrestaShop, Opencart
CMSMap: (W)ordpress, (J)oomla, (D)rupal ou (M)oodle
droopscan: Drupal, Joomla, Moodle, Silverstripe, Wordpress

cmsmap [-f W] -F -d <URL>
wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs

Neste ponto, você já deve ter algumas informações sobre o servidor web usado pelo cliente (se algum dado for fornecido) e algumas dicas a serem lembradas durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner.

Descoberta de Aplicativos Web Passo a Passo

A partir deste ponto, vamos começar a interagir com o aplicativo web.

Verificações iniciais

Páginas padrão com informações interessantes:

• /robots.txt
• /sitemap.xml
• /crossdomain.xml
• /clientaccesspolicy.xml
• /.well-known/
• Verifique também os comentários nas páginas principais e secundárias.

Forçando erros

Servidores web podem comportar-se de forma inesperada quando dados estranhos são enviados para eles. Isso pode abrir vulnerabilidades ou divulgar informações sensíveis.

• Acesse páginas falsas como /qualquer_coisa_falsa.php (.aspx,.html,.etc)
• Adicione "[]", "]]" e "[[" nos valores de cookies e nos valores de parâmetros para criar erros
• Gere um erro fornecendo a entrada /~coisarandom/%s no final da URL
• Tente diferentes verbos HTTP como PATCH, DEBUG ou errados como FAKE

Verifique se é possível fazer upload de arquivos (verbo PUT, WebDav)

Se você descobrir que o WebDav está habilitado, mas não tem permissões suficientes para fazer upload de arquivos na pasta raiz, tente:

• Forçar as credenciais
• Fazer upload de arquivos via WebDav para o resto das pastas encontradas dentro da página web. Você pode ter permissões para fazer upload de arquivos em outras pastas.

Vulnerabilidades SSL/TLS

• Se o aplicativo não estiver forçando o uso de HTTPS em nenhuma parte, então está vulnerável a MitM
• Se o aplicativo estiver enviando dados sensíveis (senhas) usando HTTP. Então é uma vulnerabilidade alta.

Use o testssl.sh para verificar vulnerabilidades (em programas de Bug Bounty, provavelmente esse tipo de vulnerabilidade não será aceito) e use o a2sv para verificar novamente as vulnerabilidades:

./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also

# You can also use other tools, by testssl.sh at this momment is the best one (I think)
sslscan <host:port>
sslyze --regular <ip:port>

Informações sobre vulnerabilidades SSL/TLS:

• https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/
• https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/

Spidering

Inicie algum tipo de spider na web. O objetivo do spider é encontrar o máximo de caminhos possível na aplicação testada. Portanto, a rastreabilidade da web e fontes externas devem ser usadas para encontrar o máximo de caminhos válidos possível.

• gospider (go): spider HTML, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
• hakrawler (go): spider HTML, com LinkFinder para arquivos JS e Archive.org como fonte externa.
• dirhunt (python): spider HTML, também indica "arquivos suculentos".
• evine (go): spider HTML interativo CLI. Também pesquisa no Archive.org.
• meg (go): Essa ferramenta não é um spider, mas pode ser útil. Você só precisa indicar um arquivo com hosts e um arquivo com caminhos, e o meg buscará cada caminho em cada host e salvará a resposta.
• urlgrab (go): spider HTML com capacidades de renderização de JS. No entanto, parece que não está sendo mantido, a versão pré-compilada é antiga e o código atual não compila.
• gau (go): spider HTML que usa provedores externos (wayback, otx, commoncrawl).
• ParamSpider: Este script encontrará URLs com parâmetros e as listará.
• galer (go): spider HTML com capacidades de renderização de JS.
• LinkFinder (python): spider HTML, com capacidades de embelezamento de JS capaz de pesquisar novos caminhos em arquivos JS. Também pode valer a pena dar uma olhada no JSScanner, que é um wrapper do LinkFinder.
• goLinkFinder (go): Para extrair endpoints tanto na fonte HTML quanto em arquivos javascript incorporados. Útil para caçadores de bugs, red teamers, ninjas de segurança da informação.
• JSParser (python2.7): Um script em python 2.7 usando Tornado e JSBeautifier para analisar URLs relativas de arquivos JavaScript. Útil para descobrir facilmente solicitações AJAX. Parece não estar sendo mantido.
• relative-url-extractor (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando uma expressão regular inteligente para encontrar e extrair as URLs relativas de arquivos "feios" (minificados).
• JSFScan (bash, várias ferramentas): Reúne informações interessantes de arquivos JS usando várias ferramentas.
• subjs (go): Encontra arquivos JS.
• page-fetch (go): Carrega uma página em um navegador sem cabeçalho e imprime todas as URLs carregadas para carregar a página.
• Feroxbuster (rust): Ferramenta de descoberta de conteúdo que combina várias opções das ferramentas anteriores.
• Javascript Parsing: Uma extensão do Burp para encontrar caminhos e parâmetros em arquivos JS.
• Sourcemapper: Uma ferramenta que, dado o URL .js.map, fornecerá o código JS embelezado.
• xnLinkFinder: Esta é uma ferramenta usada para descobrir endpoints para um determinado alvo.
• waymore: Descobre links do wayback machine (também fazendo download das respostas no wayback e procurando mais links).
• HTTPLoot (go): Rastreia (até mesmo preenchendo formulários) e também encontra informações sensíveis usando regex específicos.
• SpiderSuite: Spider Suite é um avançado Crawler/Spider de segurança web com várias funcionalidades, projetado para profissionais de segurança cibernética.
• jsluice (go): É um pacote Go e uma ferramenta de linha de comando para extrair URLs, caminhos, segredos e outros dados interessantes do código-fonte JavaScript.

Força Bruta em diretórios e arquivos

Inicie a força bruta a partir da pasta raiz e certifique-se de forçar a todos os diretórios encontrados usando este método e todos os diretórios descobertos pelo Spidering (você pode fazer essa força bruta de forma recursiva e anexando no início da lista de palavras usadas os nomes dos diretórios encontrados).
Ferramentas:

• Dirb / Dirbuster - Incluído no Kali, antigo (e lento), mas funcional. Permite certificados autoassinados e pesquisa recursiva. Muito lento em comparação com as outras opções.
• Dirsearch (python): Não permite certificados autoassinados, mas permite pesquisa recursiva.
• Gobuster (go): Permite certificados autoassinados, não possui pesquisa recursiva.
• Feroxbuster - Rápido, suporta pesquisa recursiva.
• wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
• ffuf - Rápido: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
• uro (python): Isso não é um spider, mas uma ferramenta que, dada a lista de URLs encontradas, irá excluir URLs "duplicadas".
• Scavenger: Extensão do Burp para criar uma lista de diretórios a partir do histórico do burp de diferentes páginas.
• TrashCompactor: Remove URLs com funcionalidades duplicadas (com base em importações de JS).
• Chamaleon: Usa o wapalyzer para detectar as tecnologias usadas e selecionar as listas de palavras a serem usadas.

Dicionários recomendados:

• https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt
• Dirsearch dicionário incluído
• http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10
• Listas de palavras do Assetnote
• https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content
• raft-large-directories-lowercase.txt
• directory-list-2.3-medium.txt
• RobotsDisallowed/top10000.txt
• https://github.com/random-robbie/bruteforce-lists
• https://github.com/google/fuzzing/tree/master/dictionaries
• https://github.com/six2dez/OneListForAll
• https://github.com/random-robbie/bruteforce-lists
• /usr/share/wordlists/dirb/common.txt
• /usr/share/wordlists/dirb/big.txt
• /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

Observe que sempre que um novo diretório for descoberto durante a força bruta ou spidering, ele deve ser forçado.

O que verificar em cada arquivo encontrado

• Verificador de links quebrados: Encontre links quebrados dentro de HTMLs que podem ser propensos a ataques de takeover.
• Backups de arquivos: Depois de encontrar todos os arquivos, procure backups de todos os arquivos executáveis (".php", ".aspx"...). Variações comuns para nomear um backup são: file.ext~, #file.ext#, ~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old. Você também pode usar a ferramenta bfac.
• Descobrir novos parâmetros: Você pode usar ferramentas como Arjun, parameth, x8 e Param Miner para descobrir parâmetros ocultos. Se possível, você pode tentar pesquisar parâmetros ocultos em cada arquivo web executável.
• Arjun todas as listas de palavras padrão: https://github.com/s0md3v/Arjun/tree/master/arjun/db
• Param-miner "params": https://github.com/PortSwigger/param-miner/blob/master/resources/params
• Assetnote "parameters_top_1m": https://wordlists.assetnote.io/
• nullenc0de "params.txt": https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773
• Comentários: Verifique os comentários de todos os arquivos, você pode encontrar credenciais ou funcionalidades ocultas.
• Se você estiver jogando CTF, um truque "comum" é esconder informações dentro de comentários à direita da página (usando centenas de espaços para que você não veja os dados se abrir o código-fonte com o navegador). Outra possibilidade é usar várias novas linhas e esconder informações em um comentário na parte inferior da página da web.
• Chaves de API: Se você encontrar alguma chave de API, há um guia que indica como usar chaves de API de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
• Chaves de API do Google: Se você encontrar alguma chave de API parecida com AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, você pode usar o projeto gmapapiscanner para verificar quais APIs a chave pode acessar.
• Buckets S3: Ao fazer spidering, verifique se algum subdomínio ou algum link está relacionado a algum bucket S3. Nesse caso, verifique as permissões do bucket.

Descobertas especiais

Enquanto realiza o spidering e brute-forcing, você pode encontrar coisas interessantes que precisa observar.

Arquivos interessantes

• Procure links para outros arquivos dentro dos arquivos CSS.
• Se você encontrar um arquivo .git, algumas informações podem ser extraídas
• Se você encontrar um arquivo .env, informações como chaves de API, senhas de bancos de dados e outras informações podem ser encontradas.
• Se você encontrar pontos de extremidade de API, você também deve testá-los. Eles não são arquivos, mas provavelmente "parecerão" arquivos.
• Arquivos JS: Na seção de spidering, foram mencionadas várias ferramentas que podem extrair caminhos de arquivos JS. Além disso, seria interessante monitorar cada arquivo JS encontrado, pois em algumas ocasiões, uma alteração pode indicar que uma vulnerabilidade potencial foi introduzida no código. Você pode usar, por exemplo, JSMon.
• Você também deve verificar os arquivos JS descobertos com RetireJS ou JSHole para verificar se eles são vulneráveis.
• Desofuscador e descompactador de JavaScript: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
• Embelezador de JavaScript: http://jsbeautifier.org/, http://jsnice.org/
• Desofuscação JsFuck (javascript com caracteres: "[]!+" https://ooze.ninja/javascript/poisonjs/)
• TrainFuck: +72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.
• Em várias ocasiões, você precisará entender expressões regulares usadas, isso será útil: https://regex101.com/
• Você também pode monitorar os arquivos onde os formulários foram detectados, pois uma alteração no parâmetro ou o surgimento de um novo formulário pode indicar uma nova funcionalidade potencialmente vulnerável.

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

{% content-ref url="403-and-401-bypasses.md" %} 403-and-401-bypasses.md {% endcontent-ref %}

502 Proxy Error

Se alguma página responder com esse código, provavelmente é um proxy mal configurado. Se você enviar uma solicitação HTTP como: GET https://google.com HTTP/1.1 (com o cabeçalho do host e outros cabeçalhos comuns), o proxy tentará acessar o google.com e você terá encontrado um SSRF.

Autenticação NTLM - Divulgação de informações

Se o servidor em execução que solicita autenticação for o Windows ou se você encontrar um login solicitando suas credenciais (e solicitando o nome de domínio), você pode provocar uma divulgação de informações.
Envie o cabeçalho: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e devido à forma como a autenticação NTLM funciona, o servidor responderá com informações internas (versão do IIS, versão do Windows...) dentro do cabeçalho "WWW-Authenticate".
Você pode automatizar isso usando o plugin do nmap "http-ntlm-info.nse".

Redirecionamento HTTP (CTF)

É possível colocar conteúdo dentro de um redirecionamento. Esse conteúdo não será mostrado ao usuário (pois o navegador executará o redirecionamento), mas algo pode estar oculto lá.

Verificação de Vulnerabilidades Web

Agora que foi realizada uma enumeração abrangente da aplicação web, é hora de verificar várias possíveis vulnerabilidades. Você pode encontrar a lista de verificação aqui:

{% content-ref url="../../pentesting-web/web-vulnerabilities-methodology/" %} web-vulnerabilities-methodology {% endcontent-ref %}

TODO: Complete a lista de vulnerabilidades e técnicas com https://six2dez.gitbook.io/pentest-book/others/web-checklist e https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html, https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection

Monitorar páginas para alterações

Você pode usar ferramentas como https://github.com/dgtlmoon/changedetection.io para monitorar páginas em busca de modificações que possam inserir vulnerabilidades.

Comandos Automáticos HackTricks

Protocol_Name: Web    #Protocol Abbreviation if there is one.
Port_Number:  80,443     #Comma separated if there is more than one.
Protocol_Description: Web         #Protocol Abbreviation Spelled out

Entry_1:
Name: Notes
Description: Notes for Web
Note: |
https://book.hacktricks.xyz/pentesting/pentesting-web

Entry_2:
Name: Quick Web Scan
Description: Nikto and GoBuster
Command: nikto -host {Web_Proto}://{IP}:{Web_Port} &&&& gobuster dir -w {Small_Dirlist} -u {Web_Proto}://{IP}:{Web_Port} && gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_3:
Name: Nikto
Description: Basic Site Info via Nikto
Command: nikto -host {Web_Proto}://{IP}:{Web_Port}

Entry_4:
Name: WhatWeb
Description: General purpose auto scanner
Command: whatweb -a 4 {IP}

Entry_5:
Name: Directory Brute Force Non-Recursive
Description:  Non-Recursive Directory Brute Force
Command: gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_6:
Name: Directory Brute Force Recursive
Description: Recursive Directory Brute Force
Command: python3 {Tool_Dir}dirsearch/dirsearch.py -w {Small_Dirlist} -e php,exe,sh,py,html,pl -f -t 20 -u {Web_Proto}://{IP}:{Web_Port} -r 10

Entry_7:
Name: Directory Brute Force CGI
Description: Common Gateway Interface Brute Force
Command: gobuster dir -u {Web_Proto}://{IP}:{Web_Port}/ -w /usr/share/seclists/Discovery/Web-Content/CGIs.txt -s 200

Entry_8:
Name: Nmap Web Vuln Scan
Description: Tailored Nmap Scan for web Vulnerabilities
Command: nmap -vv --reason -Pn -sV -p {Web_Port} --script=`banner,(http* or ssl*) and not (brute or broadcast or dos or external or http-slowloris* or fuzzer)` {IP}

Entry_9:
Name: Drupal
Description: Drupal Enumeration Notes
Note: |
git clone https://github.com/immunIT/drupwn.git for low hanging fruit and git clone https://github.com/droope/droopescan.git for deeper enumeration

Entry_10:
Name: WordPress
Description: WordPress Enumeration with WPScan
Command: |
?What is the location of the wp-login.php? Example: /Yeet/cannon/wp-login.php
wpscan --url {Web_Proto}://{IP}{1} --enumerate ap,at,cb,dbe && wpscan --url {Web_Proto}://{IP}{1} --enumerate u,tt,t,vp --passwords {Big_Passwordlist} -e

Entry_11:
Name: WordPress Hydra Brute Force
Description: Need User (admin is default)
Command: hydra -l admin -P {Big_Passwordlist} {IP} -V http-form-post '/wp-login.php:log=^USER^&pwd=^PASS^&wp-submit=Log In&testcookie=1:S=Location'

Entry_12:
Name: Ffuf Vhost
Description: Simple Scan with Ffuf for discovering additional vhosts
Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H "Host:FUZZ.{Domain_Name}" -c -mc all {Ffuf_Filters}

Dica de recompensa por bugs: cadastre-se no Intigriti, uma plataforma premium de recompensa por bugs criada por hackers, para hackers! Junte-se a nós em https://go.intigriti.com/hacktricks hoje mesmo e comece a ganhar recompensas de até $100.000!

{% embed url="https://go.intigriti.com/hacktricks" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Você trabalha em uma empresa de cibersegurança? Gostaria de ver sua empresa anunciada no HackTricks? Ou gostaria de ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Confira os PLANOS DE ASSINATURA!
• Descubra A Família PEASS, nossa coleção exclusiva de NFTs
• Adquira produtos oficiais PEASS & HackTricks
• Junte-se ao 💬 grupo Discord ou ao grupo Telegram ou siga-me no Twitter 🐦@carlospolopm.
• Compartilhe suas técnicas de hacking enviando PRs para o repositório hacktricks e o repositório hacktricks-cloud.