पाठ्यक्रम 156 में से पाठ 84 · Encryption जिसे आप समझा सकें
Encryption जिसे आप समझा सकें

एक signature सत्यापित करें

यह क्यों मायने रखता है आपके फ़ोन का install किया हर software update, ताले के पीछे का हर certificate, और हर passkey login एक जाँच पर टिका है: "क्या यह सचमुच सही key से sign हुआ था?" वह जाँच ख़ुद एक बार करना signatures को जादू से ऐसी चीज़ में बदल देता है जिसे आप समझा सकें।

एक signature एक ऐसी अंगूठी से लगी मोम की मुहर की तरह काम करता है जो सिर्फ़ मालिक के पास है। जो कोई जानता है कि अंगूठी का pattern कैसा दिखता है वह मुहर जाँच सकता है, पर कोई और उसे बना नहीं सकता। और अगर मुहर के बाद चिट्ठी बदली जाए, तो मुहर अब मेल नहीं खाती।

Digital signature: एक संदेश और एक private key से बनी संख्या। मेल खाती public key वाला कोई भी जाँच सकता है कि मालिक ने इसे बनाया, और तब से संदेश नहीं बदला।

क़दम 1: एक hash से संदेश का fingerprint बनाएँ

Hash: एक function जो किसी भी डेटा को एक छोटे तय आकार के fingerprint में बदलता है। एक ही input हमेशा एक ही fingerprint देता है, एक छोटा बदलाव बिल्कुल अलग देता है, और आप इसे उल्टा नहीं चला सकते। SHA-256 एक आम है।

import hashlib
print(hashlib.sha256(b"Lunch at 1pm").hexdigest()[:16])
print(hashlib.sha256(b"Lunch at 2pm").hexdigest()[:16])
# two completely different fingerprints

पूरे संदेश के बजाय fingerprint को sign करना चीज़ें छोटी और तेज़ रखता है। इस पर गणित करने के लिए, 32 bytes को int.from_bytes(digest, "big") से एक बड़ी पूर्ण संख्या में बदलें, फिर % n से n से भाग देने के बाद का शेषफल लें ताकि वह key में समा जाए।

क़दम 2: public key से signature खोलें

पाठ 81 के खिलौना RSA में मालिक private d से pow(fingerprint, d, n) निकालकर sign करता है। जाँचने के लिए आप public e से pow(signature, e, n) निकालते हैं। अगर नतीजा उस fingerprint के बराबर है जो आपने ख़ुद निकाला, तो signature असली है।

Python में एक key एक tuple में संख्याओं की एक जोड़ी है, जैसे public_key = (n, e)। पंक्ति n, e = public_key इसे खोलती है: यह पहली संख्या n में और दूसरी e में रखती है।

signer:   signature = pow(fingerprint, d, n)      # needs the private key
checker:  pow(signature, e, n) == fingerprint ?   # needs only the public key

अगर कोई संदेश बदलता है, तो उसका fingerprint बदल जाता है और अब मेल नहीं खाता। अगर वे signature बदलते हैं, तो उसे खोलने पर एक अलग संख्या मिलती है। और अगर कोई Ana (इस अभ्यास में भेजने वाली) होने का दिखावा करते हुए अपनी private key से sign करे, तो Ana की public key से आपकी जाँच विफल होती है। तीनों एक तुलना से पकड़े जाते हैं।

ज़रूरी: यह छोटी keys और बिना padding वाला खिलौना RSA है, सिर्फ़ सीखने के लिए। असली signatures जाँची-परखी libraries और Ed25519 या PSS padding वाले RSA जैसी योजनाएँ इस्तेमाल करते हैं। असली डेटा की रक्षा के लिए कभी घर की बनी cryptography इस्तेमाल न करें।

एक आम ग़लतफ़हमी: "एक signature संदेश छिपाता है"। नहीं छिपाता; संदेश खुले में जाता है। एक signature साबित करता है कि इसे किसने बनाया और यह बदला नहीं। इसे छिपाना encryption का काम है।

दूसरी भाषाओं में

असली code एक library से सत्यापित करता है। हर call हाथ से संख्याएँ मिलाने के बजाय true या false लौटाता है (या एक error उठाता है)।

# Python, with the cryptography package (Ed25519)
from cryptography.exceptions import InvalidSignature
try:
    public_key.verify(signature, message)   # raises if it does not match
    ok = True
except InvalidSignature:
    ok = False
// JavaScript (browser Web Crypto, ECDSA)
const ok = await crypto.subtle.verify(
  { name: "ECDSA", hash: "SHA-256" }, publicKey, signature, messageBytes);
// Go (crypto/ed25519)
ok := ed25519.Verify(publicKey, message, signature)
// PHP (libsodium, built in)
$ok = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
// C# (.NET)
bool ok = ecdsa.VerifyData(message, signature, HashAlgorithmName.SHA256);

सार

  • एक signature साबित करता है कि संदेश किसने बनाया और वह बदला नहीं। यह उसे छिपाता नहीं।
  • पहले संदेश का hash बनाएँ, फिर उस fingerprint से signature जाँचें।
  • जाँचने के लिए सिर्फ़ public key चाहिए; sign करने के लिए private key।
  • खिलौना RSA समझने के लिए है; असली code जाँची-परखी libraries इस्तेमाल करता है।
आपकी बारी

Ana अपने संदेश खिलौना RSA से sign करती है। उसकी public key PUBLIC_KEY = (n, e) है, और INBOX में (message, signature) जोड़े हैं, कुछ से छेड़छाड़ हुई है। तीन functions लिखें:

  1. message_number(message, n): संदेश (UTF-8 bytes) का SHA-256 digest, int.from_bytes(digest, "big") से एक संख्या के रूप में, n modulo लौटाएँ।
  2. verify(message, signature, public_key): n, e खोलें, और True सिर्फ़ तब लौटाएँ जब pow(signature, e, n) message_number(message, n) के बराबर हो, नहीं तो False।
  3. genuine_messages(inbox, public_key): उन संदेश टेक्स्ट की सूची लौटाएँ जिनके signatures सत्यापित हों, inbox क्रम में।
आख़िरी पंक्तियाँ असली संदेश print करती हैं। Tests नए संदेश और keys इस्तेमाल करते हैं, इसलिए जवाब hard-code नहीं हो सकता।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।