Argon2id Hash Generator
Generate and verify standard Argon2id v=19 PHC password hashes locally in your browser.
Your password is processed locally in a Web Worker and is not sent to our server. Do not use real production passwords in third-party web tools.
How to use the Argon2id tool
- Enter a password and choose the recommended or compatibility profile.
- Click Generate Argon2id Hash; changing the input never starts hashing automatically.
- Copy or download the complete PHC string, which already contains the algorithm, version, parameters, salt, and tag.
- To check a password, open Verify, paste a bounded Argon2id v=19 PHC string, and click Verify Password.
- Use Cancel at any time to terminate the active Worker. Only one operation can run at once.
Deterministic Argon2id fixture
Password: password
Salt (hex, fixed for this fixture only): 0102030405060708090a0b0c0d0e0f10
Parameters: m=19456 KiB, t=2, p=1, tag=32 bytes
PHC output:
$argon2id$v=19$m=19456,t=2,p=1$AQIDBAUGBwgJCgsMDQ4PEA$092w+Kf/8KX2zXM/JUpX9Xtmfouw9CV/yqqSDnFeXb8
The fixed salt makes this an auditable test fixture. The interactive generator uses a new random 16-byte salt every time, so repeated runs for the same password intentionally produce different PHC strings.
What Argon2id is
Argon2id is a password-hashing function that combines the data-independent access pattern of Argon2i with the data-dependent behavior of Argon2d. Version 19 is Argon2 version 1.3 and is identified directly in the PHC string.
Why memory hardness matters
Fast general-purpose hashes make large password-guessing campaigns cheap. Argon2id deliberately consumes both memory and computation, increasing the resource cost of each guess. The costs must still be calibrated for the system that performs authentication.
How this browser implementation works
The page loads the pinned npm package hash-wasm@4.12.0 in a module Web Worker. Generation uses crypto.getRandomValues for a 16-byte salt and emits a standard PHC string. Generation and verification run only after a button click, and Cancel terminates the Worker. Browsers without Worker, WebAssembly, or secure-random support receive an explicit error; the tool never substitutes PBKDF2 or another algorithm.
Parameter choices and limits
| Profile | Memory | Time | Parallelism | Tag |
|---|---|---|---|---|
| Recommended default | 19,456 KiB | 2 | 1 | 32 bytes |
| Compatibility | 12,288 KiB | 3 | 1 | 32 bytes |
Verification is intentionally capped before library execution: m≤19,456 KiB, t≤5, p=1, salt 8–64 bytes, tag 4–64 bytes, PHC≤1 KiB, and password≤1 KiB in UTF-8. These limits prevent a pasted string from requesting unbounded browser resources.
How to store the PHC string
Store the entire PHC string as one value. Its fields identify argon2id, version 19, memory/time/parallelism costs, salt, and tag. The salt is not secret and should remain attached to the hash. Never store the plaintext password alongside it.
Browser tool vs production authentication
This tool is for learning, interoperability checks, and development testing. Production authentication should hash and verify passwords in a controlled server environment with a framework-maintained password library, server-specific performance measurements, rate limiting, migration policies, and appropriate operational controls.
Argon2id vs bcrypt and PBKDF2
Argon2id exposes an explicit memory cost as well as time and parallelism costs. bcrypt is a mature password-hashing scheme with a compact encoded format but more limited password handling and memory behavior. PBKDF2 is standardized and widely available but primarily raises CPU work rather than requiring a large memory region. Existing systems should follow their framework and migration requirements instead of swapping formats blindly.
FAQ
Why does the hash change every time?
Each generation uses a fresh random salt. Verification reads that salt from the PHC string.
Can this verify every Argon2 hash?
No. It accepts only Argon2id v=19 strings within the documented resource bounds; Argon2i, Argon2d, other versions, and higher-cost strings are rejected before hashing.
Does Cancel stop the calculation?
Yes. Cancel terminates the active Worker instead of merely hiding a loading indicator.
Is the password securely erased from browser memory?
No such claim is made. Clear removes visible state, but JavaScript does not provide a reliable way to prove that immutable strings have been wiped from memory.