SHA-512 Hash Generator
किसी भी टेक्स्ट से SHA-512 हैश जेनरेट करें
इनपुट टेक्स्ट
SHA-512 हैश
SHA-512 हैश यहाँ दिखाई देगा…
SHA-512 हैशिंग क्या है?
SHA-512 एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन है जिसे NIST FIPS 180-4 में SHA-2 परिवार के सबसे बड़े सदस्य के रूप में परिभाषित किया गया है। यह मनमानी लंबाई का इनपुट स्वीकार करता है और एक निश्चित 512-बिट (64-बाइट) संदेश डाइजेस्ट उत्पन्न करता है, जो 128-वर्ण की हेक्साडेसिमल स्ट्रिंग के रूप में प्रदर्शित होती है। SHA-512 का उपयोग डिजिटल हस्ताक्षरों (Ed25519 आंतरिक रूप से SHA-512 पर निर्भर है), HMAC संरचनाओं, फ़ाइल अखंडता सत्यापन, और उन क्रिप्टोग्राफ़िक प्रोटोकॉल में होता है जिन्हें व्यापक सुरक्षा मार्जिन की आवश्यकता होती है।
SHA-512, 64-बिट शब्द गणित और मिश्रण के 80 चक्रों का उपयोग करते हुए 1024-बिट (128-बाइट) खंडों पर कार्य करता है। इसके आठ प्रारंभिक हैश मान पहली आठ अभाज्य संख्याओं के वर्गमूलों के भिन्नात्मक भागों से व्युत्पन्न हैं, और इसके 80 चक्र-स्थिरांक पहली 80 अभाज्य संख्याओं के घनमूलों के भिन्नात्मक भागों से आते हैं। चूँकि यह मूल 64-बिट संक्रियाओं का उपयोग करता है, SHA-512 आधुनिक 64-बिट प्रोसेसर पर SHA-256 की तुलना में प्रायः तेज़ होता है, भले ही यह एक लंबा डाइजेस्ट उत्पन्न करता है।
SHA-384, SHA-512/224, और SHA-512/256 — ये सभी SHA-512 के खंडित प्रकार हैं जो एक ही आंतरिक संरचना साझा करते हैं किंतु भिन्न प्रारंभिक हैश मानों का उपयोग करते हैं और कम बिट आउटपुट करते हैं। जब आपको SHA-2 परिवार की अधिकतम डाइजेस्ट लंबाई चाहिए, या जब कोई प्रोटोकॉल विशेष रूप से SHA-512 अनिवार्य करता है (जैसे Ed25519 या कुछ HMAC-आधारित कुंजी व्युत्पत्ति योजनाएँ), तो SHA-512 उचित विकल्प है। यह 256 बिट का टकराव प्रतिरोध प्रदान करता है, जो SHA-3-512 के बराबर है और SHA-256 की 128-बिट सीमा से बहुत अधिक है।
ऑनलाइन SHA-512 जनरेटर क्यों उपयोग करें?
SHA-512 हैश परिकलित करने के लिए सामान्यतः एक टर्मिनल आदेश या कोड की कुछ पंक्तियाँ आवश्यक होती हैं। यह ब्राउज़र-आधारित टूल आपको कोई सॉफ़्टवेयर इंस्टॉल किए बिना, टर्मिनल पर जाए बिना, या अस्थायी स्क्रिप्ट लिखे बिना SHA-512 डाइजेस्ट तुरंत जेनरेट करने देता है।
SHA-512 Hash Generator के उपयोग के मामले
SHA-2 परिवार के प्रकारों की तुलना
SHA-512, FIPS 180-4 में परिभाषित SHA-2 परिवार का सदस्य है। नीचे दी गई तालिका SHA-512 की 64-बिट आंतरिक संरचना साझा करने वाले SHA-2 प्रकारों की तुलना करती है, साथ ही संदर्भ के लिए SHA-256 भी शामिल है।
| प्रकार | डाइजेस्ट आकार | हेक्स लंबाई | बाइट आकार | सर्वोत्तम उपयोग |
|---|---|---|---|---|
| SHA-256 | 256 bits | 64 hex chars | 32 bytes | TLS certificates, blockchain, JWTs, SRI |
| SHA-384 | 384 bits | 96 hex chars | 48 bytes | TLS 1.3 CertificateVerify, CNSA/Suite B |
| SHA-512 | 512 bits | 128 hex chars | 64 bytes | Digital signatures, HMAC, Ed25519, file integrity |
| SHA-512/224 | 224 bits | 56 hex chars | 28 bytes | SHA-512 speed on 64-bit CPUs, 224-bit output |
| SHA-512/256 | 256 bits | 64 hex chars | 32 bytes | SHA-512 speed on 64-bit CPUs, 256-bit output |
SHA-512 बनाम SHA-256 बनाम SHA-384 बनाम SHA-3-512
सही हैश एल्गोरिथम आपकी सुरक्षा आवश्यकताओं, प्रदर्शन की बाधाओं और प्रोटोकॉल विनिर्देशों पर निर्भर करता है। SHA-512, SHA-2 परिवार में सबसे व्यापक डाइजेस्ट प्रदान करता है और 64-बिट हार्डवेयर पर SHA-256 की तुलना में प्रायः तेज़ होता है। यह तुलना उन गुणों को समाहित करती है जो चुनाव करते समय सर्वाधिक महत्वपूर्ण हैं।
| गुण | SHA-512 | SHA-256 | SHA-384 | SHA-3-512 |
|---|---|---|---|---|
| Digest size | 512 bits (128 hex) | 256 bits (64 hex) | 384 bits (96 hex) | 512 bits (128 hex) |
| Block size | 1024 bits | 512 bits | 1024 bits | 1600 bits (sponge) |
| Word size | 64 bits | 32 bits | 64 bits | N/A (sponge) |
| Rounds | 80 | 64 | 80 | 24 |
| Collision resistance | 2^256 operations | 2^128 operations | 2^192 operations | 2^256 operations |
| Security status | Secure | Secure | Secure | Secure |
| Standard | FIPS 180-4 | FIPS 180-4 | FIPS 180-4 | FIPS 202 |
| Web Crypto API | Yes | Yes | Yes | No |
| 64-bit optimized | Yes | No (32-bit words) | Yes | Yes |
| Primary use today | Ed25519, HMAC, file checksums | TLS, blockchain, SRI | TLS 1.3, CNSA | Backup standard |
SHA-512 आंतरिक रूप से कैसे काम करता है
SHA-512, Merkle–Damgård संरचना का उपयोग करते हुए 1024-बिट खंडों के माध्यम से इनपुट को संसाधित करता है। यह आठ 64-बिट अवस्था शब्दों (H0–H7) को पहली आठ अभाज्य संख्याओं के वर्गमूलों के भिन्नात्मक भागों से आरंभ करता है। प्रत्येक खंड 80 मिश्रण चक्रों से गुजरता है जो 64-बिट शब्दों पर बिटवाइज़ संक्रियाओं (AND, XOR, NOT, दाईं ओर घुमाना, दाईं ओर खिसकाना) का उपयोग करते हैं, जो पहली 80 अभाज्य संख्याओं के घनमूलों से प्राप्त 80 चक्र-स्थिरांकों के साथ संयुक्त होते हैं।
SHA-512: 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f
989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f
(512 bits = 64 bytes = 128 hex characters)
| चरण | विवरण |
|---|---|
| Padding | Append a 1-bit, then zeros until the message length is 896 mod 1024. Append the original length as a 128-bit big-endian integer. |
| Block splitting | Divide the padded message into 1024-bit (128-byte) blocks. |
| Message schedule | Expand each 16-word (64-bit) block into 80 words using sigma functions with right-rotate and right-shift operations on 64-bit values. |
| Compression | Process 80 rounds per block using Ch, Maj, and two Sigma functions with 80 round constants derived from the cube roots of the first 80 primes. |
| Output | Concatenate the eight 64-bit state words (H0–H7) into a 512-bit (64-byte) digest, rendered as 128 hexadecimal characters. |
व्यापक 64-बिट शब्द आकार SHA-256 से मुख्य अंतर है। 64-बिट CPU पर, प्रत्येक संक्रिया प्रति चक्र दोगुने बिट संसाधित करती है, इसीलिए SHA-512 बेंचमार्क में SHA-256 की तुलना में प्रायः बेहतर प्रदर्शन करता है, भले ही यह 64 के बजाय 80 चक्र चलाता है। Avalanche प्रभाव सुनिश्चित करता है कि एक इनपुट बिट बदलने से सभी 512 आउटपुट बिट में से लगभग 50% बदल जाते हैं।
SHA-512 कोड उदाहरण
SHA-512 प्रत्येक प्रमुख भाषा और रनटाइम में मूल रूप से समर्थित है। Web Crypto API इसे ब्राउज़र में बिना किसी लाइब्रेरी के प्रदान करता है। नीचे दिए गए उदाहरण Unicode हैंडलिंग और फ़ाइल हैशिंग सहित सामान्य प्रतिरूपों को समाहित करते हैं।
// Works in all modern browsers and Node.js 18+
async function sha512(text) {
const data = new TextEncoder().encode(text)
const hashBuffer = await crypto.subtle.digest('SHA-512', data)
const hashArray = Array.from(new Uint8Array(hashBuffer))
return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}
await sha512('hello world')
// → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"
// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha512').update('hello world').digest('hex')
// → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"import hashlib
# Basic SHA-512 hash
result = hashlib.sha512(b'hello world').hexdigest()
print(result)
# → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee..."
# Hash a string with Unicode (encode to bytes first)
text = 'café ☕'
hashlib.sha512(text.encode('utf-8')).hexdigest()
# → 128-character hex string
# Hash a large file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
sha = hashlib.sha512()
for chunk in iter(lambda: f.read(8192), b''):
sha.update(chunk)
print(sha.hexdigest())package main
import (
"crypto/sha512"
"fmt"
)
func main() {
data := []byte("hello world")
hash := sha512.Sum512(data)
fmt.Printf("%x\n", hash)
// → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f...
}# Using sha512sum (Linux) or shasum (macOS) echo -n "hello world" | sha512sum # → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee... - # macOS echo -n "hello world" | shasum -a 512 # → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee... - # Verify a file checksum echo "309ecc48... myfile.bin" | sha512sum -c # → myfile.bin: OK # Using openssl (cross-platform) echo -n "hello world" | openssl dgst -sha512 # → SHA2-512(stdin)= 309ecc489c12d6eb4cc40f50c902f2b4...