80,443 - Metodologia de Pentesting Web

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Informações Básicas

O serviço web é o serviço mais comum e abrangente 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ções para Web API

Web API Pentesting

Resumo da metodologia

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

  • Comece por identificar as tecnologias usadas pelo servidor web. Procure por truques para ter em mente durante o restante do teste se você conseguir identificar a tecnologia com sucesso.
  • Alguma vulnerabilidade conhecida da versão da tecnologia?
  • Está usando alguma tecnologia bem conhecida? Algum truque útil para extrair mais informação?
  • Algum specialised scanner para executar (like wpscan)?
  • Lance general purposes scanners. Você nunca sabe se vão encontrar algo ou alguma informação interessante.
  • Comece com as verificações iniciais: robots, sitemap, erro 404 e SSL/TLS scan (se HTTPS).
  • Comece a spidering a página web: é hora de encontrar todos os possíveis files, folders e parameters being used. Também verifique por special findings.
  • Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered.
  • Directory Brute-Forcing: Tente brute force todas as pastas descobertas procurando por novos files e directories.
  • Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced.
  • Backups checking: Teste se você consegue encontrar backups de discovered files adicionando extensões de backup comuns.
  • Brute-Force parameters: Tente encontrar parâmetros ocultos.
  • Uma vez que você tenha identificado todos os possíveis endpoints que aceitam user input, verifique todos os tipos de vulnerabilidades relacionadas a eles.
  • Follow this checklist

Versão do servidor (Vulnerável?)

Identificar

Verifique se existem vulnerabilidades conhecidas para a versão do servidor que está em execução.
Os HTTP headers and cookies of the response podem ser muito úteis para identificar as tecnologias e/ou versão em uso. Nmap scan 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

Pesquisar por vulnerabilities of the web application version

Verificar se existe algum WAF

Web tech tricks

Alguns truques para encontrar vulnerabilidades em diferentes tecnologias bem conhecidas que estão sendo usadas:

Tenha em conta que o mesmo domínio pode estar usando diferentes tecnologias em diferentes ports, folders e subdomains.
Se a aplicação web estiver usando qualquer tech/platform bem conhecida listada antes ou qualquer outra, não se esqueça de buscar na Internet por novos truques (e me avise!).

Source Code Review

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

  • Existe um Change-log or Readme or Version file ou qualquer coisa com informações de versão acessível via web?
  • Como e onde as credentials são salvas? Existe algum arquivo (acessível?) com credentials (usernames ou passwords)?
  • As passwords estão em plain text, encrypted ou qual algoritmo de hashing é usado?
  • Está usando alguma master key para encriptar algo? Qual algoritmo é usado?
  • Você consegue acessar algum desses arquivos explorando alguma vulnerabilidade?
  • Há alguma informação interessante no github (issues resolvidas ou não)? Ou no commit history (talvez alguma password introduzida em um commit antigo)?

Source code Review / SAST Tools

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>

# https://github.com/ignis-sec/puff (client side vulns fuzzer)
node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"

Scanners de CMS

Se um CMS estiver em uso, 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, vBulletin sites para questões 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 alguma informação sobre o web server usado pelo cliente (se algum dado foi fornecido) e alguns truques para ter em mente durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner.

Step-by-step Web Application Discovery

A partir deste ponto vamos começar a interagir com a aplicação web.

Initial checks

Default pages with interesting info:

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

Forcing errors

