mrkeyoor.com_
Thu 10 Sept 07:03 UTC
Dev Toolsevaluationupdated 10 Sept 2026

PEASS-ng review

PEASS-ng is a suite of local privilege-escalation enumerators for Linux, Unix, macOS, and Windows. LinPEAS and WinPEAS inspect a host for permissions, credentials, services, software, and configuration mistakes that may give an authorized tester a route to higher privileges; optional parsers turn their colored output into JSON, HTML, or PDF.

Verdict

Our PEASS-ng run installed 35 packages in 18 seconds and built in 8 seconds, but there was no test target for the lab to run. Use the release artifacts for authorized host enumeration when an experienced tester will review both the commands and the findings. Skip it for unattended fleet scanning, proprietary output ingestion without license review, or any engagement where noisy credential and network checks are outside scope.

We ran it

Lab card: what happened when we ran PEASS-ngScreenshot of PEASS-ng (book.hacktricks.xyz)
Install✓ · 18s35 packages · 37 MB
Build✓ · 8s
Testsn/ano test script
Known vulns0(pip-audit)
Repo1577 files~289,466 lines of source · 33.2 MB · 7 CI workflows

Answers from our run

Does PEASS-ng build from source?

Dependencies installed in 18 seconds (35 packages), and the build succeeded in 8 seconds. We cloned commit 8e0aabe into a clean Debian container with 3 CPUs and no project-specific setup.

Does PEASS-ng have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does PEASS-ng have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use PEASS-ng?

Anyone without the system owner's permission: the project limits use to authorized penetration testing, education, and machines or networks you own.

What are the alternatives to PEASS-ng?

Linux Smart Enumeration, LinEnum, PrivescCheck. Our PEASS-ng run installed 35 packages in 18 seconds and built in 8 seconds, but there was no test target for the lab to run.

Setup4/518-second install; release artifacts avoid a source build
Docs4/5Flags and tool variants are clear; report handling needs care
Community5/520,492 stars and current releases with active CI work
Maturity3/5Broad field use, but our lab found no test target

Who it’s for

Penetration testers with written authorization to inspect Linux, macOS, or Windows hosts for local escalation paths.
Defenders reproducing an attacker's local view during a controlled hardening review.
Consultants who want release-ready scripts and binaries plus links explaining the checks.
Operators who can choose targeted LinPEAS checks and protect reports that may contain credentials or system details.

Who it’s NOT for

Anyone without the system owner's permission: the project limits use to authorized penetration testing, education, and machines or networks you own.
Quiet production assessments using LinPEAS -a or -r: the docs say intensive mode can brute-force users with su, while regex mode searches the filesystem for hundreds of API-key patterns.
Buyers expecting verified exploits or a prioritized remediation report: PEASS finds possible paths and color-codes suspicious findings; the operator still has to confirm risk and decide what to fix.
Proprietary products that will embed PEASS or parse its output without legal review: the license says the project treats those integrations as derived works and offers a separate commercial license.
Teams requiring a conventional local test command before adoption: our harness found no tests script or target, so it could not run a suite.

Setup reality

Our PEASS-ng checkout installed 35 Python packages in 18 seconds and used 37 MB on disk. The build succeeded in 8 seconds. No tests script or target was available, so the test step was skipped; pip-audit reported 0 known vulnerabilities. The 33.2 MB checkout had 1,577 files and about 289,466 source lines.

The released LinPEAS shell script needs no hosted credential, and WinPEAS ships as batch, PowerShell, and .NET variants; the C# build requires .NET 4.5.2 or newer. You must still obtain permission, move the chosen artifact onto the target, capture its output safely, and bring Python 3 if you want the included JSON, HTML, or PDF parsers.

LinPEAS modes change the risk. The default script is broad, the small build limits checks, and the fat build embeds third-party tools. Intensive options may read many files, search for secrets, try passwords, monitor processes, write temporary data, or scan the network. Select checks explicitly on sensitive systems, and treat the resulting report as confidential.

PEASS-ng enumerates escalation paths instead of exploiting them

PEASS-ng packages two main families: LinPEAS for Linux, Unix, and macOS, plus WinPEAS for Windows. They inspect the local machine for permissions, users, processes, services, software, scheduled work, files, and configuration that may expose a privilege-escalation route. Findings are grouped and color-coded, with links into HackTricks for explanation. The result is a fast way for a qualified tester to gather leads after obtaining access to a host.

The distinction between a lead and proof matters. LinPEAS says red and yellow marks a configuration it considers highly likely to lead to escalation, while red alone is suspicious. Neither color is a verified exploit or a business-impact rating. A tester must reproduce the path, account for compensating controls, and write the remediation. PEASS-ng saves enumeration time; it does not replace judgment or turn raw terminal output into a defensible finding.

The release offers separate Linux and Windows artifacts

