Crear clave y certificado en Golang de la misma manera que lo hace OpenSSL para el host local.

Answer

1. 

   davy.ai

   July 13, 2023 at 8:40 pm

   Para codificar el equivalente al comando openssl anterior en Go, puedes usar el paquete de Go “crypto/x509” y “crypto/rsa” para generar el par de claves.

   Aquí tienes un ejemplo de código en Go:

   package main
   
   import (
       "crypto/rand"
       "crypto/rsa"
       "crypto/x509"
       "crypto/x509/pkix"
       "encoding/pem"
       "math/big"
       "net"
       "time"
   )
   
   func main() {
       // define los atributos del certificado
       plantilla := x509.Certificate{
           SerialNumber: big.NewInt(1),
           Subject: pkix.Name{
               Country:            []string{""},
               Province:           []string{""},
               Organization:       []string{""},
               Locality:           []string{""},
               CommonName:         "localhost",
           },
           NotBefore:             time.Now(),
           NotAfter:              time.Now().Add(3650 * 24 * time.Hour),
           KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
           ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
           BasicConstraintsValid: true,
           DNSNames:              []string{"localhost"},
           IPAddresses:           []net.IP{net.ParseIP("127.0.0.1")},
       }
   
       // genera un nuevo par de claves RSA
       clavePrivada, err := rsa.GenerateKey(rand.Reader, 4096)
       if err != nil {
           panic(err)
       }
   
       // crea un nuevo certificado
       bytesCertificado, err := x509.CreateCertificate(rand.Reader, &plantilla, &plantilla, &clavePrivada.PublicKey, clavePrivada)
       if err != nil {
           panic(err)
       }
   
       // codifica el certificado en formato PEM
       certPEM := pem.EncodeToMemory(&pem.Block{
           Type:  "CERTIFICATE",
           Bytes: bytesCertificado,
       })
   
       // codifica la clave privada en formato PEM
       keyPEM := pem.EncodeToMemory(&pem.Block{
           Type:  "RSA PRIVATE KEY",
           Bytes: x509.MarshalPKCS1PrivateKey(clavePrivada),
       })
   
       // escribe el certificado y la clave privada en archivos
       if err := guardarEnArchivo("test.crt", certPEM); err != nil {
           panic(err)
       }
       if err := guardarEnArchivo("test.key", keyPEM); err != nil {
           panic(err)
       }
   
       // Hecho
   }
   
   func guardarEnArchivo(nombreArchivo string, datos []byte) error {
       archivo, err := os.Create(nombreArchivo)
       if err != nil {
           return err
       }
       defer archivo.Close()
   
       _, err = archivo.Write(datos)
       if err != nil {
           return err
       }
   
       return nil
   }
   

   Este código genera un nuevo par de certificado y clave privada con los atributos dados, luego los codifica en formato PEM y los guarda en dos archivos llamados “test.crt” y “test.key”.

Comments are closed.