Hash generator

Hash Generator converts the entered text to UTF-8 bytes and passes those bytes to the browser's Web Crypto digest function. You can choose SHA-256, SHA-384, or SHA-512. The result is displayed as lowercase hexadecimal with two characters for every digest byte. SHA-256 produces 64 hexadecimal characters, SHA-384 produces 96, and SHA-512 produces 128.

A cryptographic hash is deterministic: identical bytes under the same algorithm produce the same digest. A one-character change, added newline, or different Unicode sequence normally produces a completely different result. The digest does not contain a reversible copy of the text. Hashing is therefore useful for comparison and fingerprints, but it is not encryption and cannot recover a forgotten input.

The tool hashes text only. It does not accept file uploads, stream file bytes, generate HMAC values, add a salt, stretch passwords, or sign the digest. Those operations have separate inputs and security properties.

Use the algorithm required by the protocol, test vector, or system you are comparing against. SHA-256 is the common default for content fingerprints and many API examples. SHA-384 and SHA-512 produce longer digests and are used by protocols that specify them. A longer output is not automatically compatible with a field designed for SHA-256.

Algorithm names are not interchangeable. The SHA-256 digest of `hello` cannot be compared with its SHA-512 digest, even though both were produced from the same bytes. Record the algorithm beside the value. A bare hexadecimal string does not identify which hash function created it, and its length is only a clue.

This selector does not include SHA-1, MD5, SHA-3, BLAKE families, or password-specific functions. Do not substitute an available algorithm when an external specification names another one. Use an implementation that supports the required standard and verify against published test vectors.

The browser's TextEncoder turns JavaScript text into UTF-8. ASCII examples therefore match tools that hash the same visible characters without an added newline. Non-ASCII text also works, but both sides must use UTF-8 and the same Unicode code-point sequence. A precomposed accented character can hash differently from an identical-looking letter plus combining mark.

Whitespace changes the digest. `hello`, `hello `, and `hello` followed by a newline are three different byte sequences. Command-line commands often append a newline unless told not to, which is a frequent reason a terminal result differs from the browser. Check the command's behavior and inspect the source in an editor that can display line endings.

The tool does not trim, normalize, lowercase, parse JSON, or convert line endings. If you hash pretty-printed JSON and then minified JSON, the digests differ even when both documents describe equivalent data. Decide if the comparison fingerprints raw text, canonical data, or a serialized format before comparing values.

Paste the exact text, select the required SHA algorithm, and run Hash Generator. Copy the hexadecimal result with its algorithm label. To verify content later, reproduce the same UTF-8 bytes, hash them with the same algorithm, and compare all hexadecimal characters. A partial match is not a valid confirmation.

For an API signing test, separate the steps. First construct the canonical string exactly as the API documents, including separators and line breaks. Generate its digest. Then compare that value with the intermediate digest from your application. This tool does not create the final signature or HMAC, so it can isolate the text-hashing stage without proving the complete request is authentic.

Keep a nonsecret test vector in project documentation: input, encoding, algorithm, and expected digest. Include an empty string and a multibyte character case. Tests catch accidental trimming or encoding changes when code moves between browser, server, and command-line environments.

A matching digest supports the claim that the compared byte sequences are the same under the chosen algorithm. It does not identify who supplied the content. If an attacker can replace both a message and its published hash, the comparison provides no authenticity. Signed checksums, HMACs, or authenticated distribution channels address different threats.

This text tool cannot verify a downloaded file checksum because it hashes characters entered into a textarea, not the file's raw bytes. Opening a binary file as text changes or loses bytes. Use a file hashing command or trusted application for installers, archives, images, and documents. Compare the algorithm and full digest against a value obtained through an independent channel.

For logs or database fields, decide what is stable before hashing. Timestamps, key order, insignificant spaces, and generated identifiers can make semantically similar records produce different fingerprints. Canonicalization must be defined by the application; the hash function cannot decide which differences should be ignored.

