PEASS-ng — Finding Privilege Escalation, systematically

LinPEAS, WinPEAS & co.: the standard suite of penetration testing – and an underrated helper for hardening your own systems
· Pentesting · Linux · Windows · AI-assisted
Isometric 3D illustration: an abstract PEASS-ng platform with Linux and Windows screens for LinPEAS and WinPEAS output
AI-generated illustration: PEASS-ng as a platform for LinPEAS and WinPEAS scans.

What is PEASS-ng?

If you work in penetration testing, you know the situation: you have access to a system – as an unprivileged user. Now the actual work begins: privilege escalation. Is there a misconfigured SUID binary? An exploitable capability? A weak sudo setup? A forgotten password in some config file?

That is exactly what PEASS-ng – “Privilege Escalation Awesome Scripts SUITE, new generation” – is for. The suite is the direct successor of the PEAS project started by Carlos Polop in 2019 and is now maintained by the GitHub organization peass-ng. It is tightly woven into the HackTricks ecosystem (book.hacktricks.xyz), which documents the matching exploitation technique for every finding.

With more than 20,700 GitHub stars and roughly 3,400 forks (as of November 2026), PEASS-ng is among the most widely used tools in offensive security. It is integrated into Kali Linux, was showcased at Black Hat Arsenal Asia 2020, and is used in countless CTFs and training courses. Full disclosure: it is one of my favourite tools – so here is an in-depth look.

Screenshot of the PEASS-ng repository page on GitHub showing the linPEAS and winPEAS folders
Screenshot of the PEASS-ng repository page (as of November 2026).

The suite at a glance

The idea behind PEASS-ng is simple and powerful: instead of running dozens of checks manually, one script run produces a colour-coded map of all local privilege escalation paths on the target – ranked by likelihood of success.

LinPEAS

Bash script for Linux/Unix: a one-liner, no installation required.

WinPEAS

C#/.NET binary or batch for Windows: winPEASx64.exe, winPEASx86.exe, winPEAS.bat.

MacPEAS

Privilege escalation checks for macOS systems as well.

Parsers & output

Output can be converted to JSON, HTML and PDF – for reports and automation.

ToolPlatformRun asRelease file
LinPEASLinux / UnixStandard user (root optional)linpeas.sh
WinPEASWindowsStandard user (admin optional)winPEASx64.exe, winPEAS.bat
MacPEASmacOSStandard usermacPEAS.sh

The tools are available as individual scripts in the repository; the latest executable versions can always be found on the releases page – they are rebuilt almost daily.

LinPEAS — Linux with one command

LinPEAS is a single Bash script and therefore the classic pick for any Linux server. It checks, among other things, for:

  • SUID/SGID binaries and exploitable Linux capabilities
  • sudo configuration: commented permissions, NOPASSWD entries, exploitable attack paths (e. g. via sudoedit)
  • Scheduled tasks: cron, systemd timers, file permissions on them
  • PATH hijacking and LD_PRELOAD opportunities
  • Writable files outside your own directory
  • Plaintext passwords in configs, shell history, environment variables and backups
  • Known vulnerable installed software – including hints about existing exploits
  • Risky group memberships such as docker, sudo or lxd

The fastest way to a first result is a one-liner straight from the releases – no installation:

# One-liner: downloads linpeas.sh and executes it directly
curl -L https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh | sh
LinPEAS run on a test system – as a demo, anonymized.

The script works with sh, bash, zsh and ash; if you prefer, you can download the file first and review it. Useful options:

  • -a – run all checks (slower, more thorough)
  • -r / -s – very fast, buffered checks
  • -q – quieter mode, less noise
  • -j – JSON output for further processing
Important in practice: LinPEAS runs as the current user – no root required for the first scan. That is exactly the position a real attacker is in, and exactly what we want to model.

WinPEAS — Windows

On Windows, WinPEAS takes over this job. Depending on the target platform there is winPEASx64.exe, winPEASx86.exe or a universal any-binary, plus a pure batch variant winPEAS.bat for cases where no compiled binary is available or wanted. WinPEAS checks, among other things, for:

  • Weak file permissions on services and unquoted service paths
  • AlwaysInstallElevated – allows unprivileged MSI installs as SYSTEM
  • Stored credentials: AutoLogon, Windows Credential Manager, registry
  • Token and impersonation opportunities (Potato techniques and others)
  • Modifiable DLLs and binaries of running services
  • Missing security updates and known exploit candidates

There is a convenient one-liner for the command prompt here as well:

# One-liner: download to temp and execute (cmd)
cmd /c "curl -L -o %TEMP%\winPEASx64.exe https://github.com/peass-ng/PEASS-ng/releases/latest/download/winPEASx64_ofs.exe && %TEMP%\winPEASx64.exe"
A note on Windows: Defender will often flag a compiled .exe from the internet. If you want to raise less suspicion, use the batch variant winPEAS.bat – it is slower, but transparent and fully readable in source code.

Reading the output — the colour language

The real masterstroke of PEASS-ng is its colour-coded output. Instead of a wall of text you get a prioritized list:

  • Red – very likely exploitable issue, look at it right away
  • Yellow – configuration worth checking; context decides
  • Green – security feature that is enabled (or hints about what you have enabled)
  • Light blue – user and system information
  • White – neutral information

This way you can tell at a glance where the work pays off – instead of manually sifting through hundreds of lines of log output. The script even detects false positives reported by many scanners and marks many well-known default configurations as harmless.

Why it helps admins too

PEASS-ng is an attack tool – but that makes it one of the best hardening tools I know. The simple idea: an attacker will use this suite quickly once they get in anywhere. So if I run the same checks on my own servers, I see in advance what an attacker would see.

Isometric 3D illustration of the hardening workflow: check, evaluate, harden
My hardening workflow, as an AI-generated illustration: check – evaluate – harden.
My workflow: after setting up a new system, run PEAS once as a normal user, fix all red findings, then repeat – until the output turns “green”. This often takes under an hour per system and hardens exactly where it matters.

Especially in a homelab with Docker, self-hosted services and many users, typical candidates lurk: writable scripts running as root via cron, containers accessible to a weakly configured group, or binaries with unnecessary capabilities. PEASS-ng makes exactly these things visible.

Legal framework: These scripts are intended for authorized penetration tests and training purposes only. Use them on other people’s systems only with the explicit permission of the operator – and be careful when testing your own infrastructure in production: validating real exploit paths belongs in a controlled environment.

My verdict: PEASS-ng is a tool you simply need to know – from both the attacker’s and the defender’s perspective. The suite is free, runs without installation and delivers an honest snapshot of a system in minutes.

Sources

Technical statements refer to the state as of November 1, 2026. The illustrations in this article are AI-generated symbolic images; the GitHub screenshot shown is for illustration purposes.