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

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

SHA-1 (Secure Hash Algorithm 1) एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन है जो किसी भी इनपुट से एक निश्चित 160-बिट (20-बाइट) डाइजेस्ट उत्पन्न करता है। NSA द्वारा प्रकाशित और NIST द्वारा 1995 में FIPS PUB 180-1 के रूप में मानकीकृत तथा बाद में RFC 3174 में प्रलेखित, SHA-1 को SHA-0 और MD5 के एक अधिक सुरक्षित उत्तराधिकारी के रूप में अभिकल्पित किया गया था। यह एल्गोरिथम इनपुट को 512-बिट खंडों में बिटवाइज़ संक्रियाओं के 80 चक्रों के माध्यम से संसाधित करता है, और एक 40-वर्णों का हेक्साडेसिमल फ़िंगरप्रिंट उत्पन्न करता है जो एक दशक से अधिक समय तक SSL/TLS, PGP, SSH और IPsec की नींव रहा।

सभी क्रिप्टोग्राफ़िक हैश फ़ंक्शनों की तरह, SHA-1 एकतरफा रूपांतरण है: इनपुट से हैश की गणना तेज़ होती है, परंतु केवल हैश से मूल इनपुट पुनः प्राप्त करना संगणनात्मक रूप से असंभव है। इनपुट में एक भी बिट का परिवर्तन पूरी तरह अलग 160-बिट डाइजेस्ट उत्पन्न करता है — इस गुण को एवलांश प्रभाव कहते हैं। SHA-1 एक मनमाने रूप से बड़े इनपुट स्थान को निश्चित 160-बिट आउटपुट पर मैप करता है, जिसका अर्थ है कि टकराव (दो भिन्न इनपुट से एक ही हैश) गणितीय रूप से अवश्यंभावी हैं। एक हैश फ़ंक्शन का सुरक्षा दावा यह है कि ऐसे टकराव खोजने के लिए लगभग 2^80 संक्रियाओं की आवश्यकता होनी चाहिए — जो आउटपुट बिट लंबाई का आधा है।

2017 में Google और CWI Amsterdam ने SHAttered आक्रमण प्रकाशित किया, जिसमें एक ही डाइजेस्ट वाली दो भिन्न PDF फ़ाइलें तैयार करके पहला व्यावहारिक SHA-1 टकराव प्रदर्शित किया गया। इस आक्रमण के लिए लगभग 2^63.1 SHA-1 संगणनाओं की आवश्यकता थी — जो सैद्धांतिक 2^80 सीमा से बहुत कम है। 2020 में Gaetan Leurent और Thomas Peyrin ने चुनित-उपसर्ग टकराव आक्रमण से लागत को लगभग 2^63.4 संक्रियाओं तक और घटा दिया। परिणामस्वरूप, सभी प्रमुख ब्राउज़र, प्रमाणपत्र प्राधिकरण और मानक निकायों ने डिजिटल हस्ताक्षर और TLS प्रमाणपत्रों के लिए SHA-1 को अप्रचलित घोषित कर दिया है। तथापि, SHA-1 गैर-सुरक्षा उद्देश्यों के लिए अभी भी उपयोग में है: Git ऑब्जेक्ट आईडी (हालाँकि Git SHA-256 में स्थानांतरित हो रहा है), पुरानी HMAC संरचनाएँ, और फ़ाइल अखंडता चेकसम जहाँ प्रतिकूल टकराव-प्रतिरोध आवश्यक नहीं है।

यह SHA-1 जनरेटर क्यों उपयोग करें?

कुछ भी इंस्टॉल किए बिना या कोड लिखे बिना तत्काल SHA-1 हैश जेनरेट करें। अपना टेक्स्ट चिपकाएँ और वास्तविक समय में 40-वर्णों का हेक्स डाइजेस्ट प्राप्त करें — पुराने चेकसम सत्यापित करने, Git आंतरिक संरचना में समस्या निवारण करने या हैश-आधारित कार्यप्रवाह परीक्षण के लिए उपयोगी।

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

SHA-1 बनाम अन्य हैश एल्गोरिथम

SHA-1 एक 160-बिट डाइजेस्ट उत्पन्न करता है — MD5 (128 बिट) से अधिक लंबा, परंतु SHA-2 परिवार के एल्गोरिथम से काफी छोटा। नीचे दी गई तालिका प्रत्येक एल्गोरिथम के लिए डाइजेस्ट आकार, मानक और उपयुक्त उपयोग के मामलों की तुलना करती है।

SHA-1 कैसे काम करता है

SHA-1 Merkle-Damgård संरचना का अनुसरण करता है: संदेश को पैड किया जाता है, 512-बिट खंडों में विभाजित किया जाता है, और प्रत्येक खंड को बिटवाइज़ संक्रियाओं के 80 चक्रों के माध्यम से संसाधित किया जाता है जो इनपुट को खंड से व्युत्पन्न संदेश अनुसूची के साथ मिश्रित करते हैं। पाँच 32-बिट अवस्था शब्द (H0 से H4) चालू हैश अवस्था वहन करते हैं, और इन शब्दों का अंतिम संयोजन 160-बिट डाइजेस्ट उत्पन्न करता है।

SHA-1 और MD5 के बीच मुख्य अंतर अवस्था शब्दों की संख्या (5 बनाम 4), प्रति खंड चक्रों की संख्या (80 बनाम 64), और वाम-रोटेट फ़ीडबैक के साथ संदेश अनुसूची का उपयोग है। इन अंतरों से SHA-1 को MD5 की तुलना में बड़ा आउटपुट (160 बनाम 128 बिट) मिलता है और मूलतः अधिक सुरक्षा मार्जिन प्राप्त होता था, हालाँकि अब दोनों एल्गोरिथम टकराव-प्रतिरोध के लिए दोषपूर्ण माने जाते हैं।

कोड उदाहरण

लोकप्रिय भाषाओं और परिवेशों में SHA-1 हैश जेनरेट करने का तरीका। MD5 के विपरीत, SHA-1 ब्राउज़र Web Crypto API में उपलब्ध है, जिससे यह ब्राउज़र और Node.js दोनों परिवेशों में बाहरी लाइब्रेरी के बिना उपयोग योग्य है।

// SHA-1 is available in the Web Crypto API
async function sha1(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-1', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha1('hello world')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

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

import hashlib

# Basic SHA-1 hash
result = hashlib.sha1(b'hello world').hexdigest()
print(result)  # → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a string (encode to bytes first)
text = 'hello world'
hashlib.sha1(text.encode('utf-8')).hexdigest()
# → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a file in chunks
with open('file.bin', 'rb') as f:
    sha1 = hashlib.sha1()
    for chunk in iter(lambda: f.read(8192), b''):
        sha1.update(chunk)
    print(sha1.hexdigest())

package main

import (
    "crypto/sha1"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha1.Sum(data)
    fmt.Printf("%x\n", hash)
    // → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
}

# Using sha1sum (Linux) or shasum (macOS)
echo -n "hello world" | sha1sum
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# macOS
echo -n "hello world" | shasum -a 1
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# Hash a file
sha1sum package.json
# → a1b2c3d4e5f6...  package.json

# Using openssl (cross-platform)
echo -n "hello world" | openssl sha1
# → SHA1(stdin)= 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

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