Installing Hashcat for Peak Performance, or, an Ode to Overthinking

The problem

Back in February the boss FINALLY approved a new cracking rig for the team. Ours are getting a bit long in the tooth, and this new system will have the potential to be twice as fast as our two current ones combined! Anyway, I'm getting ahead of myself. Stay tuned for a post about that new machine!

I wanted to make sure our new rig was spinning at absolute peak performance, so I asked if I could do some experimentation on different software combinations and configurations to see which, if any, came out on top. For example, most of the Internet will tell you that a Linux-based OS will absolutely perform better than a Windows OS, but will it really? And even if that's true, which of the hundreds of Linux flavors should I use? And what about drivers? And what does "headless" really mean? There are shockingly few reports on these questions, and many of the ones that do exist are not terribly recent. This post sets out to get new, modern answers to all of them!

The setup

Hardware

All testing was performed on the exact same hardware to control for variables such as slightly better ventilation, random chip bin performance differences, etc. The hardware included the following:

• CPU: AMD Ryzen 9 9950 X3D

• GPU: MSI Suprim GeForce RTX 5090

• SSD: Crucial T710 1 TB PCIe 5.0 NVMe SSD

• Motherboard: ASUS ROG Strix X870E-E

• Memory: Crucial Pro 96 GB (2x 48 GB) DDR5 5600

Software

Each OS and driver change prompted a complete wipe and reload of the system. The different hashcat installations were performed side by side. The different software configurations included 5 different operating systems:

• Ubuntu Server 24.04

• Fedora Server 43

• Kali 2026.1

• Arch 2026.03.01

• Windows Server 2025 Core

3 different hashcat installations (where applicable; Windows does not have a single, standardized, official software repository with hashcat available):

• From the default package repository

• The pre-compiled binary from hashcat

• Building from source on the target machine

and 2 different driver installations (where applicable; both full and headless drivers were either not available or not practical for both Windows and Arch)

• Full suite

• Headless install

The process

What to test

I decided early on that the testing should be practical and that the hash modes should be limited to hashes commonly found by actual penetration testers in the field. The modes should also encompass fast, slow, and moderate hashes. With that in mind, the following four modes were tested to get an idea of how well the performance was for the different types:

• 22000 (WPA-PBKDF2-PMKID+EAPOL); e.g., WPA2 handshakes

• 13100 (Kerberos 5, etype 23, TGS-REP); e.g., Kerberosted accounts

• 5600 (NetNTLMv2); e.g., Relayed authentication

• 1000 (NTLM); e.g., Windows Active Directory dumps

I regarded these hash modes as slow, moderate-to-slow, moderate, and fast respectively. Testing things like MD5 (superfast!) and bcrypt (s u p e r s l o w) really didn't seem to add value because

1. They aren't commonly encountered in real-life engagements

2. Test time was limited; I couldn't very well test everything!

How to test

This one required more thought than I had first expected. There are a lot of different ways to approach this, but in the end I opted to write a little script to run the built-in hashcat benchmarks for each hash mode five times. Other methods could have been to run a full brute-force attack to completion, but this would have wasted an absolutely incredible amount of time, energy, and money. I could have run other specific attacks that our team uses during engagements. Those results would have been extremely useful to our team but dramatically less useful to anyone else. The built-in benchmarks offer a known, consistent test every time they are run. This makes them useful to a much broader audience, which is the point of this post anyway!

I've included my test script below. It is extremely simple (maybe too simple). The point is to run each benchmark for each hash mode 5 times with a 3-minute cooldown between each run. This ensures the GPU and other components have time to return to a baseline temperature before executing the next command. I checked the temperature of the GPU first thing in the morning when the machine had been sitting unused overnight. Then I ran a benchmark, checked the temp again, and repeated until it came back to baseline. It returned amazingly fast, under a minute. This is probably due to A) water cooling on the GPU and B) the benchmark command does not take long to complete. However, the GPU temperature is not the temperature of every component in the system. With this in mind, I set the time between commands to 3 minutes to ensure that everything, not just the GPU, had time to return to equilibrium. I suppose I could have run one test a day, allowing the machine to cool completely overnight, but that seemed ridiculous.

The results

Finally! At last we're to the part with the actual data. There’s a lot here. Before poring over every number to every decimal place, you might consider jumping down to the conclusion first. But I'm not your mom, so do whatever you want.

The Top 20 lists are the fastest recorded speeds for each hash mode. So, for this first one, all the speeds for 22000 are sorted descending, then the details are recorded. Ubuntu showed up 9 times in the top 20, the full driver suite showed up 12 times in the top 20, etc.

