गो में आरएसए कुंजी के साथ सादे पाठ को एन्क्रिप्ट और डिक्रिप्ट कैसे करें?

Question

मैं एक उपयोगिता प्रोग्राम लिखने की कोशिश कर रहा हूं जो आरएसए कुंजी जोड़ी का उपयोग करके सादा पाठ फ़ाइलों को एन्क्रिप्ट और डिक्रिप्ट करता है। आरएसए कुंजी एसएसएच-कीजेन के साथ उत्पन्न की गई थी और सामान्य रूप से .ssh में संग्रहीत होती है।

मुझे यह समझने में परेशानी हो रही है कि गो भाषा क्रिप्टो और क्रिप्टो/आरएसए पैकेज के साथ ऐसा कैसे किया जाए? उन पर प्रलेखन थोड़ा विचित्र है (और भी इसलिए क्योंकि मैं एन्क्रिप्शन के लिए नया हूं) और बहुत कम उदाहरण हैं। मैंने किसी भी सुराग के लिए rsa_test.go फ़ाइल की जांच की, लेकिन यह केवल मुझे और भ्रमित कर दिया।

संक्षेप में मैं idsrsa और id_rsa.pub फ़ाइलों से .ssh में सार्वजनिक/निजी कुंजी जोड़ी लोड करने का प्रयास कर रहा हूं और उन्हें सादे पाठ फ़ाइल को एन्क्रिप्ट/डिक्रिप्ट करने के लिए उपयोग कर रहा हूं।

अग्रिम धन्यवाद!

Answer 1

ध्यान रखें कि आरएसए को ब्लॉक साइफर होने के लिए डिज़ाइन नहीं किया गया है। आम तौर पर आरएसए का प्रयोग एक सममित कुंजी को एन्क्रिप्ट करने के लिए किया जाता है जिसे तब डेटा एन्क्रिप्ट करने के लिए उपयोग किया जाता है।

package main 

import (
    "crypto/rand" 
    "crypto/rsa" 
    "crypto/sha1" 
    "crypto/x509" 
    "encoding/pem" 
    "flag" 
    "io/ioutil" 
    "log" 
) 

// Command-line flags 
var (
    keyFile = flag.String("key", "id_rsa", "Path to RSA private key") 
    inFile = flag.String("in", "in.txt", "Path to input file") 
    outFile = flag.String("out", "out.txt", "Path to output file") 
    label = flag.String("label", "", "Label to use (filename by default)") 
    decrypt = flag.Bool("decrypt", false, "Decrypt instead of encrypting") 
) 

func main() { 
    flag.Parse() 

    // Read the input file 
    in, err := ioutil.ReadFile(*inFile) 
    if err != nil { 
     log.Fatalf("input file: %s", err) 
    } 

    // Read the private key 
    pemData, err := ioutil.ReadFile(*keyFile) 
    if err != nil { 
     log.Fatalf("read key file: %s", err) 
    } 

    // Extract the PEM-encoded data block 
    block, _ := pem.Decode(pemData) 
    if block == nil { 
     log.Fatalf("bad key data: %s", "not PEM-encoded") 
    } 
    if got, want := block.Type, "RSA PRIVATE KEY"; got != want { 
     log.Fatalf("unknown key type %q, want %q", got, want) 
    } 

    // Decode the RSA private key 
    priv, err := x509.ParsePKCS1PrivateKey(block.Bytes) 
    if err != nil { 
     log.Fatalf("bad private key: %s", err) 
    } 

    var out []byte 
    if *decrypt { 
     if *label == "" { 
      *label = *outFile 
     } 
     // Decrypt the data 
     out, err = rsa.DecryptOAEP(sha1.New(), rand.Reader, priv, in, []byte(*label)) 
     if err != nil { 
      log.Fatalf("decrypt: %s", err) 
     } 
    } else { 
     if *label == "" { 
      *label = *inFile 
     } 
     out, err = rsa.EncryptOAEP(sha1.New(), rand.Reader, &priv.PublicKey, in, []byte(*label)) 
     if err != nil { 
      log.Fatalf("encrypt: %s", err) 
     } 
    } 

    // Write data to output file 
    if err := ioutil.WriteFile(*outFile, out, 0600); err != nil { 
     log.Fatalf("write output: %s", err) 
    } 
}