# Hash Generator — Examples

> Hands-on walkthroughs with the Hash Generator: hash text across algorithms, verify file integrity, compare hashes, and create an HMAC.

Source: https://www.jpkc.com/db/en/tools/hash/examples/

Back to the overview: [Hash Generator](https://www.jpkc.com/db/en/tools/hash/) · Open the tool live: [www.jpkc.com/tools/hash/](https://www.jpkc.com/tools/hash/)

The [manual](https://www.jpkc.com/db/en/tools/hash/manual/) explains every algorithm and option in detail. This page adds **concrete workflows**. The hash values below are real example values for the inputs shown — you can reproduce them to check.

## Example 1: Hash one text across several algorithms

You want to see how the same text looks in different algorithms.

1. Open the [Hash Generator](https://www.jpkc.com/tools/hash/) and type `hello` into the **Message** field.
2. Click **MD5**. The **Output** shows:
   ```
   5d41402abc4b2a76b9719d911017c592
   ```
3. Click **SHA-1** (the green button). The output gets longer:
   ```
   aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
   ```
4. Click **256** (SHA-256). Now 64 hex characters:
   ```
   2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
   ```
5. **Copy** puts the currently displayed value on your clipboard.

Observation: same input, completely different hashes — and the "bigger" the algorithm, the longer the value. Change a single character (`hello` → `Hello`) and hash again: the entire hash changes, not just part of it (the so-called avalanche effect).

## Example 2: Verify the integrity of a download

The most common real-world case — matching a downloaded image or archive against the value published by the vendor.

1. The vendor publishes, say, a **SHA-256 checksum** for its file (often on the download page or in a `.sha256` file).
2. Drag your downloaded file into the **File Hash** area (or click the drop area and select it). Name and size are shown.
3. Click **Hash File**. After a short computation the **File Checksums** table fills with eight values.
4. Find the **SHA-256** row and compare it against the published value — ideally character by character, or, more safely, by pasting both values into a text comparison.
5. **If they match exactly**, the file is unchanged and complete. **A single differing character** means a corrupted download or a tampered file — don't use it, download again.

Tip: the table also provides MD5 and SHA-1. If the vendor (still) only gives an MD5 value, you can compare that just as well — even though SHA-256 would be the better choice (more in the [tips](https://www.jpkc.com/db/en/tools/hash/tips/)).

## Example 3: Compare two hashes safely

Sometimes you have two values and want to know whether they belong to the same input.

1. Hash the first source — say a configuration file — via **File Hash** and copy the **SHA-256** value with the row's copy button.
2. Hash the second source the same way.
3. Compare the two hex strings. If they're identical, the content is bit-for-bit equal; if they differ, the files are different — no matter how similar they look.

This works for text too: type the same sentence into the **Message** field, hash it with SHA-256, and compare against an expected value. That's how you check, for example, whether a copied string stayed unchanged in transit.

## Example 4: Create an HMAC with a key

For API signatures or webhooks you need an HMAC — a hash that additionally depends on a secret key.

1. Enter your message content in the **Message** field (e.g. the payload to be signed).
2. Enter your secret key in the **HMAC Secret Key** field. If you don't have one yet, click the **key button** next to it — it fills the field with a random 64-character passphrase.
3. Click the **HMAC** button of the desired family, usually **HMAC next to SHA-256** (HMAC-SHA-256 is the de-facto standard for signatures).
4. The **Output** field shows the HMAC as hex. **Copy** copies it.

Important: the same key + the same message always yield the same HMAC. The recipient can recompute it with the same key and thereby verify that the message is genuine and unchanged.

## Example 5: Try SHA-3 — the more modern standard

You want to use the modern Keccak-based standard.

1. Type your text into the **Message** field.
2. In the **SHA-3** block, click **256** for SHA-3 (256) or **512** for SHA-3 (512).
3. The hash appears in **Output**. SHA-3 (256), like SHA-256, produces a 64-character value, but it's a technically different algorithm — so the output is completely different from SHA-256 for the same input.

In **File Hash**, too, SHA-3 (256) and SHA-3 (512) are part of the table, in case you need to match a file against a SHA-3 reference value.

## Example 6: Process a large file

You want to compute the checksum of a large archive or ISO image.

1. Drag the file into the **File Hash** area. As long as it's **100 MB or smaller**, it's accepted (larger files are rejected with an error).
2. Click **Hash File**. For large files the computation takes noticeably longer — the progress indicator runs until all eight values are computed.
3. Since everything is computed **locally in the browser**, the file never leaves your machine — not even at 100 MB. That's the decisive difference from online services that upload your file first.

---

Go deeper: the [overview](https://www.jpkc.com/db/en/tools/hash/) for the big picture, the [manual](https://www.jpkc.com/db/en/tools/hash/manual/) for every algorithm, and the [tips & tricks](https://www.jpkc.com/db/en/tools/hash/tips/) for the security context. You can try everything directly in the [tool](https://www.jpkc.com/tools/hash/).