Compare hash algorithm output length and collision security
This hash algorithm comparison tool turns a familiar algorithm name into two practical security facts: the fixed digest length in bits and whether researchers currently consider its collision resistance broken.
Run — free
It accepts common spellings and punctuation variants, returns one canonical name, and rejects unknown algorithms explicitly. Use it to review configuration, explain a migration, or prevent an obsolete digest from quietly entering a new system. The concise JSON result is ready for policy automation and technical documentation.
What the comparison tells you
A hash function maps an input of arbitrary size to a fixed-size digest. The output length is therefore a basic property of the named algorithm: SHA-256 produces 256 bits, while SHA-512 produces 512 bits. This tool reports that size without hashing any data. It also reports whether the algorithm is currently considered cryptographically broken for collision resistance. A collision occurs when two different inputs produce the same digest. When practical collision attacks are known, an attacker may be able to construct two documents or files with an identical hash, so the digest should not be trusted as proof that content is unique or unchanged. The result uses a direct boolean to make policy checks simple. A true value is a clear migration signal; a false value means no practical break is represented by this capability, not that every possible use of the algorithm is automatically secure.
Names, aliases, and deterministic results
Algorithm names appear in many styles across configuration files and documentation. SHA-256 may be written as sha256, SHA_256, or SHA-256, and all of those identify the same function. The comparator normalizes capitalization and common separators before looking up the algorithm, then returns a stable canonical spelling. It also recognizes the conventional short names BLAKE2b and BLAKE2s as their standard 512-bit and 256-bit variants. The supported set is deliberately finite. An unfamiliar label produces an invalid-input error instead of a speculative answer, because names can hide important differences in digest size or construction. The lookup is deterministic, contains no network access, and does not depend on the current clock. That makes it suitable for build checks and repeatable documentation generation: identical input always yields identical JSON, and a misspelled or unsupported name fails visibly rather than silently selecting a nearby algorithm.
Use collision status in the right context
Collision resistance is only one security property. A result of false for collision_resistance_broken does not endorse an algorithm for password storage, message authentication, digital signatures, or every protocol. Passwords need a dedicated password-hashing construction with salt and an adjustable work factor; a fast general-purpose hash is unsuitable even when its collision resistance remains intact. Authentication usually requires a keyed construction such as HMAC rather than a bare digest. Protocol requirements, truncation, implementation quality, and preimage resistance can also change the security decision. Treat this result as a precise answer to a narrow question: whether the named algorithm has a recognized practical collision break in this capability's maintained classification. Use it to flag MD5, SHA-1, and other broken choices, then apply the standards and threat model for the system you are reviewing. Recheck security guidance during migrations because cryptanalytic conclusions and approved-algorithm policies can evolve independently.
What you can do with it
Audit application configuration
Turn algorithm labels found in manifests or settings into consistent facts and flag choices with broken collision resistance.
Prepare a hash migration
Compare the digest sizes and collision status of a legacy algorithm and its proposed replacement before changing schemas or protocols.
Validate technical documentation
Check that a document states the correct output length and uses a canonical algorithm name.
FAQ
What does it cost?
Each API request costs $0.002. The same deterministic comparison can also run in the browser.
Does this tool hash my data?
No. It accepts only an algorithm name and returns properties of that algorithm.
What does collision resistance broken mean?
It means practical methods are known for constructing different inputs that have the same digest under that algorithm.
Does a false broken status mean the algorithm is safe for passwords?
No. Password storage requires a purpose-built, salted, adjustable-cost password-hashing function; collision status alone does not establish suitability.
Which spellings are accepted?
Names are case-insensitive and common separators are ignored, so SHA-256, sha256, and SHA_256 are equivalent.
What happens for an unknown algorithm?
The request fails with an invalid-input error instead of estimating properties or selecting a similar name.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/security/hash-algorithm-compare \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"algorithm":"SHA-256"}'const res = await fetch("https://api.kit.forhosting.com/security/hash-algorithm-compare", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"algorithm": "SHA-256"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/hash-algorithm-compare",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"algorithm": "SHA-256"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/hash-algorithm-compare", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"algorithm":"SHA-256"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"algorithm":"SHA-256"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/hash-algorithm-compare", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"algorithm": "SHA-256"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.hash_algorithm_compare",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |