A WiFi Auditing Tool That Doesn't Make You Live in the Terminal

You've probably seen the wall of commands and config files that comes with most WiFi security tooling, and if you've ever tried to audit your own network, you know the drill. Airgorah takes a different approach: it's a WiFi security auditing application written in Rust, and it wraps the whole workflow in a GTK4 desktop interface instead of leaving you to juggle command-line flags.

What It Does

Airgorah captures nearby WiFi traffic, discovers clients connected to access points, performs deauthentication attacks, captures handshakes and PMKIDs, and cracks the password of access points. That's the full pipeline in one place, from scanning to cracking.

It's built in Rust, with GTK4 handling the graphical side through the gtk4-rs bindings. The interface runs as a normal user, which means it works under both X11 and Wayland. When the app needs to do something privileged, it launches a small agent called airgorah-agent via polkit, which prompts you for authentication once. There's no running the whole GUI as root, and no wrestling with sudo just to open a window.

Why It's Cool

• The privilege separation is the smart part. Running security tools as root is the usual shortcut, and it's a messy one. Airgorah keeps the GUI unprivileged and only escalates through a dedicated agent via polkit, authenticating once. If you care about how your tools are architected, that's a design decision worth paying attention to.

• The agent handles the sharp edges. Deauthentication attacks and handshake capture need real access to the wireless card, and instead of pushing that responsibility onto the user, it's isolated in a small privileged component. The GUI stays a normal application.

• It's a complete workflow, not a single trick. Plenty of tools do one piece of WiFi auditing well. Airgorah covers discovery, client enumeration, deauth, handshake and PMKID capture, and password cracking. That means one interface for the whole job rather than stitching together several utilities and remembering how each one wants its arguments.

• Rust plus GTK4 is a combination you don't see every day. Desktop GUI work in Rust is still a relatively young space, and this is a real application built on it rather than a toy. If you're curious about gtk4-rs in practice, there's something to learn here.

• It's honest about what it's for. The README's legal section is blunt: this is for testing and discovering flaws in networks you own, and attacking networks you don't own is illegal in almost all countries. No hedging, no pretending the tool is something it isn't.

The requirements are worth flagging up front. This only works on Linux, and you'll need a wireless network card that supports monitor mode and packet injection. Those aren't optional extras; without them, the core features have nothing to work with.

How to Try It

Before anything else, check that your hardware qualifies. A card that supports monitor mode and packet injection is a hard requirement, and you're on Linux only.

Installation instructions live in the project wiki rather than the README, so start here:

• Installation guide: https://github.com/martin-olivier/airgorah/wiki/Installation
• Usage documentation: https://github.com/martin-olivier/airgorah/wiki/Usage

The project is published on crates.io and has an AUR package for Arch users, so depending on your setup you may have a straightforward path through your package manager. Once it's installed, launch the GUI as your normal user. The first time it needs to do something privileged, polkit will ask you to authenticate, and that's the expected flow, not a sign something's gone wrong.

If you run into questions about usage, the maintainer asks that you open a discussion rather than an issue. Bugs and feature requests go to the issue tracker, and pull requests are welcome.

Final Thoughts

Airgorah is best suited to people who own the networks they're testing and want a graphical, Linux-native way to work through a WiFi audit without memorizing a pile of commands. The polkit-based privilege model and the Rust/GTK4 stack make it interesting beyond its immediate purpose, too. It's not for everyone — the hardware requirement alone rules plenty of people out — but if you've got the right card and the right network, it's a tidy piece of work. The project is MIT licensed, so you can read through it, learn from it, or contribute back.