Do not store passwords as a direct SHA-256, SHA-384, or SHA-512 digest. These functions are intentionally fast, which lets an attacker test large numbers of guesses quickly after a database leak. Password storage needs a password-hashing function with a unique salt and a configurable cost, chosen according to the application's security guidance.

Adding a fixed word before hashing is not an adequate password scheme. A salt must be unique per password, and the dedicated function should consume time and often memory. This workbench does not provide Argon2, scrypt, bcrypt, or PBKDF2 configuration. Use a maintained authentication library and store the parameters required for later verification.

The same caution applies to API secrets. A plain digest does not prove possession of a secret in a message exchange. HMAC combines a hash function with a secret key under a defined construction. Concatenating a key and message manually is not a safe replacement for an HMAC implementation.

Digest calculation stays inside the browser tab. Neither the source text nor its resulting hash is submitted to PWRKIT for remote processing. The source still exists in the page, memory, and clipboard, and may be visible to browser extensions, managed-device tooling, screen sharing, or local session recovery. Avoid entering production secrets in an unapproved environment.

A digest can also be sensitive. Hashes of predictable identifiers, email addresses, phone numbers, or short codes can be guessed by hashing likely candidates. Removing the original value from sight does not make the digest anonymous. Apply privacy rules based on what can be inferred and how the output will be shared.

Use disposable examples in support tickets and screenshots. Clear the fields after work, and do not paste a digest into logs unless the logging policy permits it. For a production integrity process, generate hashes inside the controlled application or build pipeline where inputs and audit records are managed.

Start with the algorithm and output format. Confirm that both tools used SHA-256, SHA-384, or SHA-512 as intended, and determine whether the other output is hexadecimal or Base64. The same digest bytes can be displayed in either representation, so unlike-looking strings may need format conversion before comparison.

Next compare source bytes. Check UTF-8 versus another character encoding, Unicode normalization, byte-order marks, capitalization, spaces, tabs, line-ending style, and a final newline. For structured data, confirm serialization order and escaping. Work from a tiny known input, then add content until the mismatch appears.

Use Base64 Encode only when a protocol asks for a Base64 representation of text or bytes. Use JSON Formatter to expose raw formatting differences in JSON, but remember that formatting changes the text digest. Use a UUID generator for random identifiers, not for content fingerprints. Each tool answers a different question, and mixing them can hide the original mismatch.

Web Crypto returns digest bytes. This workbench converts each byte to two lowercase hexadecimal digits and joins them without spaces or a prefix. Another system may display uppercase hexadecimal, colon-separated bytes, a leading `0x`, or Base64. Convert both displays to the same representation before deciding that the digest bytes differ.

Hexadecimal letter case carries no difference in byte value, but string comparisons can still be case-sensitive. Normalize a trusted digest representation in code, validate its expected length, and compare the full value. Reject truncated, oddly sized, or nonhexadecimal input instead of padding it.

A content-addressed name often combines an algorithm label with a digest. Keep that label because algorithms can share display formats. If a migration changes algorithms, store old and new digests in separate fields or tagged forms. Do not overwrite the only reference before all consumers understand the change.

When comparing untrusted values in a security protocol, use the comparison method required by the library. Ordinary string comparison can reveal timing information in some server contexts. This browser page only generates output and does not implement authentication-grade verification.

Copy errors can be subtle. Select the result through the copy control, then check the first eight characters, last eight characters, and total length against the destination. A missing final character changes the represented bytes and must fail a full comparison.

Store test vectors in plain, reviewable files with an explicit note about final newlines. If the input contains a null byte or another control character, a textarea may be a poor authoring surface. Construct the byte sequence programmatically and verify with a byte-oriented hashing tool.

Content verification also needs a trusted expected value. A checksum copied from the same compromised download location as the file may be replaced alongside it. Obtain release hashes through the publisher's authenticated site, signed manifest, package registry, or another channel named by the project. This browser text tool cannot establish that trust chain. It can only calculate a digest for the characters entered. For reproducible builds, document how artifacts are created, hash raw files in automation, publish the algorithm, and retain signed provenance where the release process requires it.