गो में ईसीडीएसए निजी कुंजी संग्रहीत करना

गो में ईसीडीएसए कुंजी जोड़े के साथ काम करते समय, निजी कुंजी को सुरक्षित रूप से संग्रहीत करने की आवश्यकता उत्पन्न होती है। जबकि एलिप्टिक.मार्शल विधि सार्वजनिक कुंजी के लिए एन्कोडिंग प्रदान करती है, निजी कुंजी के लिए कोई समकक्ष नहीं है। यह आलेख बताता है कि गो में निजी कुंजी को कैसे सहेजना और लोड करना है। ईसीडीएसए कुंजी एन्क्रिप्शन, मानक एन्कोडिंग और एक फ़ाइल प्रारूप। सामान्य संयोजन में कुंजी पीढ़ी के लिए ECDSA एल्गोरिथ्म, एन्कोडिंग के लिए X.509 और भंडारण के लिए PEM (गोपनीयता-उन्नत मेल) प्रारूप का उपयोग करना शामिल है।

कोड उदाहरण

निम्नलिखित कोड स्निपेट दर्शाता है कि Go में ECDSA कुंजियों को कैसे एनकोड और डीकोड किया जाए:

import ( "क्रिप्टो/ईसीडीएसए" "क्रिप्टो/अण्डाकार" "क्रिप्टो/रैंड" "क्रिप्टो/x509" "एन्कोडिंग/पीईएम" "एफएमटी" "प्रतिबिंबित होना" ) func एन्कोड(प्राइवेटकी *ecdsa.PrivateKey, publicKey *ecdsa.PublicKey) (स्ट्रिंग, स्ट्रिंग) { x509एन्कोडेड, _ := x509.MarshalECPrivateKey(privateKey) pemEncoded := pem.EncodeToMemory(&pem.Block{प्रकार: "निजी कुंजी", बाइट्स: x509Encoded}) x509EncodedPub, _ := x509.MarshalPKIXPublicKey(publicKey) pemEncodedPub := pem.EncodeToMemory(&pem.Block{प्रकार: "सार्वजनिक कुंजी", बाइट्स: x509EncodedPub}) रिटर्न स्ट्रिंग (pemEncoded), स्ट्रिंग (pemEncodedPub) } func डिकोड(pemEncoded स्ट्रिंग, pemEncodedPub स्ट्रिंग) (*ecdsa.PrivateKey, *ecdsa.PublicKey) { ब्लॉक, _ := pem.Decode([]बाइट(pemEncoded)) x509एन्कोडेड := ब्लॉक.बाइट्स प्राइवेटकी, _ := x509.ParseECPrivateKey(x509Encoded) ब्लॉकपब, _ := pem.Decode([]बाइट(pemEncodedPub)) x509EncodedPub := ब्लॉकपब.बाइट्स जेनेरिकपब्लिककी, _ := x509.ParsePKIXPublicKey(x509EncodedPub) publicKey :=genericPublicKey.(*ecdsa.PublicKey) प्राइवेटकी, पब्लिककी लौटाएं } फंक टेस्ट() { प्राइवेटकी, _ := ecdsa.GenerateKey(elliptic.P384(), rand.Reader) publicKey := &privateKey.PublicKey encPriv, encPub := एनकोड (निजी कुंजी, सार्वजनिक कुंजी) fmt.Println(encPriv) fmt.Println(encPub) priv2, पब2 := डिकोड(encPriv, encPub) यदि !reflect.DeepEqual(privateKey, priv2) { fmt.Println('निजी कुंजियाँ मेल नहीं खातीं।') } यदि !reflect.DeepEqual(publicKey, pub2) { fmt.Println('सार्वजनिक कुंजियाँ मेल नहीं खातीं।') } }परीक्षण फ़ंक्शन में:

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "reflect"
)

func encode(privateKey *ecdsa.PrivateKey, publicKey *ecdsa.PublicKey) (string, string) {
    x509Encoded, _ := x509.MarshalECPrivateKey(privateKey)
    pemEncoded := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: x509Encoded})

    x509EncodedPub, _ := x509.MarshalPKIXPublicKey(publicKey)
    pemEncodedPub := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: x509EncodedPub})

    return string(pemEncoded), string(pemEncodedPub)
}

func decode(pemEncoded string, pemEncodedPub string) (*ecdsa.PrivateKey, *ecdsa.PublicKey) {
    block, _ := pem.Decode([]byte(pemEncoded))
    x509Encoded := block.Bytes
    privateKey, _ := x509.ParseECPrivateKey(x509Encoded)

    blockPub, _ := pem.Decode([]byte(pemEncodedPub))
    x509EncodedPub := blockPub.Bytes
    genericPublicKey, _ := x509.ParsePKIXPublicKey(x509EncodedPub)
    publicKey := genericPublicKey.(*ecdsa.PublicKey)

    return privateKey, publicKey
}

func test() {
    privateKey, _ := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
    publicKey := &privateKey.PublicKey

    encPriv, encPub := encode(privateKey, publicKey)

    fmt.Println(encPriv)
    fmt.Println(encPub)

    priv2, pub2 := decode(encPriv, encPub)

    if !reflect.DeepEqual(privateKey, priv2) {
        fmt.Println("Private keys do not match.")
    }
    if !reflect.DeepEqual(publicKey, pub2) {
        fmt.Println("Public keys do not match.")
    }
}

1. पुनर्प्राप्त कुंजियों की तुलना की जाती है सत्यापित करने के लिए कि क्या वे मेल खाते हैं, मूल कुंजी। ]