80,443 - Pentesting Web Methodology

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 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 identificando as tecnologias usadas pelo servidor web. Procure por truques para ter em mente durante o restante do teste se você conseguir identificar com sucesso a tech.
  • Existe alguma vulnerabilidade conhecida da versão da tecnologia?
  • Usando alguma well known tech? Algum truque útil para extrair mais informação?
  • Algum scanner especializado para rodar (como wpscan)?
  • Lance scanners de propósito geral. Você nunca sabe se eles vão encontrar algo ou alguma informação interessante.
  • Comece com as initial checks: robots, sitemap, 404 error e SSL/TLS scan (se HTTPS).
  • Comece a spidering a página web: é hora de encontrar todos os possíveis arquivos, pastas e parâmetros sendo usados. Também, verifique por achados especiais.
  • Note que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered.
  • Directory Brute-Forcing: Tente brute-forçar todas as pastas descobertas procurando por novos arquivos e diretórios.
  • Note 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 arquivos descobertos anexando 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 input do usuário, verifique todos os tipos de vulnerabilidades relacionadas a eles.
  • Follow this checklist

Server Version (Vulnerable?)

Identify

Verifique se existem vulnerabilidades conhecidas para a versão do servidor que está rodando.
Os HTTP headers e cookies da resposta 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

Procure for vulnerabilities of the web application version

Verifique se há algum WAF

Truques de tecnologia web

Alguns truques para encontrar vulnerabilidades em diferentes bem conhecidas technologies em uso:

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

Revisão do Código-Fonte

Se o código-fonte da aplicação estiver disponível no github, além de realizar por você mesmo um White box test da aplicação, há algumas informações que podem ser úteis para o atual Black-Box testing:

  • Existe um Change-log or Readme or Version file ou qualquer coisa com version info accessible via web?
  • Como e onde são salvas as credentials? É há algum (acessível?) file com credentials (usernames or passwords)?
  • As passwords estão em plain text, encrypted ou qual hashing algorithm é usado?
  • Está usando alguma master key para encriptar algo? Qual algorithm é usado?
  • Você pode access any of these files explorando alguma vulnerabilidade?
  • Existe alguma informação interessante no github (solved and not solved) issues? 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 esqueça de rodar um scanner, talvez algo interessante seja encontrado:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin sites 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 houver dados fornecidos) e alguns truques a ter em mente durante o teste. Se tiver sorte você até encontrou um CMS e executou algum scanner.

Descoberta de Aplicações Web passo a passo

A partir deste ponto vamos começar a interagir com a aplicação 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 comentários nas páginas principais e secundárias.

