से मैं crypto/rsa उपयोग कर रहा हूँ, और के लिए एक रास्ता ठीक से बचाने के लिए और एक कुंजी लोड खोजने की कोशिश कर आरएसए PrivateKey। से []byte बनाने का कोई सही तरीका है। यदि हां, तो क्या rsa.PublicKey के लिए ठीक से ऐसा करने का कोई तरीका है?सहेजें और लोड क्रिप्टो/करने के लिए और डिस्क
आपको बहुत बहुत धन्यवाद।
आपको मार्शल कुंजी में किसी प्रकार का प्रारूप चाहिए। एक प्रारूप जाओ मानक पुस्तकालय द्वारा समर्थित यहां पाया जा सकता: http://golang.org/pkg/crypto/x509/#MarshalPKCS1PrivateKey
func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte
उलटा समारोह http://golang.org/pkg/crypto/x509/#ParsePKCS1PrivateKey है।
func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error)
हालांकि, यह एक पीईएम फ़ाइल में मार्शल कुंजी एन्कोड करने के लिए अपेक्षाकृत मानक है।
pemdata := pem.EncodeToMemory(
&pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(key),
},
)
आप एक पूर्ण उदाहरण here पा सकते हैं।
के बाद से अपने प्रश्न की सार्वजनिक कुंजी हिस्सा उत्तर नहीं दिया गया और मैं बस एक ही समस्या में पड़ गए और इसे हल, यहाँ यह है:
नोट तर्क के सामने &MarshalPKIXPublicKey
Priv := rsa.GenerateKey(rand.Reader, 4096)
PubASN1, err := x509.MarshalPKIXPublicKey(&Priv.PublicKey)
if err != nil {
// do something about it
}
pubBytes = pem.EncodeToMemory(&pem.Block{
Type: "RSA PUBLIC KEY",
Bytes: PubASN1,
})
ioutil.WriteFile("key.pub", PubBytes, 0644)
प्रासंगिक पढ़ता है:
पुनश्च: MarshalPKIXPublicKey भी ECDSA चाबियाँ, ajust स्वीकार करता है उचित पेम हेडर।
यहां कोड स्निपेट है जो सार्वजनिक और निजी दोनों कुंजीों के आयात और निर्यात को दिखाता है। यह उन अन्य उत्तरों पर आधारित है जो सुपर सहायक थे, साथ ही आधिकारिक दस्तावेज़ों से कॉपी-पास्ता भी थे।
package main
import (
"crypto/rand"
"crypto/rsa"
"crypto/x509"
"encoding/pem"
"errors"
"fmt"
)
func GenerateRsaKeyPair() (*rsa.PrivateKey, *rsa.PublicKey) {
privkey, _ := rsa.GenerateKey(rand.Reader, 4096)
return privkey, &privkey.PublicKey
}
func ExportRsaPrivateKeyAsPemStr(privkey *rsa.PrivateKey) string {
privkey_bytes := x509.MarshalPKCS1PrivateKey(privkey)
privkey_pem := pem.EncodeToMemory(
&pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: privkey_bytes,
},
)
return string(privkey_pem)
}
func ParseRsaPrivateKeyFromPemStr(privPEM string) (*rsa.PrivateKey, error) {
block, _ := pem.Decode([]byte(privPEM))
if block == nil {
return nil, errors.New("failed to parse PEM block containing the key")
}
priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return priv, nil
}
func ExportRsaPublicKeyAsPemStr(pubkey *rsa.PublicKey) (string, error) {
pubkey_bytes, err := x509.MarshalPKIXPublicKey(pubkey)
if err != nil {
return "", err
}
pubkey_pem := pem.EncodeToMemory(
&pem.Block{
Type: "RSA PUBLIC KEY",
Bytes: pubkey_bytes,
},
)
return string(pubkey_pem), nil
}
func ParseRsaPublicKeyFromPemStr(pubPEM string) (*rsa.PublicKey, error) {
block, _ := pem.Decode([]byte(pubPEM))
if block == nil {
return nil, errors.New("failed to parse PEM block containing the key")
}
pub, err := x509.ParsePKIXPublicKey(block.Bytes)
if err != nil {
return nil, err
}
switch pub := pub.(type) {
case *rsa.PublicKey:
return pub, nil
default:
break // fall through
}
return nil, errors.New("Key type is not RSA")
}
func main() {
// Create the keys
priv, pub := GenerateRsaKeyPair()
// Export the keys to pem string
priv_pem := ExportRsaPrivateKeyAsPemStr(priv)
pub_pem, _ := ExportRsaPublicKeyAsPemStr(pub)
// Import the keys from pem string
priv_parsed, _ := ParseRsaPrivateKeyFromPemStr(priv_pem)
pub_parsed, _ := ParseRsaPublicKeyFromPemStr(pub_pem)
// Export the newly imported keys
priv_parsed_pem := ExportRsaPrivateKeyAsPemStr(priv_parsed)
pub_parsed_pem, _ := ExportRsaPublicKeyAsPemStr(pub_parsed)
fmt.Println(priv_parsed_pem)
fmt.Println(pub_parsed_pem)
// Check that the exported/imported keys match the original keys
if priv_pem != priv_parsed_pem || pub_pem != pub_parsed_pem {
fmt.Println("Failure: Export and Import did not result in same Keys")
} else {
fmt.Println("Success")
}
}
अंत में आपके सत्यापन के साथ थोड़ा समस्या: स्थिति '||' '' '' '' '' '' 'नहीं होनी चाहिए – Max
और सार्वजनिक हिस्सा? –