Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-19 01:24:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/README.md

29 KiB
Raw Blame History

80,443 - Metodologia de Pentesting Web

Aprenda hacking em AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras formas de apoiar o HackTricks:

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 existe uma grande variedade de 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 API Web

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

Resumo da Metodologia

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

  • Comece identificando as tecnologias usadas pelo servidor web. Procure por truques para ter em mente durante o resto do teste, se você conseguir identificar a tecnologia com sucesso.
  • Alguma vulnerabilidade conhecida da versão da tecnologia?
  • Usando alguma tecnologia bem conhecida? Algum truque útil para extrair mais informações?
  • Algum scanner especializado para executar (como wpscan)?
  • Lance scanners de propósitos gerais. Nunca se sabe se eles vão encontrar algo ou se vão descobrir alguma informação interessante.
  • Comece com as verificações iniciais: robots, sitemap, erro 404 e varredura SSL/TLS (se HTTPS).
  • Comece o spidering da página web: É hora de encontrar todos os possíveis arquivos, pastas e parâmetros sendo usados. Além disso, verifique por descobertas especiais.
  • Observe que sempre que um novo diretório for descoberto durante o brute-forcing ou spidering, ele deve ser spidered.
  • Brute-Forcing de Diretórios: Tente forçar bruscamente todas as pastas descobertas em busca de novos arquivos e diretórios.
  • Observe que sempre que um novo diretório for descoberto durante o brute-forcing ou spidering, ele deve ser Brute-Forced.
  • Verificação de Backups: Teste se você consegue encontrar backups de arquivos descobertos anexando extensões comuns de backup.
  • Brute-Force em parâmetros: Tente encontrar parâmetros ocultos.
  • Uma vez que você tenha identificado todos os possíveis endpoints aceitando entrada de usuário, verifique todos os tipos de vulnerabilidades relacionadas a isso.
  • Siga esta checklist

Versão do Servidor (Vulnerável?)

Identificar

Verifique se há 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 em uso. A varredura 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

Busca por vulnerabilidades da versão da aplicação web

Verifique se há algum WAF

Truques de tecnologia web

Alguns truques para encontrar vulnerabilidades em diferentes tecnologias bem conhecidas 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 listada anteriormente ou qualquer outra, não esqueça de pesquisar na Internet 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 por conta própria um teste de Caixa Branca da aplicação, há algumas informações que podem ser úteis para o atual teste de Caixa Preta:

  • Há um arquivo de Change-log ou Readme ou Versão ou algo com informações de versão acessíveis via web?
  • Como e onde são salvos os credenciais? Há algum arquivo (acessível?) com credenciais (nomes de usuário ou senhas)?
  • As senhas estão em texto puro, criptografadas ou qual algoritmo de hash é usado?
  • Está usando alguma chave mestra para criptografar algo? Qual algoritmo é usado?
  • Você pode 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>

# 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 é utilizado não esqueça de executar um scanner, talvez algo interessante seja encontrado:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: WordPress, Drupal, Joomla, vBulletin websites 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

Descoberta Passo a Passo de Aplicações Web

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çando erros

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

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

Verifique se você pode fazer upload de arquivos (verbo PUT, WebDav)

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

  • Força Bruta nas credenciais
  • Faça 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 a aplicação não está forçando o uso de HTTPS em alguma parte, então ela está vulnerável a MitM
  • Se a aplicação está enviando dados sensíveis (senhas) usando HTTP. Então é uma vulnerabilidade alta.

Use testssl.sh para verificar vulnerabilidades (em programas de Bug Bounty provavelmente esses tipos de vulnerabilidades não serão aceitos) e use a2sv para rechecar 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

