# Offline PIN Brute-Force Calculator

> One page from jmrp.io, published as markdown. Index: https://jmrp.io/llms.txt

> Generated: 2026-08-29

URL: https://jmrp.io/tools/pin-brute-force-calculator/
Language: en
Alternate: https://jmrp.io/es/tools/pin-brute-force-calculator/index.md
Updated: 2026-08-23
Category: security
Tags: security, cryptography, pbkdf2, brute-force, pin, key-derivation

Estimate how long an offline GPU takes to brute-force a PIN through PBKDF2 — then toggle device binding and watch it become infeasible. Runs client-side.

Features:
- Estimates offline PIN time-to-crack
- Adjustable PBKDF2 work factor
- Configurable keyspace and GPU throughput
- Shows device binding making attacks infeasible
- Computes client-side, no inputs transmitted

Questions answered:

**How long does it take to brute-force a 4-digit PIN?**

A 4-digit PIN has only 10,000 possible values, so a GPU with no key-stretching cracks it almost instantly. The real defense is a PBKDF2 work factor that slows each guess, or device binding that makes offline guessing infeasible.

**Does increasing the PBKDF2 iteration count stop brute-force attacks?**

Higher iteration counts multiply the per-guess cost, raising the time to sweep the whole keyspace, but the count is sized for unlock latency, not as the brute-force defense. For a small PIN keyspace it slows an offline attacker but does not make the attack infeasible on its own.

**How does device binding make a PIN brute-force infeasible?**

Device binding mixes a per-chip secret into key derivation, so every guess needs hardware that can't be extracted from the dumped flash. The attacker can no longer test candidates offline against the exfiltrated vault.

**How does the calculator estimate attacker speed?**

It divides the GPU's raw SHA-256 throughput by the PBKDF2 work, treating each iteration as roughly two SHA-256 compressions. Keyspace divided by that rate gives the time to try every candidate; the expected time to find the secret is about half of that.

**Is anything I type sent to a server?**

No. Every value is computed in your browser with simple arithmetic, and no inputs are transmitted anywhere.


---

**Interactive tool** — this page hosts the working application itself, not a description of one.

**Offline brute-force calculator — built-in presets**

| Attacker hardware | Raw SHA-256 |
| --- | --- |
| NVIDIA RTX 5090 | 28.353 GH/s |
| NVIDIA RTX 4090 | 21.975 GH/s |
| NVIDIA RTX 4080 | 13.7 GH/s |
| NVIDIA RTX 3090 | 9.866 GH/s |
| NVIDIA RTX 3060 | 3.9 GH/s |
| Modern 16-core CPU | 1.5 GH/s |
| 8x RTX 5090 rig | 226.824 GH/s |
| 100x RTX 5090 cluster | 2835.3 GH/s |

Attacker rate is derived from the raw SHA-256 figure as raw / (2 x PBKDF2 iterations) — two SHA-256 compressions per round.

Secret alphabets: digits (PIN) 10, lowercase + digits 36, letters + digits 62, all printable ASCII 95. Secret length: 3 to 20.

PBKDF2 iteration presets: 35000 (device production), 600000 (OWASP 2025), 1000 (hashcat benchmark).

## About This Tool

A 4-digit PIN has only **10,000** possible values. This calculator shows what that means against an **offline** attacker who has dumped the flash: pick a secret space, a **PBKDF2** work factor, and a GPU, and it estimates the time to sweep the whole keyspace.

Then flip on **device binding** — and the offline attack becomes infeasible, because every guess now needs a per-chip secret that can't be extracted from the hardware.

It is the interactive companion to the article [Your 4-Digit PIN Is Fine: Device-Bound Keys on ESP32-S3](https://jmrp.io/blog/012-device-bound-key-derivation/).

### What Does It Compute?

- **Keyspace** — the alphabet size raised to the secret length.
- **Attacker rate** — raw GPU SHA-256 throughput divided by the PBKDF2 work (≈ two SHA-256 compressions per iteration).
- **Time** — keyspace ÷ rate to try every candidate; the expected time to *find* the secret is roughly half of that.

### A Note on Realism

This models the *offline* attack on an exfiltrated vault. On the device itself, online guessing is stopped first by a brute-force lockout that wipes the vault after a handful of wrong tries — the iteration count is sized for unlock latency, not as the brute-force defense.

### Privacy

Everything is computed in your browser with simple arithmetic. No inputs are
transmitted anywhere.