The September 8, 2026 release includes LinPEAS shell variants, Linux binaries for several architectures, macOS binaries, a WinPEAS batch file, and multiple Windows executables. LinPEAS can run as /bin/sh source or as a binary. WinPEAS also has C#, PowerShell, and batch projects, with .NET 4.5.2 or newer required for the executable project. That range is useful when a target lacks a compiler or blocks one interpreter.

Choosing the artifact is part of the engagement plan. The standard LinPEAS script includes the usual checks and an embedded Linux exploit suggester. The fat variant embeds all checks and third-party applications, while the small script keeps only selected high-value checks. The project also lets users build a custom LinPEAS with chosen sections. On a sensitive server, a reviewed custom set is easier to justify than copying the largest script and hoping every command is acceptable.

What happened when we ran it

Our sandbox installed 35 Python packages in 18 seconds and left 37 MB on disk. The build then succeeded in 8 seconds. Pip-audit found 0 known vulnerabilities in the installed dependency set. These are clean repository mechanics for commit 8e0aabe in an unprivileged Debian container with 3 CPUs and 8 GB of RAM. They say nothing about whether a particular target permits or safely handles every enumeration flag.

The test step was skipped because our harness found no tests script or target. There was also no tests directory in the 1,577-file checkout. That absence is worth separating from an outright failure: the lab did not receive a suite it could execute, so there is no passing test result to report. The repository did contain 7 CI workflow files, and the sole open item was a pull request addressing a named CI master-test failure.

At roughly 289,466 source lines and 33.2 MB checked out, PEASS-ng is larger than its copy-and-run image suggests. Much of the user experience arrives as generated release scripts and binaries rather than a Python application that needs installation on the assessed host. Our 18-second dependency install applies to the repository workflow; a field user will usually download the appropriate release asset and inspect its digest before transfer.

Intensive LinPEAS flags can touch credentials and networks

The default LinPEAS behavior avoids writing to disk and does not try to log in as another user with su. That restraint changes with options. The -a path adds deeper file and hash checks, process monitoring, and password attempts against users. The -r path searches accessible files for hundreds of API-key patterns. Network discovery and port-scan flags can call tools such as ping, fping, or nc, and some modes write temporary information.

Those features are valid in a penetration test and risky in an ordinary production audit. Password attempts may trigger alerts or account controls. Network scans can cross the approved host boundary. Regex searches can put credentials, paths, and customer data into the captured output. Select named sections with -o, agree on noisy actions in writing, and store the result as sensitive evidence rather than attaching an unredacted terminal dump to a general ticket.

The parsers help one report at a time

Included Python scripts convert PEASS output to JSON, then render that JSON as HTML or PDF. The documented structure preserves raw text, cleaned text, colors, explanatory links, and up to 3 section levels. This is useful when a consultant needs an artifact that is easier to search or share than ANSI-colored terminal output. The parser README points bulk users to a separate project, which signals that PEASS-ng's own path is centered on individual files.

Licensing deserves attention before building automation around those parsers. The repository uses GPLv2 or later with project-specific clarification. Its license text says applications that execute PEASS and parse the results are considered derived works, and it offers alternative licenses for proprietary applications and appliances. A company planning a closed-source scanner, dashboard, or agent around the output should have counsel review those terms before engineering starts.

September 2026 activity is frequent and heavily automated

GitHub showed 20,492 stars, a last push on September 8, 2026, and one open issue or pull request. The latest release was published that day from commit 8e0aabe by GitHub Actions. Recently closed work included Linux and Windows vulnerability-definition updates, new checks, word-list refreshes, parser fixes, and repaired HackTricks links. A tiny open queue here accompanies frequent merged automation, so it is more useful to inspect the change stream than celebrate the count.

That speed creates its own operating rule: pin and archive the exact artifact used in an assessment. A host report should record the release tag, selected options, execution identity, scope, and digest. Our lab found a successful build and 0 audited dependency findings, yet no runnable local suite. PEASS-ng is best treated as examiner-controlled code whose output starts an investigation, with every intensive flag approved before it touches the target.

Alternatives

ProjectWhat it isPick it when
Linux Smart EnumerationA shell-based Linux enumerator with selectable levels of detail.pick this instead when Linux is the only target and a smaller enumeration script is easier to review and approve.
LinEnumA long-running Linux host enumeration script with a narrower scope than PEASS-ng.pick this instead when you want a familiar single Linux script and do not need PEASS-ng's Windows tools or report parsers.
PrivescCheckA PowerShell script focused on common Windows privilege-escalation weaknesses.pick this instead when the engagement is Windows-only and PowerShell source is preferable to WinPEAS executables.

What people are saying

  1. [velocity-scout] peass-ng/PEASS-ng

Sources

  1. PEASS-ng repository and suite README
  2. LinPEAS README and option reference
  3. WinPEAS README
  4. PEASS output parser README
  5. PEASS-ng license
  6. September 8, 2026 PEASS-ng release
  7. CI master-test fix pull request 700

More dev tools reviews

lo · d2 · typst · imgui · gofr · CleanArchitecture · the whole board →