Top 20 - 22000

Top 20 - 13100

Top 20 - 5600

Top 20 - 1000

Cumulative Top 20s

Absolutely Everything

The complete table, along with plenty of our other publicly available tools, can be found here: https://github.com/shellntel/Installing-Hashcat-for-Peak-Performance-or-an-Ode-to-Overthinking

Conclusion

In the end the specific software configuration doesn't appear to matter all that much, which surprised me. The numbers were not very different, certainly not by any statistically significant amount.

None of the different combinations of OS, driver, or hashcat installation appeared to give an across-the-board advantage. Ubuntu and Fedora performed perfectly adequately and are officially supported by NVIDIA. Arch and Kali did fine as well, but they are not officially supported. They each present the potential for future troubles since the Kali distribution is so heavily customized by that team, even though it is based on Debian. Arch is a completely different animal that had to be installed with the NVIDIA .run files instead of a .deb or .rpm file. Getting the drivers to work on Windows Server can be a little tricky since NVIDIA doesn't officially have drivers for the Server OS (the server OS was selected deliberately since it offered a headless installation option).

Interestingly, Windows did seem to run several degrees hotter than the rest with the same performance. There are several reasons this could be the case, including the fact that "headless" on Windows is not the same as "headless" on Linux, and that the compatible driver was not the exact same version that was used on the other Linux operating systems. However, I never said my testing was completely scientific and did not control for this.

You should install whatever will be most easily supported:

Operating System

If you already have support for Debian or RHEL systems, why on earth would you use Arch on your cracking rig? If you’re a strict Windows shop, my heart breaks for you.

Drivers

NVIDIA's full driver suite vs. their headless driver suite doesn't appear to matter at all. This actually makes sense given that all the other functionality simply isn't being used. It's not running background tasks; it's just code on the machine that isn't needed. At worst, it's a waste of disk space.

Hashcat versions

Install hashcat however you like. Unless you're running highly complex attacks for days on end, the differences probably won't matter that much.

If you do want to get a little in the weeds with it, consider installing hashcat several different ways, then run benchmarks to see which installations handle which hashes best. That means install hashcat from your package manager (if applicable), from the pre-compiled binary, and from source. And if you’re ready to analyze them for trends and vulnerabilities, check out our new tool, Hash Master 1000!

BONUS!!!

How TO install hashcat

Thanks for sticking around to the end! As a thank you, here are some dead-simple steps to install all the hashcats (repo, pre-compiled, source-complied) on a fresh OS installation. These steps assume an NVIDIA GPU and a supported Linux-based operating system

1. sudo apt update && sudo apt -y upgrade

2. Follow steps from https://developer.nvidia.com/cuda-downloads?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=24.04&target_type=deb_local

   1. wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin

   2. sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600

   3. wget https://developer.download.nvidia.com/compute/cuda/13.2.0/local_installers/cuda-repo-ubuntu2404-13-2-local_13.2.0-595.45.04-1_amd64.deb

   4. sudo dpkg -i cuda-repo-ubuntu2404-13-2-local_13.2.0-595.45.04-1_amd64.deb

   5. sudo cp /var/cuda-repo-ubuntu2404-13-2-local/cuda-*-keyring.gpg /usr/share/keyrings/

   6. sudo apt-get update

   7. sudo apt-get -y install cuda-toolkit-13-2

   8. sudo apt-get install -y nvidia-open ***The instructions offer the option of installing either the open source or closed source kernel mode drivers. The 5090 I was using would not work with the closed source drivers, and errors in dmesg explicitly stated that the open kernel modules were required.***

3. Complete the post-installation requirements found here: https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions

   1. echo export PATH=\${PATH}:/usr/local/cuda-13.2/bin >> ~/.bashrc

   2. echo export LD_LIBRARY_PATH=\${LD_LIBRARY_PATH}:/usr/local/cuda-13.2/lib64 >> ~/.bashrc

4. sudo reboot

5. sudo apt update && sudo apt install hashcat 7zip

6. mkdir hashcat-release; cd hashcat-release

7. wget https://github.com/hashcat/hashcat/releases/download/v7.1.2/hashcat-7.1.2.7z

8. 7z x hashcat-7.1.2.7z

9. mkdir ../hashcat-source; cd ../hashcat-source

10. git clone https://github.com/hashcat/hashcat.git

11. cd hashcat

12. make clean && make

13. cd ~ 

14. echo Thanks, Chad!