Gerador de Hash Argon2

What this tool does

It computes a real Argon2 hash — Argon2id, Argon2i, or Argon2d, as specified in RFC 9106 — from a password or message you enter, with configurable memory cost, iterations, parallelism, hash length, and salt. Output is available as a PHC-encoded string (the portable $argon2id$v=19$m=...,t=...,p=...$salt$hash format most libraries expect), hex, or Base64.

What is Argon2?

Argon2 is a memory-hard key derivation function — the winner of the 2015 Password Hashing Competition, and the current best-practice choice (per OWASP) for hashing passwords before storing them. Unlike a plain hash function (MD5, SHA-256), Argon2 is deliberately slow and memory-intensive, which makes brute-force and GPU/ASIC cracking attacks far more expensive without meaningfully slowing down a single legitimate login check.

Argon2id (the default here, and the recommended variant for almost all use cases) is a hybrid of the other two: resistant to both GPU cracking (like Argon2d) and side-channel timing attacks (like Argon2i). Argon2i favors side-channel resistance; Argon2d favors maximum GPU/ASIC resistance but is more vulnerable to certain side-channel attacks — it's typically used for cryptocurrency or non-interactive settings rather than password storage.

The parameters

• Memory cost (m), in KiB — how much RAM the computation uses. Higher is more secure but slower. 19456 KiB (19 MiB) is OWASP's current minimum recommendation for interactive use (e.g. a login form).
• Iterations (t) — how many passes are made over that memory. Also trades security for speed.
• Parallelism (p) — the number of independent lanes the algorithm's internal computation is split into. This changes the derived output (it's a real Argon2 parameter, not just a speed knob), so hashing the same password with a different p produces a different hash.
• Hash length — the size, in bytes, of the derived key/hash itself. 32 bytes (256 bits) is typical.
• Salt — a random value mixed into every hash so identical passwords don't produce identical hashes. Leave it on auto-generate unless you specifically need a reproducible salt for testing.

How to use it

1. Enter the password or message to hash.
2. Adjust the Argon2 parameters if needed — the defaults are a reasonable, OWASP-aligned starting point.
3. Choose a salt mode and output format.
4. Click Generate hash.
5. Copy the result, or download it as a text file.

FAQ

Is this safe to use for real passwords? The computation runs entirely in your browser — your password is never sent anywhere. The underlying Argon2 implementation is @noble/hashes, an independently audited, open-source library; this tool doesn't reimplement the algorithm itself.

Why is Generate slower than other tools on this site? That's by design — Argon2 is meant to be computationally expensive, so that trying millions of password guesses is expensive too. Raising memory cost or iterations makes it slower still (and more secure); this tool caps both to keep the browser responsive.

Can I verify a password against an existing Argon2 hash here? Not currently — this tool focuses on generating hashes. To verify, most languages have a built-in or well-known Argon2 verify function (e.g. PHP's password_verify()).

Why does the PHC string not always match other tools with the "same" settings? If the salt differs, the hash differs — that's the point of a salt. Compare the parameters (m, t, p, v) inside the PHC string instead, or set a custom salt on both sides for a like-for-like comparison.

Privacy

Everything happens client-side in your browser. Nothing you type here — the password, salt, or resulting hash — is transmitted to or stored on our servers.