Lance algum tipo de spider na web. O objetivo do spider é encontrar o máximo de caminhos possíveis a partir da aplicação testada. Portanto, deve-se usar rastreamento web e fontes externas para encontrar o máximo de caminhos válidos possíveis.

  • gospider (go): Spider HTML, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
  • hakrawler (go): Spider HML, com LinkFider 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): Esta ferramenta não é um spider, mas pode ser útil. Você pode apenas 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 JS. No entanto, parece que está sem manutenção, 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âmetro e as listará.
  • galer (go): Spider HTML com capacidades de renderização JS.
  • LinkFinder (python): Spider HTML, com capacidades de embelezamento JS capaz de buscar novos caminhos em arquivos JS. Também vale a pena dar uma olhada no JSScanner, que é um wrapper do LinkFinder.
  • goLinkFinder (go): Para extrair endpoints em arquivos HTML e javascript embutidos. Útil para caçadores de bugs, equipes vermelhas, ninjas de infosec.
  • JSParser (python2.7): Um script python 2.7 usando Tornado e JSBeautifier para analisar URLs relativas de arquivos JavaScript. Útil para descobrir facilmente solicitações AJAX. Parece sem manutenção.
  • relative-url-extractor (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando uma expressão regular inteligente para encontrar e extrair URLs relativas de arquivos feios (minificados).
  • JSFScan (bash, várias ferramentas): Coletar informações interessantes de arquivos JS usando várias ferramentas.
  • subjs (go): Encontrar arquivos JS.
  • page-fetch (go): Carrega uma página em um navegador sem cabeça e imprime todas as URLs carregadas para carregar a página.
  • Feroxbuster (rust): Ferramenta de descoberta de conteúdo misturando várias opções das ferramentas anteriores
  • Javascript Parsing: Uma extensão Burp para encontrar caminho 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 alvo dado.
  • waymore: Descobrir links do wayback machine (também baixando as respostas no wayback e procurando mais links
  • HTTPLoot (go): Rastrear (até preenchendo formulários) e também encontrar informações sensíveis usando regexes específicos.
  • SpiderSuite: Spider Suite é um Crawler/Spider de segurança web GUI avançado com múltiplas funcionalidades projetado para profissionais de segurança cibernética.
  • jsluice (go): É um pacote Go e ferramenta de linha de comando para extrair URLs, caminhos, segredos e outros dados interessantes de código fonte JavaScript.
  • ParaForge: ParaForge é uma simples extensão Burp Suite para extrair os parâmetros e endpoints da solicitação para criar uma lista de palavras personalizada para fuzzing e enumeração.

Força Bruta em diretórios e arquivos

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

  • Dirb / Dirbuster - Incluído no Kali, antigo (e lento) mas funcional. Permite certificados autoassinados e busca recursiva. Muito lento comparado com as outras opções.
  • Dirsearch (python): Não permite certificados autoassinados, mas permite busca recursiva.
  • Gobuster (go): Permite certificados autoassinados, não possui 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): Esta não é uma spider, mas uma ferramenta que, dada a lista de URLs encontradas, irá deletar URLs "duplicadas".
  • Scavenger: Extensão Burp para criar uma lista de diretórios a partir do histórico burp de diferentes páginas
  • TrashCompactor: Remover URLs com funcionalidades duplicadas (baseado em importações js)
  • Chamaleon: Usa wapalyzer para detectar tecnologias usadas e selecionar as listas de palavras a usar.

Dicionários recomendados:

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

O que verificar em cada arquivo encontrado

  • Verificador de links quebrados: Encontrar links quebrados dentro de HTMLs que podem estar propensos a takeovers
  • Backups de Arquivos: 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.
  • Descobrir novos parâmetros: Você pode usar ferramentas como Arjun, parameth, x8 e Param Miner para descobrir parâmetros ocultos. Se puder, tente buscar parâmetros ocultos em cada arquivo web executável.
  • Todas as listas de palavras padrão do Arjun: 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ê está 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 no fundo da página 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.
  • S3 Buckets: Durante o spidering, veja se algum subdomínio ou link está relacionado com algum S3 bucket. Nesse caso, verifique as permissões do bucket.

Descobertas Especiais

Durante a realização do spidering e força bruta, você pode encontrar coisas interessantes que deve notar.

Arquivos Interessantes

  • Procure por 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 endpoints de API você também deve testá-los. Estes não são arquivos, mas provavelmente "parecerão" com eles.
  • Arquivos JS: Na seção spidering, várias ferramentas que podem extrair caminhos de arquivos JS foram mencionadas. Além disso, seria interessante monitorar cada arquivo JS encontrado, pois em algumas ocasiões, uma mudança pode indicar que uma vulnerabilidade potencial foi introduzida no código. Você poderia usar, por exemplo, JSMon.
  • Você também deve verificar arquivos JS descobertos com RetireJS ou JSHole para encontrar se é vulnerável.
  • 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 de JsFuck (javascript com chars:"[]!+" 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 foram detectados formulários, pois uma mudança no parâmetro ou o aparecimento de um novo formulário pode indicar uma nova funcionalidade potencialmente vulnerável.

403 Proibido/Autenticação Básica/401 Não Autorizado (bypass)

{% content-ref url="403-and-401-bypass

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 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" %}

Aprenda a hackear AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras formas de apoiar o HackTricks: