# 5 cybersecurity tools on Linux you should master

> Master Wireshark, Nmap, Hydra, tcpdump and Lynis on Linux to audit networks, detect intrusions and harden your system before another attack
> By José Maldonado · Cybersecurity · 2026-09-08

Linux remains the natural terrain of cybersecurity, and it is no coincidence. More than 90% of cloud infrastructure runs on this system and, according to Wireshark's own documentation, its protocol analyzer is already the most widely used in the world for inspecting traffic in real time. The question is not whether you will need these tools, but when.

If you administer servers, audit infrastructures or simply want to understand what goes in and out of your machine, these five utilities form the minimum kit that separates an improvised defense from a truly hardened system.

## Why is Linux the testing ground for security?

On Windows you can install closed suites that do almost everything with one click. True, they are a black box: the tool works, but you don't know what it does, or how it does it, and worst of all, whether it really works. On Linux the opposite happens, since each piece is specialized, lightweight and composable.

That fragmentation is an advantage, because it lets you chain tools into a professional workflow. You discover what is exposed, capture what is circulating, verify whether a weak credential opens the door and audit whether your own configuration meets the standard. The key is understanding that these are not isolated programs, but layers.

For example, tools like Nmap give you visibility into the network, tcpdump and Wireshark provide evidence, Hydra puts your passwords to the test and Lynis points out what you should have configured from the start.

It is worth qualifying that no tool replaces judgment. A misused scanner can take down a service, a brute-force attack without permission is illegal in almost any jurisdiction and an unfiltered capture can expose sensitive data. This is where hardening intersects with responsible use, and where professional ethics must prevail above all.

**[Jupyter Notebooks, a computational laboratory within your reach](https://observatorioblockchain.com/en/technology/jupyter-notebooks-uv-ubuntu-fedora/)**

## Nmap, the map of your attack surface

[Nmap](https://nmap.org/) is the starting point. Created by Gordon Lyon and maintained as an open source project since the late nineties, it remains the reference port scanner.

Version 7.95, from April 2024, added more than 6,500 fingerprints and four industrial scripts, and the branch has continued up to 7.991 from August 2026 according to its official website. Those signatures make it possible to distinguish a Linux 6.1 from a macOS Ventura or an iOS 16 with only the response to a probe.

But what does this tool do? Basically, it sends crafted packets and analyzes each port: open, closed, filtered. From there you deduce whether a computer or server exposes SSH where it shouldn't, whether a forgotten container left Docker's port 2375 in view or whether your firewall delivers the security it promises. That way, nmap helps you know your network, the services on it, what is and isn't enabled, and gives you clues on how to attack.

For example, a basic defensive use of this tool would be:

```
sudo nmap -sV -sC -O -T4 192.168.10.0/24
```

This command runs an advanced, fast network scan across your entire local network (192.168.10.0/24) using administrator privileges (sudo). Its goal is to identify all connected devices, accurately detecting which ports they have open, the exact versions of the services they run (-sV), vulnerabilities and basic information through automated scripts (-sC) and the operating system of each machine (-O), all processed at high speed (-T4).

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/nmap-scan-test.webp)

An excellent way to start testing the security of your network at its most basic level.

## tcpdump, the scalpel in the terminal

If Nmap is the map, [tcpdump](https://man.openbsd.org/tcpdump) is the stethoscope. It has no graphical interface, weighs barely a few hundred kilobytes and comes preinstalled on almost any distribution, from Ubuntu to Rocky Linux. Precisely for that reason it remains irreplaceable on remote servers where you cannot open Wireshark.

It captures packets via libpcap and saves them to files with the `.pcap`extension. Its strength is the Berkeley Packet Filter (BPF) filters, which keep you from drowning in traffic.

Example for debugging HTTPS:

```
sudo tcpdump -i eth0 -w captura.pcap host 10.0.0.1 and port 443 -c 1000
```

With `-i` you choose the interface and `-w` dumps to a file; the expression `host ... and port ...` is pure BPF. Add `-n` to skip DNS resolution and `-X` to see the payload in hexadecimal.

On a remote server over SSH at two in the morning, that line is all you have. The essential thing is to capture little and well: seconds with the right filter are worth more than gigabytes unfiltered. A useful trick is rotation: `tcpdump -C 100 -W 5 -w traza.pcap` creates 100 MB files and rotates among five without filling the disk.

Remember that tcpdump sees everything that passes through the interface. In sensitive environments, that capture is a critical asset: encrypt it, limit its duration and delete it when you finish.

**[CERN abandons RHEL for Debian Linux on its accelerators](https://observatorioblockchain.com/en/technology/cern-abandona-rhel-debian/)**

## Wireshark, the laboratory for understanding what is happening

Wireshark is the same engine as tcpdump, but with a microscope. It is the most popular analyzer in the world, maintained by the [Wireshark Foundation](https://www.wireshark.org/docs/relnotes/wireshark-4.4.4.html), and its 4.4 branch remains active: 4.4.8 from July 2025 improved dissectors such as DTLS and IPsec and 4.4.9 from September fixed a crash in the SSH dissector.

It decodes more than 3,000 protocols and its display filter is more expressive than BPF. While BPF filters at capture time, Wireshark filters after capture: `http.request.method == "POST" && ip.addr == 192.168.1.50` , for example, shows only the POSTs from that IP, filtering their content more effectively.

Its value in hardening goes beyond being a forensic tool. For example, does your Nginx server negotiate TLS 1.0 for legacy compatibility? Wireshark can detect it, through its use of ClientHello. Does malware use DNS TXT toward a strange domain? With Wireshark you can see it clearly. Does a backup expose credentials over unencrypted FTP? You can see that without problems too.

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/ws-main.png)

To use it on Linux without resorting to sudo every time, the package creates the `network` group (then log out and back in to apply the change):

```
sudo usermod -aG network $USER
```

Even so, the project's recommendation is not to run the interface as root. Capture with `dumpcap` and analyze as a normal user. The most efficient workflow is hybrid: capture lightweight with tcpdump remotely and open the `.pcap` in Wireshark on your machine. Lightness of the terminal and visual power of the laboratory.

A capture can contain tokens, cookies and passwords. Treat it like a database dump and anonymize it before sharing.

## Hydra, the uncomfortable mirror of your passwords

[**THC Hydra**](https://github.com/vanhauser-thc/thc-hydra) is not a sniffer or a scanner. It is an online credential tester, and its defensive value is precisely that: it forces you to check whether what you consider a reasonable password withstands an automated attack.

Developed by van Hauser and the THC community, it supports more than 50 protocols —FTP, SSH, HTTP-Form, SMB, RDP, PostgreSQL— and parallelizes attempts where the protocol allows it. Version 9.7, from May and listed as the latest stable on [GitHub](https://github.com/vanhauser-thc/thc-hydra/releases) and [Kali Linux Tools](https://www.kali.org/tools/hydra), keeps the project active after two decades.

Example against a lab SSH:

```
hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://192.168.1.20 -t 4 -f -V
```

With `-l` you set the user, `-P` a wordlist and `-t 4` you limit threads so as not to bring down the service. `-f` stops at the first hit; always test against environments you control.

Hydra does not crack offline hashes like Hashcat. It attacks the live login, slower and detectable. If it finds `admin:admin` in seconds, you don't need an external auditor to know you have a problem. You can automate that check in your lab before others do.

Launching Hydra against third-party systems without permission is illegal. In audits, scope is signed, the window is limited and monitoring is coordinated so as not to confuse a test with an attack. If your Fail2Ban does not detect those attempts, the finding is twofold: weak password and lack of detection.

## Lynis, the audit you should run every week

Lynis is the least flashy and perhaps the most useful for hardening Linux from the inside. Open source GPL since 2007 and maintained by CISOfy, it performs hundreds of checks on the host: permissions, kernel, authentication, patches and alignment with CIS or NIST, as detailed in its [official documentation](https://cisofy.com/lynis) and its repo on [GitHub](https://github.com/CISOfy/lynis) with more than 16,000 stars.

It doesn't need an agent:

```
sudo lynis audit system
```

You get a hardening index out of 100 and prioritized suggestions. It doesn't say you are secure, it says what you don't comply with.

The ideal workflow is to run it after every deployment: new Docker image, freshly created VPS. If it flags `/tmp` without `noexec`, `,` kernel.sysrq `active or` PermitRootLogin yes `in OpenSSH, you know what to touch in` /etc/sysctl.conf `or`.

sshd\_config

![](https://content.observatorioblockchain.com/wp-content/uploads/2026/09/lynis-audit.webp)

. Unlike OpenVAS or Nessus, which scan from outside, Lynis inspects local files. It is faster, less intrusive and does not pollute logs. One shows how they see you from outside; the other, how you are on the inside.

## Lynis does not exploit. It does not confirm a CVE with an exploit, but it does tell you whether you have the ingredients to be vulnerable. Combine it with patches and an external scanner for the full picture.

How to chain the five pieces without breaking anything?

Having the tools installed doesn't make you more secure. Using them in order, with judgment and in a controlled environment does.

This is the workflow followed by many teams starting from scratch with a freshly provisioned Ubuntu, Debian or Rocky server:

Phase

Tool

Defensive objective

Reference command

Discovery

Nmap

Inventory real ports and versions

nmap -sV -sC 192.168.1.10

Lightweight capture

tcpdump

Record minimal, filtered evidence

tcpdump -i eth0 -w traza.pcap port 443

Deep analysis

Wireshark

Decode protocols and detect anomalies

Open traza.pcap and filter tls.handshake

Credential testing

Hydra

Verify there are no trivial logins

hydra -L usuarios.txt -P claves.txt ssh://host

Internal audit

Lynis

Measure hardening and prioritize fixes

lynis audit system –quick

Always start in the lab: clone the machine, isolate the network and test there. In production, notify the team, log the window and limit the scope. Document the command, parameters and finding.`Automation makes the difference. Nmap and Lynis generate parseable output (`, `-oX`\--report-format `), tcpdump leaves` .pcap `processable with` tshark -r traza.pcap -Y "dns"

**[and Hydra exports to JSON. A weekly cron or your image CI warns you before an external scanner does.](https://observatorioblockchain.com/en/cybersecurity/hugging-face-hack-mensaje-mundo-empresarial/)**

## The Hugging Face hack and the powerful message it sends the world

Common mistakes and limits you should know

The power of these utilities comes with an edge. These are the stumbles that repeat most when they are used without background. `The first is confusing scanning with auditing. Running Nmap without understanding the` open|filtered `states or launching Hydra with 64 threads against a production SSH is not a test, it is a self-inflicted denial of service. Adjust` -t `in Hydra, use` -T2

in Nmap if the service is sensitive and coordinate. `The second is capturing without a filter and storing forever. A` .pcap

of hours with customer traffic can contain personal data. Apply narrow BPF, rotate files and encrypt the result. Forensics does not justify retaining more than necessary.

The third is trusting the hardening index as if it were a final grade. Lynis can give you 85 out of 100 and you will still be vulnerable if you don't patch. The index measures configuration, not exposure to zero-day exploits. Use it as a to-do list, not as a seal.

## Remember the limits: Wireshark does not decrypt TLS 1.3 without keys, tcpdump does not see inside well-configured VPNs and Hydra crashes against MFA or progressive lockout. If your system withstands Hydra because Fail2Ban blocks after five attempts and your SSH requires a key, the tool has done its job even if it finds nothing.

A kit that forces you to look at your system through an attacker's eyes

Mastering these five tools doesn't make you a hacker, it makes you a better defender. They provide raw evidence of what your Linux does on the network and where your configuration falls short. `Wireshark and tcpdump teach you to read the network without intermediaries. Nmap forces an honest inventory. Hydra reminds you that` P@ssw0rd2024

is not security, it is decoration. Lynis forces you to close what you opened in a hurry and to justify what you leave open.
