Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-18 17:16:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/README.md
Translator workflow c928d8e52e Translated to Portuguese
2023-06-06 18:56:34 +00:00

30 KiB
Raw Blame History

80,443 - Metodologia de Pentesting Web

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

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 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ê 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 descoberto com servidor web indeterminado dentro do escopo.

  • Comece identificando as tecnologias usadas pelo servidor web. Procure por tricks para lembrar durante o resto do teste se você puder identificar com sucesso a tecnologia.
    • Alguma vulnerabilidade conhecida da 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 spidering da página da web: é hora de encontrar todos os possíveis arquivos, pastas e parâmetros sendo usados. Além disso, verifique descobertas especiais.
    • Observe que sempre que um novo diretório é descoberto durante a força bruta ou spidering, ele deve ser spidered.
  • Força bruta de diretórios: Tente forçar a força bruta em todas as pastas descobertas procurando por novos arquivos e diretórios.
    • Observe que sempre que um novo diretório é descoberto durante a força bruta ou spidering, ele deve ser forçado.
  • Verificação de backups: Teste se você pode encontrar backups de arquivos descobertos adicionando extensões de backup comuns.
  • Força bruta de parâmetros: Tente encontrar parâmetros ocultos.
  • Depois de identificar todos os possíveis endpoints que aceitam entrada do usuário, verifique todos os tipos de vulnerabilidades relacionadas a ele.

Versão do servidor (Vulnerável?)

Identificar

Verifique se existem vulnerabilidades conhecidas para a versão do servidor que está sendo executada.
Os cabeçalhos HTTP e cookies da resposta podem ser muito úteis para identificar as tecnologias e/ou versão sendo usadas. 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 da web

Alguns truques para encontrar vulnerabilidades em diferentes tecnologias bem conhecidas sendo usadas:

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 alguma tecnologia/plataforma conhecida listada anteriormente ou qualquer outra, não se esqueça de pesquisar na Internet novos truques (e me informe!).

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 de caixa branca da aplicação por conta própria, há algumas informações que podem ser úteis para o teste de caixa preta 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 são salvos as credenciais? 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 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 (resolvida e não resolvida) issues? Ou no histórico de commits (talvez alguma senha introduzida dentro de 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: sites WordPress, Drupal, Joomla, 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 alguma informação sobre o servidor web usado pelo cliente (se houver dados disponíveis) e algumas dicas a serem lembradas durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner.

Descoberta de aplicativos da web passo a passo

A partir deste ponto, vamos começar a interagir com o aplicativo da 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

Os servidores da web podem comportar-se de forma inesperada quando dados estranhos são enviados a eles. Isso pode abrir vulnerabilidades ou divulgar informações confidenciais.

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

Verifique se você pode 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ça bruta de credenciais
  • Carregue arquivos via WebDav para o resto das pastas encontradas dentro da página da 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 confidenciais (senhas) usando HTTP. Então é uma vulnerabilidade alta.

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

Spidering

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

  • 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. Ele também procura 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 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 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 JS.
  • LinkFinder (python): spider HTML, com capacidades de embelezamento JS capazes de pesquisar novos caminhos em arquivos JS. Também pode valer a pena dar uma olhada no JSScanner, que é um invólucro do LinkFinder.
  • goLinkFinder (go): Para extrair endpoints em ambos os arquivos de origem HTML e javascript incorporados. Útil para caçadores de bugs, red teamers, 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 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 (minify).
  • JSFScan (bash, várias ferramentas): Reúna informações interessantes de arquivos JS usando várias ferramentas.
  • subjs (go): Encontre arquivos JS.
  • page-fetch (go): Carregue uma página em um navegador sem cabeça e imprima 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 do Burp para encontrar caminhos e parâmetros em arquivos JS.
  • Sourcemapper: Uma ferramenta que, dada a URL .js.map, obterá o código JS beatificado
  • xnLinkFinder: Esta é uma ferramenta usada para descobrir endpoints para um determinado alvo.
  • waymore: Descubra links do wayback machine (também baixando as respostas no wayback e procurando mais links
  • HTTPLoot (go): Rastreie (até mesmo preenchendo formulários) e também encontre informações confidenciais usando regexes específicos.
  • SpiderSuite: Spider Suite é um avançado Crawler/Spider de segurança na web GUI multi-características projetado para profissionais de segurança cibernética.

Brute Force de diretórios e arquivos

Inicie a força bruta a partir da pasta raiz e certifique-se de forçar a entrada em todos os diretórios encontrados usando este método e todos os diretórios descobertos pelo Spidering (você pode fazer essa força bruta recursivamente 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 tem 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, excluirá URLs "duplicadas".
  • Scavenger: Extensão do Burp para criar uma lista de diretórios do histórico do burp de diferentes páginas
  • TrashCompactor: Remova URLs com funcionalidades duplicadas (com base em importações js)
  • Chamaleon: Usa o wapalyzer para detectar as tecnologias usadas e selecionar as listas de palavras a serem usadas.

Dicionários recomendados:

O que verificar em cada arquivo encontrado

  • Verificador de links quebrados: Encontre links quebrados dentro de HTMLs que podem ser propensos a 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 procurar parâmetros ocultos em cada arquivo web executável.
  • 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 no lado direito 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: Durante a spidering, verifique se algum subdomínio ou qualquer link está relacionado a algum bucket S3. Nesse caso, verifique as permissões do bucket.

Descobertas especiais

Enquanto realiza a spidering e força bruta, você pode encontrar coisas interessantes que deve 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 da API, você também deve testá-los. Estes não são arquivos, mas provavelmente "parecerão" com eles.
  • Arquivos JS: Na seção de spidering, foram mencionadas várias ferramentas que podem extrair caminhos de arquivos JS. Também 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ê pode usar, por exemplo, JSMon.
  • Você também pode monitorar os arquivos onde os formulários foram detectados, pois uma mudança no parâmetro ou o aparecimento de um novo formulário pode indicar uma nova funcionalidade vulnerável potencial.

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 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 Windows ou se você encontrar um login solicitando suas credenciais (e pedindo o nome do 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...)

Monitorar páginas para mudanças

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 do 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: inscreva-se no Intigriti, uma plataforma premium de recompensas 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 🎥