Go (Golang) में क्रिप्टोग्राफी: एन्क्रिप्शन और हैशिंग

Go (Golang) में क्रिप्टोग्राफी: डेटा का एन्क्रिप्शन और हैशिंग

Go (Golang) भाषा क्रिप्टोग्राफ़िक संचालन के लिए एक शक्तिशाली और सुरुचिपूर्ण मानक पुस्तकालय प्रदान करती है। कई अन्य भाषाओं के विपरीत, जहाँ तृतीय-पक्ष पैकेज स्थापित करने की आवश्यकता होती है, Go में सममित और असममित एन्क्रिप्शन, साथ ही आधुनिक हैशिंग एल्गोरिदम का समर्थन "बॉक्स से बाहर" शामिल है। इस लेख में, हम विस्तार से जानेंगे कि शैक्षिक पोर्टल pythonlib.ru पर डेटा सुरक्षा के लिए Go में क्रिप्टोग्राफी का उपयोग कैसे करें।

Go में क्रिप्टोग्राफी के मुख्य पैकेज

Go में सभी क्रिप्टोग्राफी पैकेज crypto और इसके उप-पैकेजों में केंद्रित है। यहाँ उनमें से प्रमुख हैं:

• crypto/aes — Advanced Encryption Standard (AES) का कार्यान्वयन।
• crypto/cipher — एन्क्रिप्शन मोड (CBC, GCM, CTR) के लिए इंटरफ़ेस।
• crypto/rsa — असममित RSA एन्क्रिप्शन।
• crypto/sha256, crypto/sha512 — SHA-2 परिवार के हैश फ़ंक्शन।
• golang.org/x/crypto/bcrypt — पासवर्ड का अनुकूली हैशिंग (अतिरिक्त पैकेज)।
• crypto/rand — क्रिप्टोग्राफ़िक रूप से सुरक्षित यादृच्छिक संख्या जनरेटर।

Go में सममित AES एन्क्रिप्शन

सममित एन्क्रिप्शन एन्क्रिप्ट और डिक्रिप्ट करने के लिए एक ही कुंजी का उपयोग करता है। आइए GCM (Galois/Counter Mode) मोड में AES-256 के साथ एक उदाहरण देखें, जो डेटा प्रमाणीकरण प्रदान करता है।

package main

import (    "crypto/aes"    "crypto/cipher"    "crypto/rand"    "encoding/hex"    "fmt"    "io")

func encryptAES(plaintext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    // GCM (Galois/Counter Mode) बनाएँ    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    // एक यादृच्छिक nonce (एक बार उपयोग की जाने वाली संख्या) उत्पन्न करें    nonce := make([]byte, gcm.NonceSize())    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {        return nil, err    }

    // Seal एन्क्रिप्टेड टेक्स्ट की शुरुआत में nonce जोड़ता है    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)    return ciphertext, nil}

func decryptAES(ciphertext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    nonceSize := gcm.NonceSize()    if len(ciphertext) < nonceSize {        return nil, fmt.Errorf("ciphertext too short")    }

    nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]    plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)    if err != nil {        return nil, err    }    return plaintext, nil}

func main() {    key := []byte("examplekey123456") // AES-128 के लिए 16 बाइट    plaintext := []byte("PythonLib के लिए गुप्त डेटा")

    encrypted, _ := encryptAES(plaintext, key)    fmt.Println("एन्क्रिप्टेड (hex):", hex.EncodeToString(encrypted))

    decrypted, _ := decryptAES(encrypted, key)    fmt.Println("डिक्रिप्टेड:", string(decrypted))}

ध्यान दें: कुंजी AES-128, AES-192 या AES-256 के लिए क्रमशः 16, 24 या 32 बाइट लंबी होनी चाहिए। Nonce (IV) यादृच्छिक रूप से उत्पन्न होता है और सिफरटेक्स्ट के साथ संग्रहीत किया जाता है।

Go में असममित RSA एन्क्रिप्शन

RSA कुंजियों की एक जोड़ी का उपयोग करता है: एन्क्रिप्शन के लिए सार्वजनिक (public) और डिक्रिप्शन के लिए निजी (private)। यह सर्वर और क्लाइंट के बीच सुरक्षित डेटा आदान-प्रदान के लिए आदर्श है।

package main

import (    "crypto/rand"    "crypto/rsa"    "crypto/sha256"    "fmt")

func generateKeyPair(bits int) (*rsa.PrivateKey, error) {