JPKCom DB

Hash Generator

What the Hash Generator does: 20 hash algorithms live, HMAC, SRI, file checksums and bcrypt/Argon2id/PBKDF2 — all in your browser, no upload.

Hashes for text and files — all in the browser

The Hash Generator computes hashes (checksums) for any text, for raw bytes given as hex or Base64, and for entire files. As soon as you start typing, a table fills with all 20 algorithms at once — from MD5 through SHA-2 and SHA-3 to BLAKE3. A third section creates and verifies password hashes with bcrypt, Argon2id, and PBKDF2.

A hash is a digital fingerprint: the same input always produces the same hash, and changing a single character produces a completely different value. That's exactly why hashes are the tool of choice for verifying the integrity of downloads, backups, or documents, for comparing values, or — as an HMAC — for keyed message authentication.

The tool is built for everyone who deals with data integrity and checksums: developers who want to double-check a checksum or need an SRI attribute for a <script> tag; admins matching a downloaded build against its published SHA-256 value; and anyone who needs an HMAC for an API signature or a bcrypt/Argon2id hash for an application. No account, no installation, no server upload.

Client-side — your data never leaves the browser

This is the key point: every hash is computed locally in your browser, in a separate background thread (a Web Worker), so the page stays responsive even with large files. The math comes from the libraries @noble/hashes (MIT) and bcrypt.js (BSD-3-Clause); CRC-32 is built into the tool itself. Neither your text, nor your file, nor a password is ever sent to a server — even a large file is read piece by piece straight from your disk instead of being loaded into memory in one go.

The random HMAC key is generated locally as well (crypto.getRandomValues); there is no server endpoint involved anymore. A history of your text inputs is kept only if you explicitly switch it on — and passwords and keys are never stored.

Which algorithms are available

The result table is organized into four groups:

  • Legacy (not collision-resistant) — MD5, SHA-1, RIPEMD-160, and CRC-32. For compatibility and for catching accidental changes, not for security. CRC-32 is explicitly a checksum, not a cryptographic hash.
  • SHA-2 — SHA-224, SHA-256, SHA-384, SHA-512, and SHA-512/256. Today's standard for integrity.
  • SHA-3 (FIPS 202) — SHA3-224/256/384/512, plus Keccak-256 and Keccak-512 (the original Keccak, as used by Ethereum, for example) and the extendable-output functions SHAKE128 (256-bit output) and SHAKE256 (512-bit).
  • BLAKE — BLAKE2b-512, BLAKE2s-256, and BLAKE3.

Enter an HMAC key and the table shows the HMAC instead of the plain hash for every algorithm except SHAKE, BLAKE3, and CRC-32. Every value can be output as hex, HEX, Base64, or Base64URL. A compare field highlights the matching row in green, and without an HMAC key the tool builds a ready-made SRI attribute (preferably SHA-384; in the File tab, depending on your selection, SHA-256 or SHA-512). In the Password hashing section you create and verify bcrypt, Argon2id, and PBKDF2 hashes that PHP or Django understand as-is. Every option is covered in the manual.

Try it now

→ Open the Hash Generator — type text or drop a file, read off the hash, or let the tool check it against the value you expect. Free, no account, entirely in the browser.

Hashing is just one part of the crypto toolbox — these tools complement it:

  • Generator — for secure passwords, keys, TOTP codes, and .htpasswd lines. General-purpose password hashes (bcrypt, Argon2id, PBKDF2), including verification, live here in the Hash Generator instead; the Generator links straight to that section.
  • Cryptor — for actual encryption and decryption (hashing is not encryption; see the tips).
  • PKI — for certificates, key pairs, and signatures.

There's more on the subpages: the manual with every algorithm and every input/output option, hands-on examples for concrete workflows, and tips & tricks with the all-important security context.