Come crittografare e decodificare il testo normale con una chiave RSA in Go?

Question

Sto provando a scrivere un programma di utilità che crittografa e decifra file di testo normale usando una coppia di chiavi RSA. Le chiavi RSA sono state generate con ssh-keygen e sono memorizzate in .ssh, come al solito.

Non riesco a capire come farlo con i pacchetti crypto e crypto/rsa della lingua Go? La documentazione su questi è un po 'scarsa (ancor più perché sono nuovo alla crittografia) e ci sono pochissimi esempi. Ho controllato il file rsa_test.go per qualsiasi indizio, ma mi ha solo confuso di più.

In breve, sto cercando di caricare la coppia di chiavi pubblica/privata dai file id_rsa e id_rsa.pub in .ssh e usarli per crittografare/decrittografare un file di testo.

Grazie in anticipo!

Answer 1

Ricordare che RSA non è progettato per essere un codice a blocchi. Solitamente RSA viene utilizzato per crittografare una chiave simmetrica che viene poi utilizzata per crittografare i dati. Con questo in mente, però, ecco un programma che può utilizzare una chiave privata RSA per crittografare i dati che possono essere decifrati da solo:

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) 
    } 
}