Forçar erros

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

  • Acesse fake pages como /whatever_fake.php (.aspx,.html,.etc)
  • Adicione “[]”, “]]” e “[[” em cookie values e parameter values para criar erros
  • Gere erro dando entrada como /~randomthing/%s no final da URL
  • Tente diferentes HTTP Verbs como PATCH, DEBUG ou inválidos como FAKE

Verifique se você pode upload files (PUT verb, WebDav)

Se descobrir que WebDav está enabled mas você não tem permissões suficientes para uploading files na pasta root, tente:

  • Brute Force credentials
  • Upload files via WebDav para o restante das found folders dentro da página. Você pode ter permissões para upload files em outras pastas.

Vulnerabilidades SSL/TLS

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

Use testssl.sh para checar vulnerabilities (Em Bug Bounty programs provavelmente esse tipo de vulnerabilities não será aceito) e use a2sv para recheck as vulnerabilities:

./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ção sobre vulnerabilidades SSL/TLS:

Spidering

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

  • gospider (go): HTML spider, LinkFinder in JS files and external sources (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): Interactive CLI HTML spider. It also searches in Archive.org
  • meg (go): This tool isn’t a spider but it can be useful. You can just indicate a file with hosts and a file with paths and meg will fetch each path on each host and save the response.
  • urlgrab (go): HTML spider with JS rendering capabilities. However, it looks like it’s unmaintained, the precompiled version is old and the current code doesn’t compile
  • gau (go): HTML spider that uses external providers (wayback, otx, commoncrawl)
  • ParamSpider: This script will find URLs with parameter and will list them.
  • galer (go): HTML spider with JS rendering capabilities.
  • LinkFinder (python): HTML spider, with JS beautify capabilities capable of search new paths in JS files. It could be worth it also take a look to JSScanner, which is a wrapper of LinkFinder.
  • goLinkFinder (go): To extract endpoints in both HTML source and embedded javascript files. Useful for bug hunters, red teamers, infosec ninjas.
  • JSParser (python2.7): A python 2.7 script using Tornado and JSBeautifier to parse relative URLs from JavaScript files. Useful for easily discovering AJAX requests. Looks like unmaintained.
  • relative-url-extractor (ruby): Given a file (HTML) it will extract URLs from it using nifty regular expression to find and extract the relative URLs from ugly (minify) files.
  • JSFScan (bash, several tools): Gather interesting information from JS files using several tools.
  • subjs (go): Find JS files.
  • page-fetch (go): Load a page in a headless browser and print out all the urls loaded to load the page.
  • Feroxbuster (rust): Content discovery tool mixing several options of the previous tools
  • Javascript Parsing: A Burp extension to find path and params in JS files.
  • Sourcemapper: A tool that given the .js.map URL will get you the beatified JS code
  • xnLinkFinder: This is a tool used to discover endpoints for a given target.
  • waymore: Discover links from the wayback machine (also downloading the responses in the wayback and looking for more links)
  • HTTPLoot (go): Crawl (even by filling forms) and also find sensitive info using specific regexes.
  • SpiderSuite: Spider Suite is an advance multi-feature GUI web security Crawler/Spider designed for cyber security professionals.
  • jsluice (go): It’s a Go package and command-line tool for extracting URLs, paths, secrets, and other interesting data from JavaScript source code.
  • ParaForge: ParaForge is a simple Burp Suite extension to extract the paramters and endpoints from the request to create custom wordlist for fuzzing and enumeration.
  • katana (go): Awesome tool for this.
  • Crawley (go): Print every link it’s able to find.

Brute Force directories and files

Comece o brute-forcing a partir da pasta raiz e certifique-se de brute-forçar 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 acrescentar no início da wordlist usada os nomes dos diretórios encontrados).
Ferramentas:

  • Dirb / Dirbuster - Included in Kali, old (and slow) but functional. Allow auto-signed certificates and recursive search. Too slow compared with th other options.
  • Dirsearch (python): It doesn’t allow auto-signed certificates but allows recursive search.
  • Gobuster (go): It allows auto-signed certificates, it doesn’t have recursive search.
  • Feroxbuster - Fast, supports recursive search.
  • wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
  • ffuf - Fast: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
  • uro (python): This isn’t a spider but a tool that given the list of found URLs will to delete “duplicated” URLs.
  • Scavenger: Burp Extension to create a list of directories from the burp history of different pages
  • TrashCompactor: Remove URLs with duplicated functionalities (based on js imports)
  • Chamaleon: It uses wapalyzer to detect used technologies and select the wordlists to use.

Dicionários recomendados:

Note que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser brute-forçado.

What to check on each file found

  • Broken link checker: Encontre links quebrados dentro de HTMLs que possam ser suscetíveis a takeovers
  • File Backups: Depois de ter encontrado todos os arquivos, procure por backups de todos os arquivos executáveis (“.php”, “.aspx”…). Variações comuns de nome para backups 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 ocultos. Se possível, tente buscar parâmetros ocultos 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 credenciais ou funcionalidade oculta.
  • Se você estiver 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 código-fonte no 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 alguma 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 encontrar qualquer API key que comece com AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik você pode usar o projeto gmapapiscanner para verificar quais apis a chave 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.

Special findings

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

Arquivos interessantes

403 Forbidden/Basic Authentication/401 Unauthorized (bypass)

403 & 401 Bypasses

502 Proxy Error

Se alguma 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 está solicitando autenticação for Windows ou você encontrar um login pedindo suas credenciais (e pedindo o nome do domain), você pode provocar uma divulgação de informação.
Envie o header: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e devido a como a autenticação NTLM funciona, o servidor 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 colocar conteúdo dentro de um Redirection. Esse conteúdo não será mostrado ao usuário (já que o navegador executará a redireção) mas algo poderia estar escondido ali.

Web Vulnerabilities Checking

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

Web Vulnerabilities Methodology

Encontre mais informações sobre web vulns em:

Monitor Pages for changes

Você pode usar ferramentas como https://github.com/dgtlmoon/changedetection.io para monitorar páginas em busca de 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>

> [!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>