How fast a GPU guesses each password hash
We ran hashcat 7.1.2 against each common password hash on the AMD Radeon 8060S in our test machine, a Ryzen AI Max+ 395 mini PC, with the slow hashes set to the parameters OWASP recommends (bcrypt at cost 12, above OWASP's minimum of 10). On the same chip, MD5 runs at 28.6 billion guesses per second and Argon2id at 2,011: a factor of about 14 million. The table sets our measurements beside the published benchmark for an NVIDIA RTX 5090.
| Hash | Parameters | hashcat mode | Radeon 8060S, guesses/s (measured) | RTX 5090, guesses/s (published) | Try the 755,994 most common leaked passwords (8060S) | Try every 8-character password (8060S) |
|---|---|---|---|---|---|---|
| MD5 | none (unsalted) | 0 | 28,631,864,972 | 220,600,000,000 | under a second (start-up time dominates) | 2.7 days |
| NTLM (Windows) | none (unsalted) | 1000 | 52,667,595,819 | 340,100,000,000 | under a second (start-up time dominates) | 1.5 days |
| SHA-1 | none | 100 | 13,314,110,816 | 70,245,100,000 | under a second (start-up time dominates) | 5.8 days |
| SHA-256 | none | 1400 | 5,429,935,801 | 28,353,300,000 | under a second (start-up time dominates) | 14 days |
| SHA-512 | none | 1700 | 1,537,667,955 | 10,048,600,000 | under a second (start-up time dominates) | 1.6 months |
| PBKDF2-HMAC-SHA512 | 220,000 iterations | 12100 | 2,963 | 19,297 * | 4.3 minutes | 71 thousand years |
| PBKDF2-HMAC-SHA256 | 600,000 iterations | 10900 | 3,816 | 18,595 * | 3.3 minutes | 55 thousand years |
| Argon2id | m=19 MiB, t=2, p=1 | 34000 | 2,011 | not in the benchmark | 6.3 minutes | 105 thousand years |
| bcrypt | cost 12 | 3200 | 318 | 2,381 * | 40 minutes | 661 thousand years |
| bcrypt | cost 10, the OWASP minimum | 3200 | 1,272 † | 9,525 * | 9.9 minutes | 165 thousand years |
| scrypt | N=2^17, r=8, p=1 | 8900 | 177 | not in the benchmark | 1.2 hours | 1.2 million years |
"Every 8-character password" is all 958 combinations of printable ASCII, the full keyspace; the average password falls in half that. * Derived from the published figure, which was measured at hashcat's benchmark settings rather than these parameters: PBKDF2-HMAC-SHA512 (220,000 iterations), PBKDF2-HMAC-SHA256 (600,000 iterations), bcrypt (cost 12), bcrypt (cost 10, the OWASP minimum). † bcrypt cost 10 on the 8060S is our cost-12 measurement times four, since each cost step doubles the work. The derivations are explained below. Download the table (CSV).
Why the slow hashes are measured at deployed settings
hashcat's built-in benchmark runs each slow hash at a fixed, light setting: bcrypt at cost 5, PBKDF2 at 1,000 iterations, scrypt at N=16384. Nobody deploys those. Published benchmark tables quote them anyway, which makes slow hashes look faster to crack than they are in practice. So for bcrypt, scrypt, PBKDF2 and Argon2id we generated a real hash at the recommended setting, ran a short brute-force attack against it, and recorded the speed hashcat reported. The fast hashes have no setting to choose, so their figures come from benchmark mode.
The settings follow the OWASP Password Storage Cheat Sheet: Argon2id with 19 MiB of memory, 2 iterations and 1 thread; scrypt with N=217, r=8, p=1; PBKDF2-HMAC-SHA256 at 600,000 iterations and PBKDF2-HMAC-SHA512 at 220,000. For bcrypt, OWASP sets a minimum cost of 10; we used 12, the default many frameworks ship and the setting the estimator assumes. Cost 10 is four times faster to attack than cost 12.
Checks on the numbers
- bcrypt scales as documented. Each step of bcrypt's cost doubles the work, so cost 12 should run at 1/128 of cost 5. We measured 39,281 guesses per second at cost 5 and 318 at cost 12; 39,281 ÷ 128 is 307, within 4%.
- Attack mode agrees with benchmark mode. bcrypt at cost 5 ran at 35,945 in a real attack against 39,281 in benchmark mode, 8% apart.
- PBKDF2 scales with iterations. hashcat benchmarks PBKDF2 at 1,000 iterations (its output shows 999, because it stores the count minus one). Scaling our benchmark figures by iteration count predicts 3,772 guesses per second for PBKDF2-HMAC-SHA256 at 600,000 iterations and 3,010 for PBKDF2-HMAC-SHA512 at 220,000. We measured 3,816 and 2,963: 1.2% and 1.6% from the prediction.
OWASP's five Argon2id settings measure the same
OWASP lists five Argon2id settings, from 46 MiB with one pass to 7 MiB with five, and says they "provide an equal level of defense, and the only difference is a trade off between CPU and RAM usage." We measured three of them on the 8060S:
| Argon2id setting | Guesses per second (measured) |
|---|---|
| 46 MiB, t=1, p=1 | 2,014 |
| 19 MiB, t=2, p=1 | 2,011 |
| 7 MiB, t=5, p=1 | 2,009 |
| 256 MiB, t=3, p=1 (heavier control, not an OWASP setting) | 94 |
The three OWASP settings come out within 0.3% of each other. To rule out hashcat ignoring the parameters, we had it crack a known password hashed at each of the two extremes, which it did, and timed a much heavier setting, 256 MiB with three passes, which ran 94 guesses per second, about 21 times slower. On this hardware the three settings are indistinguishable to an attacker. We have not tested a discrete GPU, where the memory-heavy setting could behave differently.
Where the RTX 5090 figures come from
The RTX 5090 column is Chick3nman's public hashcat benchmark of an RTX 5090 Founders Edition, run in February 2025 on a development build of hashcat (v6.2.6-851). It was run at benchmark settings, so for the slow hashes we converted it: bcrypt by the 2cost rule our own check confirms, and PBKDF2 by the iteration count. scrypt's cost does not convert as cleanly, because more memory per guess also limits how many guesses fit on the card at once, so we left it out; at N=16384 the benchmark shows 7,760 guesses per second. That benchmark predates hashcat's Argon2 support, so Argon2id has no RTX 5090 figure here.
What the table says
- Behind a fast hash, short passwords fall quickly. At 28.6 billion MD5 guesses per second, a small machine tries every 8-character password in 2.7 days. An RTX 5090 is roughly 8 times faster again.
- The slow hashes are all slow, and close to each other at OWASP settings. At the OWASP settings the slow hashes span a factor of about 22 on this chip. scrypt (177 guesses per second) and bcrypt at cost 12 (318) were the slowest to attack, Argon2id at OWASP's 19 MiB setting about 2,010, and PBKDF2 3,000 to 4,000. The comparison flatters bcrypt, because cost 12 is above its OWASP minimum: at the minimum, cost 10, it is about 1,270, much closer to Argon2id. Minimums are not equal-cost settings, so this is not a ranking of the algorithms; the fair comparison is attack speed at equal server time per login, which we did not measure. Treat every minimum as a floor.
- No hash saves a password that is on a list. Even at Argon2id's rate, the 755,994 most common leaked passwords take 6.3 minutes to try on this chip. Our study of the most common leaked passwords shows how many of them a strength meter calls strong.
Method and limitations
- Hardware. AMD Radeon 8060S (RDNA 3.5, 40 compute units, shown by hashcat as 20 processors) in a Ryzen AI Max+ 395 with 128 GB of memory shared between CPU and GPU, Fedora 44, ROCm/HIP 7.1, hashcat 7.1.2 (signature checked against the hashcat signing key). The shared memory is unusual: a discrete card has less memory, which matters most for the memory-hard hashes. Treat the scrypt and Argon2id rows as specific to this kind of machine.
- One run per hash. The fast hashes come from hashcat's benchmark mode. Each slow-hash attack ran for 90 seconds after hashcat's autotune, and the reported speed was stable across its status updates. During the PBKDF2 runs the GPU reached 90 to 94 °C and its clock settled 5 to 7% below its 2,900 MHz peak, so these are sustained rates, not burst rates. The scrypt kernel needed hashcat's self-test turned off at N=217; before timing it, we confirmed it cracks a known hash at that setting. A different driver or hashcat version can move these figures by tens of percent. The order of magnitude is the reliable part.
- The machine was otherwise idle, apart from a language model loaded but serving no requests.
- Measured 1 November 2026.
Updated .