Web servers podem comportar-se de forma inesperada quando dados estranhos são enviados a eles. Isso pode abrir vulnerabilidades ou vazar informações sensíveis.

  • Acesse páginas fake como /whatever_fake.php (.aspx,.html,.etc)
  • Adicione “[]”, “]]”, e “[[” em valores de cookie e valores de parâmetro para criar erros
  • Gere erro fornecendo input como /~randomthing/%s no final da URL
  • Tente verbos HTTP diferentes como PATCH, DEBUG ou incorretos como FAKE

Check if you can upload files (PUT verb, WebDav)

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

  • Brute Force credentials
  • Upload de arquivos via WebDav nas demais pastas encontradas dentro da página web. Você pode ter permissões para subir arquivos em outras pastas.

Vulnerabilidades SSL/TLS

  • Se a aplicação não força o uso de HTTPS em nenhuma parte, então ela é vulnerável a MitM
  • Se a aplicação envia dados sensíveis (senhas) via HTTP, então é uma vulnerabilidade grave.

Use testssl.sh para checar vulnerabilidades (em programas de Bug Bounty provavelmente esse tipo de vulnerabilidade não será aceito) e use a2sv para revalidar 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:

Spidering

Inicie algum tipo de spider no web. O objetivo do spider é encontrar o máximo de caminhos possível da aplicação testada. Portanto, web crawling e fontes externas devem ser usados para encontrar o maior número possível de caminhos válidos.

  • gospider (go): HTML spider, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com).
  • hakrawler (go): HML spider, com LinkFider para arquivos JS e Archive.org como fonte externa.
  • dirhunt (python): HTML spider, também indica “juicy files”.
  • evine (go): CLI interativo HTML spider. Também pesquisa no Archive.org
  • meg (go): Esta ferramenta não é um spider mas pode ser útil. Você pode indicar um arquivo com hosts e um arquivo com paths e o meg irá buscar cada path em cada host e salvar a resposta.
  • urlgrab (go): HTML spider com capacidades de renderização JS. No entanto, parece não ser mantido, a versão pré-compilada é antiga e o código atual não compila
  • gau (go): HTML spider que usa provedores externos (wayback, otx, commoncrawl)
  • ParamSpider: Este script encontrará URLs com parâmetros e irá listá-los.
  • galer (go): HTML spider com capacidades de renderização JS.
  • LinkFinder (python): HTML spider, com capacidades de JS beautify capaz de buscar novos caminhos em arquivos JS. Pode valer a pena também olhar o JSScanner, que é um wrapper do LinkFinder.
  • goLinkFinder (go): Para extrair endpoints tanto do source HTML quanto de arquivos javascript embutidos. Útil para bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): Um script python 2.7 que usa Tornado e JSBeautifier para parsear URLs relativas de arquivos JavaScript. Útil para descobrir facilmente requisições AJAX. Parece não ser mantido.
  • relative-url-extractor (ruby): Dado um arquivo (HTML) ele extrairá URLs dele usando expressões regulares para encontrar e extrair URLs relativas de arquivos minificados.
  • JSFScan (bash, várias ferramentas): Coleta informação interessante de arquivos JS usando várias ferramentas.
  • subjs (go): Encontra arquivos JS.
  • page-fetch (go): Carrega uma página em um browser headless e imprime todas as urls carregadas para montar a página.
  • Feroxbuster (rust): Ferramenta de content discovery misturando várias opções das ferramentas anteriores
  • Javascript Parsing: Uma extensão do Burp para encontrar paths e params em arquivos JS.
  • BurpJSLinkFinder Enhanced: Extensão Burp (Jython) que analisa passivamente respostas JavaScript (por MIME type e caminhos /js) para extrair endpoints/links e opcionalmente sinalizar segredos embutidos com severidade.
  • Sourcemapper: Uma ferramenta que dado o .js.map URL irá obter o código JS beatificado
  • xnLinkFinder: Ferramenta usada para descobrir endpoints para um target dado.
  • waymore: Descobre links da wayback machine (também baixando as respostas na wayback e procurando mais links)
  • HTTPLoot (go): Crawl (até preenchendo forms) e também encontra info sensível usando regexes específicas.
  • SpiderSuite: Spider Suite é um crawler/spider GUI avançado multi-funcional projetado para profissionais de cibersegurança.
  • jsluice (go): É um pacote Go e ferramenta de linha de comando para extrair URLs, paths, segredos e outros dados interessantes de código fonte JavaScript.
  • ParaForge: ParaForge é uma simples Burp Suite extension para extrair os parâmetros e endpoints da request para criar wordlists customizadas para fuzzing e enumeração.
  • katana (go): Excelente ferramenta para isso.
  • Crawley (go): Imprime todo link que conseguir encontrar.

Brute Force diretórios e arquivos

