hacktricks/network-services-pentesting/pentesting-web

80,443 - Metodologia di Pentesting Web

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

• Se vuoi vedere la tua azienda pubblicizzata su HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!
• Ottieni il merchandising ufficiale di PEASS & HackTricks
• Scopri La Famiglia PEASS, la nostra collezione di NFT esclusivi
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @carlospolopm.
• Condividi i tuoi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud github repos.

Se sei interessato alla carriera dell'hacking e vuoi hackerare l'inviolabile - stiamo assumendo! (richiesta competenza in polacco scritto e parlato).

{% embed url="https://www.stmcyber.com/careers" %}

Informazioni di Base

Il servizio web è il servizio più comune ed esteso e esistono molti tipi diversi di vulnerabilità.

Porta predefinita: 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

Guida alle API Web

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

Riassunto della metodologia

In questa metodologia supponiamo che tu stia per attaccare un dominio (o sottodominio) e solo quello. Quindi, dovresti applicare questa metodologia a ciascun dominio, sottodominio o IP scoperto con un server web non determinato all'interno del perimetro.

• Inizia con identificare le tecnologie utilizzate dal server web. Cerca trucchi da tenere a mente durante il resto del test se riesci a identificare con successo la tecnologia.
• Ci sono vulnerabilità conosciute della versione della tecnologia?
• Utilizzando una tecnologia ben nota? Qualche trucco utile per estrarre più informazioni?
• Qualsiasi scanner specializzato da eseguire (come wpscan)?
• Avvia scanner a scopo generale. Non si sa mai se troveranno qualcosa o informazioni interessanti.
• Inizia con i controlli iniziali: robots, sitemap, errore 404 e scansione SSL/TLS (se HTTPS).
• Inizia a spiderizzare la pagina web: È il momento di trovare tutti i possibili file, cartelle e parametri utilizzati. Controlla anche per trovare speciali scoperte.
• Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere spiderizzata.
• Brute-Force delle directory: Prova a forzare tutte le cartelle scoperte cercando nuovi file e directory.
• Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere forzata.
• Controllo dei backup: Verifica se puoi trovare backup dei file scoperti aggiungendo estensioni di backup comuni.
• Forza bruta dei parametri: Prova a trovare parametri nascosti.
• Una volta che hai identificato tutti i possibili punti di accesso che accettano input utente, controlla tutti i tipi di vulnerabilità ad esse correlate.
• Segui questa checklist

Versione del Server (Vulnerabile?)

Identificare

Controlla se ci sono vulnerabilità conosciute per la versione del server in esecuzione.
Gli intestazioni HTTP e i cookie della risposta potrebbero essere molto utili per identificare le tecnologie e/o la versione in uso. La scansione Nmap può identificare la versione del server, ma potrebbero essere utili anche gli strumenti whatweb, webtech o https://builtwith.com/:

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

Cerca vulnerabilità dell'applicazione web versione

Controlla se c'è un WAF

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

Trucchi tecnologici Web

Alcuni trucchi per trovare vulnerabilità in diverse tecnologie ben note in uso:

• AEM - Adobe Experience Cloud
• Apache
• Artifactory
• Buckets
• CGI
• Drupal
• Flask
• Git
• Golang
• GraphQL
• H2 - Java SQL database
• IIS tricks
• JBOSS
• Jenkins
• Jira
• Joomla
• JSP
• Laravel
• Moodle
• Nginx
• PHP (php ha molti trucchi interessanti che potrebbero essere sfruttati)
• Python
• Spring Actuators
• Symphony
• Tomcat
• VMWare
• Web API Pentesting
• WebDav
• Werkzeug
• Wordpress
• Electron Desktop (XSS to RCE)

Tieni presente che lo stesso dominio può utilizzare tecnologie diverse in porte, cartelle e sottodomini diversi.
Se l'applicazione web sta utilizzando una tecnologia/piattaforma nota o qualsiasi altra, non dimenticare di cercare su Internet nuovi trucchi (e fammelo sapere!).

Revisione del codice sorgente

Se il codice sorgente dell'applicazione è disponibile su github, oltre a eseguire un test White box dell'applicazione, ci sono alcune informazioni che potrebbero essere utili per il test Black-Box attuale:

• C'è un file Change-log o Readme o Version o qualcosa con informazioni sulla versione accessibili via web?
• Come e dove vengono salvate le credenziali? C'è un file (accessibile?) con credenziali (nomi utente o password)?
• Le password sono in testo normale, criptate o quale algoritmo di hash viene utilizzato?
• Sta utilizzando una chiave principale per crittografare qualcosa? Quale algoritmo viene utilizzato?
• Puoi accedere a uno di questi file sfruttando qualche vulnerabilità?
• Ci sono informazioni interessanti su github (risolte e non risolte) issues? O nella cronologia dei commit (forse una password introdotta in un vecchio commit)?

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

Scanner automatici

Scanner automatici a uso generale

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"

Scanner CMS

Se viene utilizzato un CMS non dimenticare di eseguire uno scanner, forse si trova qualcosa di interessante:

Clusterd: JBoss, ColdFusion, WebLogic, Tomcat, Railo, Axis2, Glassfish
CMSScan: siti web WordPress, Drupal, Joomla, vBulletin per problemi di sicurezza. (GUI)
VulnX: Joomla, Wordpress, Drupal, PrestaShop, Opencart
CMSMap: (W)ordpress, (J)oomla, (D)rupal o (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

A questo punto dovresti già avere alcune informazioni sul server web utilizzato dal cliente (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato, potresti aver anche trovato un CMS e eseguito una scansione.

Scoperta dell'applicazione Web passo dopo passo

Da questo punto inizieremo a interagire con l'applicazione web.

Controlli iniziali

Pagine predefinite con informazioni interessanti:

• /robots.txt
• /sitemap.xml
• /crossdomain.xml
• /clientaccesspolicy.xml
• /.well-known/
• Controlla anche i commenti nelle pagine principali e secondarie.

Forzare errori

I server web possono comportarsi in modo imprevisto quando vengono inviati loro dati strani. Ciò potrebbe aprire vulnerabilità o rivelare informazioni sensibili.

• Accedi a pagine fittizie come /qualsiasifake.php (.aspx,.html,.ecc)
• Aggiungi "[]", "]]" e "[[" nei valori dei cookie e nei valori dei parametri per creare errori
• Genera errori inserendo input come /~randomthing/%s alla fine dell'URL
• Prova diversi verbi HTTP come PATCH, DEBUG o sbagliati come FAKE

Verifica se puoi caricare file (verbo PUT, WebDav)

Se scopri che WebDav è abilitato ma non hai abbastanza autorizzazioni per caricare file nella cartella principale, prova a:

• Forzare le credenziali
• Caricare file tramite WebDav al resto delle cartelle trovate all'interno della pagina web. Potresti avere autorizzazioni per caricare file in altre cartelle.

Vulnerabilità SSL/TLS

• Se l'applicazione non forza l'uso di HTTPS in nessuna parte, allora è vulnerabile a MitM
• Se l'applicazione invia dati sensibili (password) tramite HTTP. Allora è una vulnerabilità elevata.

Utilizza testssl.sh per verificare le vulnerabilità (nei programmi Bug Bounty probabilmente queste vulnerabilità non saranno accettate) e utilizza a2sv per ricontrallare le vulnerabilità:

./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>

Informazioni sulle vulnerabilità di SSL/TLS:

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

Spidering

Lancia una sorta di spider all'interno del web. L'obiettivo del ragno è trovare il maggior numero possibile di percorsi dall'applicazione testata. Pertanto, il crawling web e le fonti esterne dovrebbero essere utilizzati per trovare il maggior numero possibile di percorsi validi.

• gospider (go): ragno HTML, LinkFinder nei file JS e fonti esterne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
• hakrawler (go): ragno HML, con LinkFider per i file JS e Archive.org come fonte esterna.
• dirhunt (python): ragno HTML, indica anche "file juicy".
• evine (go): ragno HTML interattivo CLI. Cerca anche in Archive.org
• meg (go): Questo strumento non è un ragno ma può essere utile. Puoi semplicemente indicare un file con host e un file con percorsi e meg recupererà ogni percorso su ogni host e salverà la risposta.
• urlgrab (go): ragno HTML con capacità di rendering JS. Tuttavia, sembra non essere mantenuto, la versione precompilata è vecchia e il codice attuale non si compila
• gau (go): ragno HTML che utilizza fornitori esterni (wayback, otx, commoncrawl)
• ParamSpider: Questo script troverà URL con parametri e li elencherà.
• galer (go): ragno HTML con capacità di rendering JS.
• LinkFinder (python): ragno HTML, con capacità di bellezza JS in grado di cercare nuovi percorsi nei file JS. Potrebbe valere la pena dare un'occhiata anche a JSScanner, che è un wrapper di LinkFinder.
• goLinkFinder (go): Per estrarre endpoint sia nella sorgente HTML che nei file javascript incorporati. Utile per cacciatori di bug, red teamers, ninja della sicurezza informatica.
• JSParser (python2.7): Uno script python 2.7 che utilizza Tornado e JSBeautifier per analizzare URL relativi dai file JavaScript. Utile per scoprire facilmente le richieste AJAX. Sembra non essere mantenuto.
• relative-url-extractor (ruby): Dato un file (HTML) estrarrà gli URL da esso utilizzando una nifty espressione regolare per trovare ed estrarre gli URL relativi dai file brutti (minify).
• JSFScan (bash, diversi strumenti): Raccogli informazioni interessanti dai file JS utilizzando diversi strumenti.
• subjs (go): Trova file JS.
• page-fetch (go): Carica una pagina in un browser headless e stampa tutti gli URL caricati per caricare la pagina.
• Feroxbuster (rust): Strumento di scoperta del contenuto che combina diverse opzioni degli strumenti precedenti
• Javascript Parsing: Un'estensione di Burp per trovare percorsi e parametri nei file JS.
• Sourcemapper: Uno strumento che, dato l'URL .js.map, otterrà il codice JS beatificato
• xnLinkFinder: Questo è uno strumento utilizzato per scoprire endpoint per un determinato target.
• waymore: Scopri i collegamenti dalla macchina del passato (scaricando anche le risposte nella macchina del passato e cercando altri collegamenti
• HTTPLoot (go): Crawla (anche riempiendo moduli) e trova anche informazioni sensibili utilizzando espressioni regolari specifiche.
• SpiderSuite: Spider Suite è un avanzato Crawler/Spider GUI multi-feature progettato per professionisti della sicurezza informatica.
• jsluice (go): È un pacchetto Go e strumento da riga di comando per estrarre URL, percorsi, segreti e altri dati interessanti dal codice sorgente JavaScript.
• ParaForge: ParaForge è una semplice estensione di Burp Suite per estrarre i parametri e gli endpoint dalla richiesta per creare un elenco di parole personalizzato per fuzzing e enumerazione.
• katana (go): Strumento fantastico per questo.

Forza bruta su directory e file

Inizia a forzare la ricerca dalla cartella radice e assicurati di forzare la ricerca su tutte le directory trovate utilizzando questo metodo e tutte le directory scoperte dal Spidering (puoi fare questa forza bruta in modo ricorsivo e aggiungendo all'inizio della wordlist utilizzata i nomi delle directory trovate).
Strumenti:

• Dirb / Dirbuster - Incluso in Kali, vecchio (e lento) ma funzionale. Consente certificati auto-firmati e ricerca ricorsiva. Troppo lento rispetto alle altre opzioni.
• Dirsearch (python): Non consente certificati auto-firmati ma consente la ricerca ricorsiva.
• Gobuster (go): Consente certificati auto-firmati, non ha la ricerca ricorsiva.
• Feroxbuster - Veloce, supporta la ricerca ricorsiva.
• wfuzz wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ
• ffuf - Veloce: ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ
• uro (python): Questo non è un ragno ma uno strumento che, dato l'elenco degli URL trovati, eliminerà gli URL "duplicati".
• Scavenger: Estensione di Burp per creare un elenco di directory dalla cronologia di burp di diverse pagine
• TrashCompactor: Rimuove gli URL con funzionalità duplicate (basato su importazioni js)
• Chamaleon: Utilizza wapalyzer per rilevare le tecnologie utilizzate e selezionare le wordlist da utilizzare.

Dizionari consigliati:

• https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt
• Dizionario incluso in Dirsearch
• http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10
• Wordlists di 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
• https://github.com/ayoubfathi/leaky-paths
• /usr/share/wordlists/dirb/common.txt
• /usr/share/wordlists/dirb/big.txt
• /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere sottoposta a Brute-Force.

Cosa controllare su ogni file trovato

• Verifica dei link rotti: Trova i link rotti all'interno degli HTML che potrebbero essere vulnerabili agli attacchi di takeover
• Backup dei file: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili (".php", ".aspx"...). Le variazioni comuni per nominare un backup sono: file.ext~, #file.ext#, ~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old. Puoi anche utilizzare lo strumento bfac o backup-gen.
• Scopri nuovi parametri: Puoi utilizzare strumenti come Arjun, parameth, x8 e Param Miner per scoprire parametri nascosti. Se possibile, potresti provare a cercare parametri nascosti in ogni file web eseguibile.
• Tutti i wordlist predefiniti di 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
• Commenti: Controlla i commenti di tutti i file, potresti trovare credenziali o funzionalità nascoste.
• Se stai giocando a CTF, un "trucco" comune è nascondere informazioni nei commenti alla destra della pagina (usando centinaia di spazi in modo che non si vedano i dati se apri il codice sorgente con il browser). Un'altra possibilità è utilizzare diverse righe vuote e nascondere informazioni in un commento in fondo alla pagina web.
• Chiavi API: Se trovi qualche chiave API c'è una guida che indica come utilizzare le chiavi API di piattaforme diverse: keyhacks, zile, truffleHog, SecretFinder, RegHex, DumpsterDive, EarlyBird
• Chiavi API di Google: Se trovi una chiave API che assomiglia a AIzaSyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto gmapapiscanner per verificare a quali API la chiave può accedere.
• Bucket S3: Durante lo spidering, controlla se qualche sottodominio o qualche link è collegato a un bucket S3. In tal caso, controlla i permessi del bucket.

Scoperte speciali

Mentre esegui lo spidering e il brute-forcing potresti trovare cose interessanti che devi notare.

File interessanti

• Cerca link ad altri file all'interno dei file CSS.
• Se trovi un file .git è possibile estrarre alcune informazioni
• Se trovi un file .env potrebbero essere presenti informazioni come chiavi API, password dei database e altre informazioni.
• Se trovi endpoint API dovresti testarli anche. Questi non sono file, ma probabilmente "sembreranno" tali.
• File JS: Nella sezione di spidering sono stati menzionati diversi strumenti che possono estrarre percorsi dai file JS. Inoltre, sarebbe interessante monitorare ogni file JS trovato, poiché in alcune occasioni, una modifica potrebbe indicare l'introduzione di una potenziale vulnerabilità nel codice. Potresti utilizzare ad esempio JSMon.
• Dovresti anche controllare i file JS scoperti con RetireJS o JSHole per verificare se sono vulnerabili.
• Deobfuscator e Unpacker Javascript: https://lelinhtinh.github.io/de4js/, https://www.dcode.fr/javascript-unobfuscator
• Javascript Beautifier: http://jsbeautifier.org/, http://jsnice.org/
• Deobfuscation JsFuck (javascript con caratteri:"[]!+" https://ooze.ninja/javascript/poisonjs/)
• TrainFuck: +72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.
• In diverse occasioni sarà necessario comprendere le espressioni regolari utilizzate, questo sarà utile: https://regex101.com/
• Potresti anche monitorare i file in cui sono stati rilevati moduli, poiché una modifica nei parametri o l'aggiunta di un nuovo modulo potrebbero indicare una potenziale nuova funzionalità vulnerabile.

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 una pagina risponde con quel codice, probabilmente è un proxy mal configurato. Se invii una richiesta HTTP come: GET https://google.com HTTP/1.1 (con l'intestazione host e altre intestazioni comuni), il proxy cercherà di accedere a google.com e avrai trovato un SSRF.

Autenticazione NTLM - Divulgazione informazioni

Se il server in esecuzione che richiede l'autenticazione è Windows o trovi un login che chiede le tue credenziali (e chiede il nome del dominio), puoi provocare una divulgazione di informazioni.
Invia l'intestazione: “Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=” e a causa del funzionamento dell'autenticazione NTLM, il server risponderà con informazioni interne (versione di IIS, versione di Windows...) all'interno dell'intestazione "WWW-Authenticate".
Puoi automatizzare questo utilizzando il plugin nmap "http-ntlm-info.nse".

Reindirizzamento HTTP (CTF)

È possibile inserire contenuti all'interno di un reindirizzamento. Questo contenuto non verrà mostrato all'utente (poiché il browser eseguirà il reindirizzamento), ma potrebbe essere nascosto al suo interno.

Controllo delle Vulnerabilità Web

Ora che è stata eseguita un'enumerazione completa dell'applicazione web, è il momento di verificare molte possibili vulnerabilità. Puoi trovare la checklist qui:

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

Trova ulteriori informazioni sulle vulnerabilità web in:

• https://six2dez.gitbook.io/pentest-book/others/web-checklist
• 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

Monitorare le Pagine per i Cambiamenti

Puoi utilizzare strumenti come https://github.com/dgtlmoon/changedetection.io per monitorare le pagine per le modifiche che potrebbero inserire vulnerabilità.

Se sei interessato a una carriera nel campo dell'hacking e a violare l'invulnerabile - stiamo assumendo! (richiesta competenza fluente in polacco, scritta e parlata).

{% embed url="https://www.stmcyber.com/careers" %}

Comandi Automatici di 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}

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

• Se desideri vedere la tua azienda pubblicizzata su HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!
• Ottieni il merchandising ufficiale di PEASS & HackTricks
• Scopri La Famiglia PEASS, la nostra collezione di NFT esclusivi
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @carlospolopm.
• Condividi i tuoi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud repos di github.