SHA-256 हैश जनरेटर

SHA-256 हैशिंग क्या है?

SHA-256 (Secure Hash Algorithm 256-bit) SHA-2 परिवार का एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन है, जिसे NIST ने 2001 में FIPS 180-2 के भाग के रूप में प्रकाशित किया था (बाद में FIPS 180-4 में अद्यतन किया गया)। किसी भी इनपुट के लिए — एक एकल वर्ण, बहु-गीगाबाइट फ़ाइल, या रिक्त स्ट्रिंग — SHA-256 एक निश्चित 256-बिट (32-बाइट) डाइजेस्ट उत्पन्न करता है, जो परंपरागत रूप से 64 हेक्साडेसिमल वर्णों के रूप में प्रदर्शित होता है। SHA-256 आज उत्पादन प्रणालियों में सर्वाधिक व्यापक रूप से उपयोग किया जाने वाला हैश फ़ंक्शन है, जो TLS प्रमाणपत्र श्रृंखलाओं, Bitcoin के proof-of-work, Subresource Integrity (SRI) और कोड-साइनिंग कार्यप्रवाहों की नींव है।

SHA-256 एकतरफा फ़ंक्शन है: इनपुट से हैश की गणना तेज़ होती है (आधुनिक हार्डवेयर पर सैकड़ों मेगाबाइट प्रति सेकंड), परंतु इस प्रक्रिया को उलटना — किसी दिए गए हैश को उत्पन्न करने वाला इनपुट खोजना — संगणनात्मक रूप से असंभव है। यह गुण, जिसे प्रीइमेज प्रतिरोध कहते हैं, SHA-256 को पासवर्ड हैशिंग (नमक और key-stretching के साथ), डिजिटल हस्ताक्षर और डेटा अखंडता सत्यापन के लिए उपयुक्त बनाता है। MD5 और SHA-1 के विपरीत, पूर्ण SHA-256 के विरुद्ध कोई टकराव या प्रीइमेज आक्रमण प्रदर्शित नहीं किया गया है।

SHA-2 परिवार में छह प्रकार शामिल हैं: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, और SHA-512/256। SHA-256 प्रति खंड 64 चक्रों के साथ 32-बिट शब्दों पर कार्य करता है, जो 32-बिट प्रोसेसर के लिए अनुकूलित है। SHA-512 64-बिट शब्दों और 80 चक्रों का उपयोग करता है, जो 64-बिट प्लेटफ़ॉर्म पर तेज़ हो सकता है। अधिकांश अनुप्रयोगों के लिए जहाँ 256-बिट डाइजेस्ट पर्याप्त है, SHA-256 NIST, IETF और CA/Browser Forum की डिफ़ॉल्ट अनुशंसा बना रहता है।

ऑनलाइन SHA-256 जनरेटर क्यों उपयोग करें?

SHA-256 हैश जेनरेट करने के लिए सामान्यतः एक टर्मिनल आदेश या कुछ पंक्तियों का कोड आवश्यक होता है। यह ब्राउज़र-आधारित टूल आपको कुछ भी इंस्टॉल किए बिना, संदर्भ बदले बिना, या कोई स्क्रिप्ट लिखे बिना SHA-256 डाइजेस्ट की गणना करने देता है।

SHA-256 के उपयोग के मामले

SHA-2 परिवार के प्रकारों की तुलना

SHA-256 FIPS 180-4 में परिभाषित SHA-2 परिवार से संबंधित है। प्रत्येक प्रकार डाइजेस्ट आकार, प्रदर्शन विशेषताओं और सुरक्षा मार्जिन के बीच संतुलन बनाता है। नीचे दी गई तालिका SHA-2 के उन सभी प्रकारों की तुलना करती है जिनका आप उपयोग करने की संभावना रखते हैं।

SHA-256 बनाम SHA-1 बनाम MD5 बनाम SHA-3

सही हैश एल्गोरिथम चुनना आपकी सुरक्षा आवश्यकताओं और अनुकूलता बाधाओं पर निर्भर करता है। SHA-256 व्यावहारिक दृष्टि से सर्वोत्तम स्थिति में है: यह सुरक्षित है, सार्वभौमिक रूप से समर्थित है (Web Crypto API सहित), और अधिकांश कार्यभार के लिए पर्याप्त तेज़ है। नीचे दी गई तुलना तालिका उन गुणों को शामिल करती है जो हैश फ़ंक्शन चुनते समय सर्वाधिक महत्वपूर्ण हैं।

SHA-256 आंतरिक रूप से कैसे काम करता है

SHA-256 Merkle–Damgård संरचना के माध्यम से इनपुट को 512-बिट (64-बाइट) खंडों में संसाधित करता है। यह एल्गोरिथम आठ 32-बिट अवस्था शब्दों (H0–H7) को आरंभ करता है जो पहले आठ अभाज्य संख्याओं के वर्गमूलों के भिन्नात्मक भागों से व्युत्पन्न हैं। प्रत्येक खंड मिश्रण के 64 चक्रों से गुजरता है जो बिटवाइज़ संक्रियाओं (AND, XOR, NOT, दाएँ-घूर्णन, दाएँ-स्थानांतरण) और पहली 64 अभाज्य संख्याओं के घनमूलों से व्युत्पन्न 64 चक्र स्थिरांकों का उपयोग करते हैं।

एवलांश प्रभाव सुनिश्चित करता है कि इनपुट में एक बिट बदलने से आउटपुट बिट के लगभग 50% बदल जाते हैं। यह गुण, 2^128 टकराव प्रतिरोध के साथ मिलकर, यही कारण है कि SHA-256 2026 में सुरक्षा-संवेदनशील अनुप्रयोगों के लिए आधारभूत अनुशंसा बना हुआ है।

SHA-256 कोड उदाहरण

SHA-256 प्रत्येक प्रमुख भाषा और रनटाइम में मूल रूप से उपलब्ध है। Web Crypto API इसे ब्राउज़र में बिना किसी लाइब्रेरी के प्रदान करता है। नीचे दिए गए उदाहरण Unicode इनपुट प्रबंधन और फ़ाइल हैशिंग सहित वास्तविक उपयोग पैटर्न दर्शाते हैं।

// Works in all modern browsers and Node.js 18+
async function sha256(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha256').update('hello world').digest('hex')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha256()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

अक्सर पूछे जाने वाले प्रश्न