LinPEAS vs WinPEAS: Privilege Escalation Enumeration

Compare LinPEAS and WinPEAS for privilege escalation enumeration: what each collects, how the colouring works, which findings actually matter, and the detection and authorisation risks of running either.

Short answer: They are the same tool for two operating systems, so the comparison is not "which is better" but "what each one can and cannot see". LinPEAS reads files, permissions and scheduled jobs on Linux; WinPEAS queries registry hives, services and token privileges on Windows. Neither escalates anything - both produce a long, colour-coded list of things a human still has to read.

Executive Verdict: When to Choose Each

Choose LinPEAS (Linux) if…

Best for Linux post-exploitation enumeration: SUID and capabilities, sudo rules, cron and systemd timers, writable paths, container escapes, credential files and keys, plus a fast mode that skips the slow filesystem sweeps.

Choose WinPEAS (Windows) if…

Best for Windows enumeration: service binary permissions, unquoted service paths, token privileges such as SeImpersonatePrivilege, AlwaysInstallElevated, stored credentials, autologon registry values and scheduled tasks.

Feature-by-Feature Technical Matrix

Dimension LinPEAS (Linux) WinPEAS (Windows)
Runs on Linux - a bash script assembled from many small checks Windows - a .NET executable, with a PowerShell script alternative
What it needs A shell, and preferably an execution method that leaves no file behind A shell; the executable is often dropped to disk, which is a detection event
Typical output Thousands of lines, colour-coded by how exploitable each finding is usually considered The same idea, with sections for services, tokens, registry and credentials
Coverage: users Local users, groups, sudo rules, home directory permissions Local accounts, group membership, logon sessions, token privileges
Coverage: files SUID/SGID binaries, capabilities, world-writable files and directories Service binaries and their ACLs, unquoted paths, writable Program Files paths
Coverage: scheduled work cron jobs, systemd units and timers, at jobs Scheduled tasks, services with weak start permissions
Coverage: credentials SSH keys, .git-credentials, history files, config with passwords, cloud metadata Credential Manager entries, autologon values, unattend.xml, group policy preferences
Container awareness Flags broken container boundaries, mounted sockets, privileged containers Not the primary use case
Hard mode Optional, exhaustive, much slower and much louder The default output is already verbose
What it cannot do Exploit anything. It reports; you still have to reason, and verify Same - a red line means "worth testing", not "vulnerable"
Main risk A production host notices: file reads, process spawns and network callbacks are all visible The same, plus the dropped binary is a strong signature for endpoint tools

The colours are a starting point, not a finding list

Both tools colour their output, and the convention is widely misread. Red means "this often leads somewhere", not "this is exploitable". A world-writable file inside a directory the current user cannot traverse is usually useless. A SUID binary that only calls execv on a path you cannot write is a dead end.

The practical consequence is that a PEAS run is not a scan result you can paste into a report. It is a search index. The work is opening the red lines one at a time and asking the only question that matters: can I control anything this binary or service reads, executes or loads?

Experienced testers run PEAS with a narrowed focus - one section at a time, or in the fast mode that skips the expensive filesystem walk - precisely because reading everything at once produces a list too long to reason about.

Where the two diverge

On Linux, privilege escalation is largely about files: which ones are set-uid, which directories are writable by your user, which cron job runs as root and reads from a path you can write to. That is why LinPEAS spends most of its output on filesystem facts, and why capabilities - a detail older checklists ignore entirely - get their own section.

On Windows, it is largely about configuration and privilege: a service that starts from an unquoted path with a space in it, an installer that runs as SYSTEM regardless of who invokes it, a token that already carries an impersonation privilege the documentation calls dangerous. WinPEAS organises its output around those, which is why its sections look like a checklist of Windows hardening failures rather than a filesystem inventory.

Neither tool can see what it was not designed to see. LinPEAS will not tell you a Windows domain trusts an unconstrained delegation; WinPEAS will not read a Linux sudoers file. On a mixed network the answer is not to pick a winner - it is to know which host you are on.

Running either one safely and lawfully

Both tools are noisy by nature. On the Linux side, the script spawns a large number of short-lived processes, walks the filesystem and may attempt outbound lookups; on the Windows side, the executable is dropped to disk and scanned. Any competent endpoint protection or SIEM will produce alerts, which is fine in a lab and a problem in production.

That matters twice over. Technically, a scan that gets you blocked or the service degraded is a failed assessment. Legally, running an enumeration script against a host you do not own is unauthorised access in most jurisdictions, whether or not anything is exploited - the tool does not need to succeed at privilege escalation to be a problem.

If you are learning, use your own virtual machines. Metasploitable, the published Hack The Box and TryHackMe labs, and a local Windows VM with weak configuration are enough to see what real output looks like.

Side-by-Side CLI & Operational Workflow

LinPEAS (Linux) Example

# Standard run to a file, then read it back locally
./linpeas.sh -a > linpeas-full.txt 2>/dev/null

# Fast pass: skip the slow filesystem sweeps first
timeout 180 ./linpeas.sh -o system_information,software_information,container -q

WinPEAS (Windows) Example

# Run WinPEAS and write a readable report
.\winPEASx64.exe > winpeas.txt 2>&1

# Narrow the scope to the sections that usually pay
.\winPEASx64.exe servicesinfo userinfo > winpeas-targeted.txt

Frequently Asked Questions

Are LinPEAS and WinPEAS the same project?

Yes - both are part of PEASS-ng, maintained together. LinPEAS is the bash script for Linux and WinPEAS is the compiled tool for Windows, but the philosophy is identical: collect everything that might matter and colour it by how often it matters.

Does a red line mean I have root or SYSTEM?

No. It means the condition commonly appears in real escalations. Most red lines cannot be turned into an escalation on a given host, because some other permission blocks the path. Treat each one as a hypothesis to test, not a result to report.

Why is the output so long?

Because it is a search index, not a summary. Both tools err toward showing everything rather than missing the one finding that matters. Use the section flags to run one category at a time and the output becomes readable.

Will PEAS get me caught during an authorised test?

Very likely, yes. Expect a large number of process spawns on Linux and a dropped binary on Windows. Agree with the client in advance which systems may be enumerated and when, because "it was only enumeration" is not a defence if it was not in scope.

Can I run these against production?

Only with explicit written authorisation, a defined maintenance window, and a plan for the alerts it will raise. The scripts read protected files and spawn hundreds of processes; on a busy system that is enough to break something unrelated.


Related Tools, Cheat Sheets & Comparisons