Comece o brute-forcing a partir da pasta root e certifique-se de brute-force todos os diretórios encontrados usando este método e todos os diretórios descobertos pelo Spidering (você pode fazer esse brute-forcing recursivamente e anexar no início do wordlist usado os nomes dos diretórios encontrados).
Ferramentas:

  • Dirb / Dirbuster - Incluído no Kali, antigo (e lento) mas funcional. Permite auto-signed certificates e busca recursiva. Muito lento comparado com as outras opções.
  • Dirsearch (python): Não permite auto-signed certificates mas permite busca recursiva.
  • Gobuster (go): Permite auto-signed certificates, não tem busca recursiva.
  • Feroxbuster - Rápido, suporta busca 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): Não é um spider mas uma ferramenta que, dada a lista de URLs encontradas, deleta URLs “duplicadas”.
  • Scavenger: Burp Extension para criar uma lista de diretórios a partir do histórico do burp de diferentes páginas
  • TrashCompactor: Remove URLs com funcionalidades duplicadas (baseado em imports js)
  • Chamaleon: Usa wapalyzer para detectar tecnologias usadas e selecionar os wordlists a serem usados.

Dicionários recomendados:

Nota que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced.

O que verificar em cada arquivo encontrado

  • Broken link checker: Encontrar links quebrados dentro de HTMLs que podem ser suscetíveis a takeovers
  • File Backups: Uma vez que você encontrou todos os arquivos, procure por 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 ou backup-gen.
  • Discover new parameters: Você pode usar ferramentas como Arjun, parameth, x8 e Param Miner para descobrir parâmetros escondidos. Se possível, tente buscar parâmetros escondidos em cada arquivo web executável.
  • Arjun all default wordlists: 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
  • Comments: Verifique os comentários de todos os arquivos, você pode encontrar credentials ou funcionalidade escondida.
  • Se você está jogando CTF, um truque “comum” é esconder informação dentro de comentários à direita da página (usando centenas de espaços para que você não veja os dados se abrir o source com o navegador). Outra possibilidade é usar várias quebras de linha e esconder informação em um comentário no final da página web.
  • API keys: Se você encontrar qualquer API key existe um guia que indica como usar API keys de diferentes plataformas: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
  • Google API keys: Se você encontrar qualquer API key que pareça com AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik você pode usar o projeto gmapapiscanner para checar quais apis a key pode acessar.
  • S3 Buckets: Enquanto estiver spidering verifique se algum subdomain ou algum link está relacionado com algum S3 bucket. Nesse caso, verifique as permissões do bucket.

Descobertas especiais

Enquanto executar o spidering e o brute-forcing você pode encontrar coisas interessantes que você deve observar.

Arquivos interessantes

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

502 Proxy Error

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

NTLM Authentication - Info disclosure

Se o servidor que pedir autenticação for Windows ou você encontrar um login pedindo suas credentials (e pedindo o nome do domínio), você pode provocar uma divulgação de informação.
Envie o header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e devido a como a NTLM authentication funciona, o servidor irá responder com informações internas (versão do IIS, versão do Windows…) dentro do header “WWW-Authenticate”.
Você pode automatizar isso usando o nmap plugin “http-ntlm-info.nse”.

HTTP Redirect (CTF)

É possível inserir conteúdo dentro de uma Redirection. Esse conteúdo não será mostrado ao usuário (já que o navegador executará o redirecionamento) mas algo pode ser escondido ali.

Web Vulnerabilities Checking

Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de checar uma série de possíveis vulnerabilidades. Você pode encontrar a checklist aqui:

Web Vulnerabilities Methodology

Encontre mais info sobre web vulns em:

Monitor Pages for changes

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

HackTricks Automatic Commands

Comandos Automáticos do HackTricks ```yaml 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.wiki/en/network-services-pentesting/pentesting-web/index.html

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}

</details>

## Referências

- [https://github.com/panchocosil/burp-js-linkfinder-enhanced](https://github.com/panchocosil/burp-js-linkfinder-enhanced)

> [!TIP]
> Aprenda e pratique Hacking AWS:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Aprenda e pratique Hacking GCP: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
> Aprenda e pratique Hacking Azure: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://training.hacktricks.xyz/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
>
> <details>
>
> <summary>Supporte o HackTricks</summary>
>
> - Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
> - **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **Compartilhe truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
>
> </details>