Hash Generator
Generate SHA-1, SHA-256, SHA-384 and SHA-512 hashes instantly from text. Create lowercase or uppercase hexadecimal hashes with private browser-based processing.
Generate Cryptographic Hash
Generate SHA-1, SHA-256, SHA-384 or SHA-512 hashes from UTF-8 text directly in your browser.
Shortcut: Ctrl/Cmd + Enter to generate
Hash Statistics
Details about the input and the currently selected hashing algorithm.
Algorithm
SHA-256
Input Characters
0
Input Bytes
0
Digest Bits
256
Digest Bytes
32
SHA Algorithm Comparison
Different SHA algorithms produce different fixed-length digests.
| Algorithm | Digest | Bytes | Hex Length | Guidance |
|---|---|---|---|---|
| SHA-1 | 160 bits | 20 | 40 | Legacy compatibility |
| SHA-256 | 256 bits | 32 | 64 | General-purpose default |
| SHA-384 | 384 bits | 48 | 96 | Longer SHA-2 digest |
| SHA-512 | 512 bits | 64 | 128 | Largest supported digest |
Small Input Changes Produce Different Hashes
Cryptographic hash functions are highly sensitive to the exact input. Changing one letter, space or line break normally produces a very different digest.
Input A
SwiftVecto
Input B
swiftvecto
Only the capitalisation changed, but the generated hashes will be completely different.
Do Not Use Raw SHA Hashes for Password Storage
SHA-1, SHA-256, SHA-384 and SHA-512 are fast general-purpose cryptographic hash functions. That speed makes them unsuitable as a direct password-storage mechanism.
Passwords should be processed with dedicated password-hashing algorithms such as Argon2 or bcrypt, using the security features provided by your application framework.
In Laravel, for example, password storage should use Laravel's hashing facilities rather than manually generating SHA hashes.
Private Browser-Based Hashing
Hash generation is performed directly inside your browser using the browser's Web Crypto API.
- No file upload is required.
- Your text does not need to be sent to SwiftVecto's server.
- UTF-8 conversion and digest generation happen locally on your device.
- The generated hexadecimal hash can be copied directly from your browser.
Continue with These Tools
Finished using Hash Generator? Here are some related tools that people commonly use next to complete their workflow faster.
Base64 Encoder / Decoder
Encode text to Base64 or decode Base64 back to readable text instantly. Supports UTF-8 and Base64URL with private browser-based processing.
JSON Formatter & Validator
Format, beautify, minify and validate JSON online instantly. Detect invalid JSON, organise nested data and create clean, readable JSON directly in your browser.
JWT Decoder & Inspector
Decode and inspect JSON Web Tokens online. View JWT headers, payloads, claims, timestamps and expiration details instantly in your browser without uploading your token.
UUID Generator
Generate secure random UUID v4 identifiers instantly online. Create single or bulk UUIDs, choose uppercase or lowercase output, remove hyphens and copy or download results directly in your browser.
Password Generator
Generate strong random or memorable passwords instantly. Choose password length, character types, symbols and easy-to-remember word combinations with secure browser-based generation.
Regex Tester
Test JavaScript regular expressions online with live match highlighting, capturing groups, named groups, flags and replacement previews directly in your browser.
URL Encoder / Decoder
Encode or decode URLs and URL components instantly. Convert special characters to percent-encoded values, decode encoded text and work with URI components or form-style query data directly in your browser.
How to Generate a Cryptographic Hash
Use the SwiftVecto Hash Generator to create SHA-1, SHA-256, SHA-384 or SHA-512 hashes from text instantly. Enter a string, choose a hashing algorithm and generate a hexadecimal message digest directly in your browser.
Overview
A cryptographic hash function converts input data into a fixed-length output commonly called a hash, digest or message digest. Unlike Base64 encoding, hashing is designed as a one-way transformation and does not provide a normal decoding operation that restores the original input. Hashes are widely used for integrity checking, digital signatures, caching, identifiers and many other development and security-related tasks. This Hash Generator supports several SHA algorithms available through modern browser cryptography APIs and provides UTF-8-aware processing so international text can be hashed consistently. It is intended for developer utilities and general hashing tasks rather than password storage, which requires specialised password-hashing algorithms such as Argon2 or bcrypt.
Benefits
How It Works
Enter or paste text into the input area.
The text is converted into its UTF-8 byte representation.
Choose the hashing algorithm you want to use.
The selected cryptographic hash function processes the complete sequence of input bytes.
The algorithm produces a fixed-length binary message digest.
The digest bytes are converted into hexadecimal characters for convenient display.
The same input processed using the same algorithm produces the same hash value.
Even a small change to the source text normally produces a substantially different digest.
Changing the selected algorithm changes both the digest calculation and its output length.
The hexadecimal result can be copied for use in development, testing or integrity checks.
How to Use This Tool
-
1Enter the text you want to hash.
-
2Choose SHA-1, SHA-256, SHA-384 or SHA-512.
-
3Choose lowercase or uppercase hexadecimal output.
-
4Select Generate Hash.
-
5Review the generated hexadecimal digest.
-
6Check the input and output statistics if needed.
-
7Copy the hash to your clipboard when using it elsewhere.
-
8Modify the input to see how even a small change produces a different digest.
-
9Use Clear to reset the tool before generating another hash.
Helpful Tips
- Use SHA-256 or a stronger SHA-2 variant for new general-purpose cryptographic hashing where appropriate.
- SHA-1 remains useful for compatibility and identifying legacy values but should not be selected for new security-sensitive collision-resistant applications.
- Do not use a raw SHA hash as a password storage mechanism.
- Password storage should use a dedicated password-hashing algorithm such as Argon2 or bcrypt with appropriate configuration.
- The exact input matters, including uppercase letters, lowercase letters, spaces and line breaks.
- A trailing space changes the hash even when it is difficult to see in the input.
- UTF-8 characters are represented by bytes before hashing, so character encoding must be consistent when comparing hashes across systems.
- Lowercase and uppercase hexadecimal hashes represent the same underlying digest bytes.
- Hashing is not encryption and there is no secret key involved in an ordinary hash operation.
- A cryptographic hash is not intended to be decoded back into the original text.
- Do not assume a hash proves who created the original data.
- A matching hash can help show that two byte sequences are identical when the same algorithm and representation are used.
- Different hashing algorithms produce different output lengths.
- SHA-256 produces 256 bits, which is 32 bytes or 64 hexadecimal characters.
- SHA-512 produces 512 bits, which is 64 bytes or 128 hexadecimal characters.
Common Uses
Generate a SHA-256 hash for a test string.
Create a SHA-512 digest while testing an application integration.
Compare hashes generated by different programming languages.
Verify that UTF-8 text is hashed consistently between frontend and backend code.
Generate test values for automated software tests.
Compare two pieces of text using their SHA-256 digests.
Generate a legacy SHA-1 value while troubleshooting an older system.
Create hexadecimal digest examples for technical documentation.
Check whether whitespace changes an expected application hash.
Generate a checksum-style value from configuration text.
Compare lowercase and uppercase hexadecimal representations.
Inspect the output length of different SHA algorithms.
Worked Examples
The following examples demonstrate how this tool can be used in realistic scenarios.
Generating a SHA-256 Hash
Enter "SwiftVecto" and select SHA-256. The tool converts the text into UTF-8 bytes and generates a 256-bit digest represented as 64 hexadecimal characters.
Detecting a Small Input Change
Generate a SHA-256 hash for "SwiftVecto", then change the input to "swiftvecto". Although only the capitalization has changed, the resulting digest is substantially different because cryptographic hash functions are highly sensitive to changes in the input bytes.
Hashing International Text
Enter text such as "Hello 世界 £ ₵". The input is converted to UTF-8 bytes before hashing, allowing the digest to be reproduced by another system that uses the same UTF-8 representation and hashing algorithm.
Comparing Application Output
A backend application generates a SHA-512 digest for a known test string. Generate the same algorithm and input in SwiftVecto and compare the hexadecimal outputs to help confirm that both implementations are processing the same bytes.
Finding Hidden Whitespace Differences
Two visually similar strings generate different hashes. Removing an accidental trailing space or line break causes the digests to match, demonstrating that hashing operates on the exact input bytes rather than only the visible characters.
Common Mistakes
Avoid these common mistakes to achieve the most accurate results.
- Assuming a cryptographic hash can simply be decoded back into the original input.
- Confusing hashing with Base64 encoding.
- Confusing hashing with encryption.
- Using raw SHA-256 or SHA-512 directly for password storage.
- Using SHA-1 for a new security-sensitive collision-resistant design.
- Comparing hashes generated using different algorithms.
- Ignoring uppercase and lowercase differences in the original input.
- Ignoring invisible spaces, tabs or line breaks in the original input.
- Comparing hashes generated from different character encodings.
- Assuming uppercase and lowercase hexadecimal output represent different digest values.
- Expecting different algorithms to produce hashes of the same length.
- Assuming that a hash by itself authenticates the person or system that generated the source data.
- Treating a hash as a substitute for a digital signature.
- Assuming matching hashes prove more than equality of the processed input under the selected algorithm.
- Copying an incomplete digest and then attempting to compare it with a full hash.
Glossary
Definitions of the most important terms used by this tool.
Hash
A fixed-length value produced by applying a hash function to input data.
Hash Function
A function that accepts input data and deterministically produces a fixed-length output value.
Cryptographic Hash Function
A hash function designed with security properties such as resistance to reversing the digest and finding different inputs with the same output.
Digest
Another common term for the output produced by a cryptographic hash function.
Message Digest
A cryptographic hash value calculated from a message or other input data.
SHA
Secure Hash Algorithm, a family of cryptographic hash functions used in many software and security systems.
SHA-1
A legacy Secure Hash Algorithm producing a 160-bit digest. It is retained for compatibility but has known collision weaknesses and should not be chosen for new collision-sensitive security designs.
SHA-256
A SHA-2 family algorithm producing a 256-bit, 32-byte digest commonly represented by 64 hexadecimal characters.
SHA-384
A SHA-2 family algorithm producing a 384-bit, 48-byte digest commonly represented by 96 hexadecimal characters.
SHA-512
A SHA-2 family algorithm producing a 512-bit, 64-byte digest commonly represented by 128 hexadecimal characters.
SHA-2
A family of Secure Hash Algorithms that includes SHA-256, SHA-384 and SHA-512.
Hexadecimal
A base-16 representation using the digits 0 through 9 and letters A through F. Hash bytes are commonly displayed as hexadecimal text.
Collision
A situation where two different inputs produce the same hash value.
Collision Resistance
A cryptographic property describing how difficult it should be to find two different inputs that produce the same digest.
Preimage Resistance
A cryptographic property describing how difficult it should be to discover an input that produces a given hash value.
Avalanche Effect
The property where a small change to the input causes substantial changes throughout the resulting hash value.
Checksum
A value used to help detect changes or errors in data. Cryptographic hashes can be used for integrity checking, although not every checksum algorithm is cryptographic.
UTF-8
A common Unicode character encoding used to convert text into bytes before those bytes are processed by the hash function.
Password Hashing
A specialised process for storing password verifiers using deliberately expensive algorithms such as Argon2 or bcrypt rather than fast general-purpose SHA functions.
Digital Signature
A cryptographic mechanism using asymmetric keys to provide authenticity and integrity. A plain hash value by itself is not a digital signature.
Frequently Asked Questions
What is a hash generator?
A hash generator takes input data and applies a hash function to produce a fixed-length digest. The same input and algorithm produce the same digest.
Which hashing algorithms does this tool support?
The initial SwiftVecto Hash Generator supports SHA-1, SHA-256, SHA-384 and SHA-512 for text-based hashing.
What is SHA-256?
SHA-256 is a member of the SHA-2 family of cryptographic hash functions. It produces a 256-bit digest, normally displayed as 64 hexadecimal characters.
What is SHA-512?
SHA-512 is a SHA-2 cryptographic hash function that produces a 512-bit digest, normally displayed as 128 hexadecimal characters.
What is the difference between SHA-256 and SHA-512?
They are different SHA-2 algorithms with different internal constructions and digest sizes. SHA-256 produces 256 bits, while SHA-512 produces 512 bits.
Is SHA-1 still secure?
SHA-1 has demonstrated collision weaknesses and should not be selected for new applications that depend on strong collision resistance. It remains available in this tool for compatibility, testing and legacy development work.
Can a hash be decoded?
A cryptographic hash is designed as a one-way transformation and has no ordinary decode operation that restores the original input. This is fundamentally different from reversible encodings such as Base64.
Is hashing the same as encryption?
No. Encryption is designed to be reversible when the appropriate key is available. Cryptographic hashing produces a digest and is not designed to recover the original source data.
Is hashing the same as Base64?
No. Base64 is reversible encoding. Hashing is a one-way transformation designed to produce a fixed-length digest.
Will the same input always produce the same hash?
Yes, provided the exact same bytes and the same hashing algorithm are used. Changes to text encoding, whitespace or capitalization change the input bytes and therefore normally change the hash.
Why does adding one character completely change the hash?
Cryptographic hash functions are designed so that small input changes affect the resulting digest extensively. This behaviour is commonly described as the avalanche effect.
Does whitespace affect a hash?
Yes. Spaces, tabs, carriage returns and line breaks are part of the input data and therefore affect the generated digest.
Does capitalization affect the hash?
Yes. Uppercase and lowercase letters have different byte values, so "SwiftVecto" and "swiftvecto" produce different hashes.
Why does SHA-256 produce 64 characters?
SHA-256 produces 256 bits, which equals 32 bytes. Each byte is represented using two hexadecimal characters, resulting in 64 hexadecimal characters.
Why does SHA-512 produce 128 characters?
SHA-512 produces 512 bits, or 64 bytes. Representing each byte with two hexadecimal characters produces a 128-character hexadecimal digest.
Does uppercase hash output change the hash?
No. Uppercase and lowercase hexadecimal are simply different textual representations of the same digest bytes. For example, "ab" and "AB" represent the same hexadecimal byte value when case is ignored.
Can I hash Unicode text?
Yes. The tool is designed to convert text into UTF-8 bytes before hashing, allowing international text, symbols and other Unicode characters to be processed consistently.
Can I use SHA-256 to store passwords?
Raw SHA-256 should not normally be used for password storage because it is intentionally fast. Password storage should use dedicated password-hashing algorithms such as Argon2 or bcrypt with appropriate salts and configuration.
Can hashes be used to check file integrity?
Cryptographic hashes are commonly used to compare file contents and detect changes. The initial version of this SwiftVecto tool hashes text rather than uploaded files, but the same general principle applies to byte data.
Does matching SHA-256 prove a file is authentic?
A matching digest can help establish that the compared bytes are the same, but a hash obtained from an untrusted source does not by itself establish authenticity. Trusted signatures or authenticated hash sources may be required depending on the security objective.
Can two different inputs have the same hash?
In principle, yes, because hash functions map an unlimited number of possible inputs into a fixed number of digest values. A secure cryptographic hash is designed to make finding such collisions computationally impractical.
Does SwiftVecto send my text to the server to generate the hash?
The interactive Hash Generator is designed to perform normal text hashing directly in your browser using supported browser cryptographic functionality, so no file upload is required.
Is this Hash Generator free?
Yes. SwiftVecto provides this online developer utility for generating SHA-1, SHA-256, SHA-384 and SHA-512 text hashes.
Things to Know
- The initial version supports SHA-1, SHA-256, SHA-384 and SHA-512.
- SHA-256, SHA-384 and SHA-512 belong to the SHA-2 family.
- SHA-1 is included for compatibility and legacy development work rather than recommendation for new collision-sensitive security applications.
- Text is interpreted as UTF-8 before hashing.
- SHA-1 produces 40 hexadecimal characters.
- SHA-256 produces 64 hexadecimal characters.
- SHA-384 produces 96 hexadecimal characters.
- SHA-512 produces 128 hexadecimal characters.
- Uppercase and lowercase hexadecimal output represent the same underlying digest.
- Normal interactive hashing is intended to happen locally inside the browser.
- This tool is not intended to implement password storage.
Disclaimer
This Hash Generator is intended for development, testing, educational and general data-integrity workflows.
Do not use raw SHA-1, SHA-256, SHA-384 or SHA-512 as a substitute for a dedicated password-hashing algorithm.
SHA-1 has known collision weaknesses and should not be selected for new applications requiring strong collision resistance.
A matching hash does not by itself authenticate the origin of data unless the expected digest is obtained through a trusted mechanism.
Users remain responsible for selecting cryptographic algorithms appropriate to their application and security requirements.
Official References
The following official resources were used when developing this tool and are useful for further reading.
NIST FIPS 180-4 - Secure Hash Standard
https://csrc.nist.gov/pubs/fips/180-4/upd1/final
MDN Web Docs - SubtleCrypto.digest()
https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
PHP Manual - hash()
https://www.php.net/manual/en/function.hash.php
OWASP Password Storage Cheat Sheet
https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html